effect-start 0.13.1 → 0.14.0

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "effect-start",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "type": "module",
   "license": "MIT",
   "exports": {
     ".": "./src/index.ts",
+    "./StartApp": "./src/StartApp.ts",
     "./FileRouter": "./src/FileRouter.ts",
     "./Route": "./src/Route.ts",
-    "./EncryptedCookies": "./src/EncryptedCookies.ts",
     "./bun": "./src/bun/index.ts",
     "./client": "./src/client/index.ts",
-    "./FileSystemExtra": "./src/FileSystemExtra.ts",
-    "./package.json": "./package.json",
-    "./jsx-runtime": "./src/jsx-runtime.ts",
-    "./jsx-dev-runtime": "./src/jsx-runtime.ts",
-    "./hyper": "./src/hyper/index.ts",
+    "./testing": "./src/testing/index.ts",
     "./x/*": "./src/x/*/index.ts",
     "./x/tailwind/plugin": "./src/x/tailwind/plugin.ts",
-    "./middlewares/BasicAuthMiddleware": "./src/middlewares/BasicAuthMiddleware.ts",
-    "./assets.d.ts": "./src/assets.d.ts"
+    "./middlewares": "./src/middlewares/index.ts",
+    "./experimental": "./src/experimental/index.ts",
+    "./assets.d.ts": "./src/assets.d.ts",
+    "./jsx-runtime": "./src/jsx-runtime.ts",
+    "./jsx-dev-runtime": "./src/jsx-runtime.ts",
+    "./package.json": "./package.json"
   },
   "scripts": {
     "format": "bunx dprint fmt",

package/src/Bundle.ts

@@ -6,7 +6,6 @@ import {
   PubSub,
 } from "effect"
 import * as Schema from "effect/Schema"
-import { importBlob } from "./JsModule.ts"
 
 export const BundleEntrypointMetaKey: unique symbol = Symbol.for(
   "effect-start/BundleEntrypointMetaKey",
@@ -131,37 +130,3 @@ export type Tag = Context.Tag<
 
 export class ClientBundle extends Tag("ClientBundle")<ClientBundle>() {}
 export class ServerBundle extends Tag("ServerBundle")<ServerBundle>() {}
-
-/**
- * Lodas a bundle as a javascript module.
- * Bundle must have only one entrypoint.
- */
-export function load<M>(
-  bundle: Effect.Effect<BundleContext, BundleError>,
-): Effect.Effect<M, BundleError> {
-  return Effect.gen(function*() {
-    const context = yield* bundle
-    const [artifact, ...rest] = Object.values(context.entrypoints)
-
-    if (rest.length > 0) {
-      return yield* Effect.fail(
-        new BundleError({
-          message: "Multiple entrypoints are not supported in load()",
-        }),
-      )
-    }
-
-    return yield* Effect.tryPromise({
-      try: () => {
-        const blob = context.getArtifact(artifact)
-
-        return importBlob<M>(blob!)
-      },
-      catch: (e) =>
-        new BundleError({
-          message: "Failed to load entrypoint",
-          cause: e,
-        }),
-    })
-  })
-}

package/src/BundleHttp.test.ts

@@ -1,16 +1,14 @@
 import * as HttpRouter from "@effect/platform/HttpRouter"
 import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
 import * as t from "bun:test"
-import {
-  Bundle,
-  BundleHttp,
-  effectFn,
-  TestHttpClient,
-} from "effect-start"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import IndexHtml from "../static/react-dashboard.html" with { type: "file" }
 import * as BunBundle from "./bun/BunBundle.ts"
+import * as Bundle from "./Bundle.ts"
+import * as BundleHttp from "./BundleHttp.ts"
+import { effectFn } from "./testing"
+import * as TestHttpClient from "./testing/TestHttpClient.ts"
 
 const effect = effectFn(
   Layer.effect(

package/src/BundleHttp.ts

@@ -13,7 +13,8 @@ import * as Stream from "effect/Stream"
 import * as NPath from "node:path"
 import * as NUrl from "node:url"
 import * as Bundle from "./Bundle.ts"
-import * as SseHttpResponse from "./SseHttpResponse.ts"
+import * as SseHttpResponse from "./experimental/SseHttpResponse.ts"
+
 
 const DefaultBundleEndpoint = "/_bundle"
 

package/src/Effect_HttpRouter.test.ts

@@ -7,9 +7,8 @@
 import * as HttpRouter from "@effect/platform/HttpRouter"
 import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
 import * as t from "bun:test"
-import * as Effect from "effect/Effect"
-import * as TestHttpClient from "../src/TestHttpClient.ts"
-import { effectFn } from "../src/testing.ts"
+import { effectFn } from "../src/testing"
+import * as TestHttpClient from "./testing/TestHttpClient.ts"
 
 const effect = effectFn()
 

package/src/FileHttpRouter.test.ts

@@ -7,8 +7,8 @@ import * as Effect from "effect/Effect"
 import * as FileHttpRouter from "./FileHttpRouter.ts"
 import * as FileRouter from "./FileRouter.ts"
 import * as Route from "./Route.ts"
-import * as TestHttpClient from "./TestHttpClient.ts"
-import { effectFn } from "./testing.ts"
+import { effectFn } from "./testing"
+import * as TestHttpClient from "./testing/TestHttpClient.ts"
 
 class CustomError extends Data.TaggedError("CustomError") {}
 

package/src/FileRouterCodegen.test.ts

@@ -12,7 +12,7 @@ import * as FileRouterCodegen from "./FileRouterCodegen.ts"
 import * as NodeFileSystem from "./NodeFileSystem.ts"
 import * as Route from "./Route.ts"
 import * as SchemaExtra from "./SchemaExtra.ts"
-import * as TestLogger from "./TestLogger.ts"
+import * as TestLogger from "./testing/TestLogger.ts"
 
 function createTempDirWithFiles(
   files: Record<string, string>,

package/src/FileRouter_files.test.ts

@@ -2,7 +2,7 @@ import * as t from "bun:test"
 import { MemoryFileSystem } from "effect-memfs"
 import * as Effect from "effect/Effect"
 import * as FileRouter from "./FileRouter.ts"
-import { effectFn } from "./testing.ts"
+import { effectFn } from "./testing"
 
 const Files = {
   "/routes/about/layer.tsx": "",

package/src/HttpAppExtra.test.ts

@@ -7,7 +7,7 @@ import {
 } from "effect"
 import * as Cause from "effect/Cause"
 import * as HttpAppExtra from "./HttpAppExtra.ts"
-import { effectFn } from "./testing.ts"
+import { effectFn } from "./testing"
 
 const mockRequest = HttpServerRequest.HttpServerRequest.of({
   url: "http://localhost:3000/test",

package/src/Start.ts

@@ -3,48 +3,14 @@ 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 Config from "effect/Config"
 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 * as BunBundle from "./bun/BunBundle.ts"
 import * as BunHttpServer from "./bun/BunHttpServer.ts"
-import * as BunRoute from "./bun/BunRoute.ts"
 import * as BunRuntime from "./bun/BunRuntime.ts"
-import * as Bundle from "./Bundle.ts"
-import * as BundleHttp from "./BundleHttp.ts"
-import * as HttpAppExtra from "./HttpAppExtra.ts"
 import * as NodeFileSystem from "./NodeFileSystem.ts"
-import * as Router from "./Router.ts"
 import * as StartApp from "./StartApp.ts"
 
-export function bundleClient(config: BunBundle.BuildOptions | string) {
-  const clientLayer = Layer.effect(
-    Bundle.ClientBundle,
-    Function.pipe(
-      BunBundle.buildClient(config),
-      Bundle.handleBundleErrorSilently,
-    ),
-  )
-  const assetsLayer = Layer.effectDiscard(Effect.gen(function*() {
-    const router = yield* HttpRouter.Default
-    const app = BundleHttp.toHttpApp(Bundle.ClientBundle)
-
-    yield* router.mountApp(
-      "/_bundle",
-      // we need to use as any here because HttpRouter.Default
-      // only accepts default services.
-      app as any,
-    )
-  }))
-
-  return Layer.mergeAll(
-    clientLayer,
-    assetsLayer,
-  )
-}
-
 export function layer<
   Layers extends [
     Layer.Layer<never, any, any>,

package/src/StartApp.ts

@@ -3,23 +3,22 @@ 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 PubSub from "effect/PubSub"
 import * as Ref from "effect/Ref"
 
-type NewType = HttpApp.Default<never, never>
-
 type StartMiddleware = <E, R>(
   self: HttpApp.Default<E, R>,
-) => NewType
+) => HttpApp.Default<never, never>
 
 export class StartApp extends Context.Tag("effect-start/StartApp")<
   StartApp,
   {
     readonly env: "development" | "production" | string
-    readonly relativeUrlRoot?: string
     readonly addMiddleware: (
       middleware: StartMiddleware,
     ) => Effect.Effect<void>
     readonly middleware: Ref.Ref<StartMiddleware>
+    readonly events: PubSub.PubSub<any>
   }
 >() {
 }
@@ -27,17 +26,22 @@ export class StartApp extends Context.Tag("effect-start/StartApp")<
 export function layer(options?: {
   env?: string
 }) {
-  return Layer.sync(StartApp, () => {
-    const env = options?.env ?? process.env.NODE_ENV ?? "development"
-    const middleware = Ref.unsafeMake(
-      Function.identity as StartMiddleware,
-    )
+  return Layer.effect(
+    StartApp,
+    Effect.gen(function*() {
+      const env = options?.env ?? process.env.NODE_ENV ?? "development"
+      const middleware = yield* Ref.make(
+        Function.identity as StartMiddleware,
+      )
+      const events = yield* PubSub.unbounded()
 
-    return StartApp.of({
-      env,
-      middleware,
-      addMiddleware: (f) =>
-        Ref.update(middleware, (prev) => (app) => f(prev(app))),
-    })
-  })
+      return StartApp.of({
+        env,
+        middleware,
+        addMiddleware: (f) =>
+          Ref.update(middleware, (prev) => (app) => f(prev(app))),
+        events,
+      })
+    }),
+  )
 }

package/src/bun/BunBundle.test.ts

@@ -7,7 +7,7 @@ import * as NOS from "node:os"
 import * as NPath from "node:path"
 import * as Bundle from "../Bundle.ts"
 import * as BundleHttp from "../BundleHttp.ts"
-import * as TestHttpClient from "../TestHttpClient.ts"
+import * as TestHttpClient from "../testing/TestHttpClient.ts"
 import * as BunBundle from "./BunBundle.ts"
 
 t.describe("BunBundle manifest structure", () => {

package/src/bun/BunBundle_imports.test.ts

@@ -1,5 +1,5 @@
 import * as t from "bun:test"
-import { effectFn } from "../testing.ts"
+import { effectFn } from "../testing"
 import * as BunBundle from "./BunBundle.ts"
 import * as BunImportTrackerPlugin from "./BunImportTrackerPlugin.ts"
 
@@ -35,7 +35,7 @@ t.it("imports", () =>
           },
           {
             kind: "import-statement",
-            path: "src/testing.ts",
+            path: "src/testing",
           },
           {
             kind: "import-statement",

package/src/bun/BunRoute_bundles.test.ts

@@ -2,7 +2,7 @@ import * as t from "bun:test"
 import * as Effect from "effect/Effect"
 import * as Route from "../Route.ts"
 import * as Router from "../Router.ts"
-import * as TestHttpClient from "../TestHttpClient.ts"
+import * as TestHttpClient from "../testing/TestHttpClient.ts"
 import * as BunHttpServer from "./BunHttpServer.ts"
 import * as BunRoute from "./BunRoute.ts"
 

package/src/{SseHttpResponse.ts → experimental/SseHttpResponse.ts}

@@ -4,7 +4,8 @@ import * as Effect from "effect/Effect"
 import * as Function from "effect/Function"
 import * as Schedule from "effect/Schedule"
 import * as Stream from "effect/Stream"
-import * as StreamExtra from "./StreamExtra.ts"
+import * as StreamExtra from "../StreamExtra.ts"
+
 
 const DefaultHeartbeatInterval = Duration.seconds(5)
 

package/src/experimental/index.ts

@@ -0,0 +1,2 @@
+export * as EncryptedCookies from "./EncryptedCookies.ts"
+export * as SseHttpResponse from "./SseHttpResponse.ts"

package/src/index.ts

@@ -1,24 +1,6 @@
-export * as Bundle from "./Bundle.ts"
-export * as BundleHttp from "./BundleHttp.ts"
-
-export * as StartHttp from "./StartHttp.ts"
-
-export * as HttpAppExtra from "./HttpAppExtra.ts"
-
-export * as PublicDirectory from "./PublicDirectory.ts"
-
-export * as TestHttpClient from "./TestHttpClient.ts"
-export {
-  effectFn,
-} from "./testing.ts"
+export * as Start from "./Start.ts"
 
-export * as FileHttpRouter from "./FileHttpRouter.ts"
 export * as FileRouter from "./FileRouter.ts"
-
 export * as Route from "./Route.ts"
-export * as Router from "./Router.ts"
 
-export * as Start from "./Start.ts"
-
-export * as Hyper from "./Hyper.ts"
-export * as HyperHtml from "./HyperHtml.ts"
+export * as Bundle from "./Bundle.ts"

package/src/middlewares/index.ts

@@ -0,0 +1 @@
+export * as BasicAuthMiddleware from "./BasicAuthMiddleware.ts"

package/src/{TestHttpClient.test.ts → testing/TestHttpClient.test.ts}

@@ -2,8 +2,8 @@ import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
 import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
 import * as t from "bun:test"
 import * as Effect from "effect/Effect"
+import { effectFn } from "./index.ts"
 import * as TestHttpClient from "./TestHttpClient.ts"
-import { effectFn } from "./testing.ts"
 
 const App = Effect.gen(function*() {
   const req = yield* HttpServerRequest.HttpServerRequest

package/src/{TestHttpClient.ts → testing/TestHttpClient.ts}

@@ -10,7 +10,6 @@ import * as UrlParams from "@effect/platform/UrlParams"
 import * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
 import * as Function from "effect/Function"
-import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 
 const WebHeaders = globalThis.Headers

package/src/testing/index.ts

@@ -0,0 +1,3 @@
+export * as TestHttpClient from "./TestHttpClient.ts"
+export * as TestLogger from "./TestLogger.ts"
+export * from "./utils.ts"

package/src/x/tailwind/TailwindPlugin.ts

@@ -44,21 +44,22 @@ export const make = (opts?: {
       // (imported path) -> (importer paths)
       const importDescendants = new Map<string, Set<string>>()
 
-      if (opts?.scanPath) {
-        const candidates = await scanFiles(opts.scanPath)
+      const prepopulateCandidates = opts?.scanPath
+        ? async () => {
+          const candidates = await scanFiles(opts.scanPath!)
 
-        candidates.forEach(candidate => scannedCandidates.add(candidate))
-      }
+          scannedCandidates.clear()
 
-      /**
-       * Track import relationships when dynamically scanning
-       * from tailwind entrypoints.
-       *
-       * As of Bun 1.3 this pathway break for Bun Full-Stack server.
-       * Better to pass scanPath explicitly.
-       * @see https://github.com/oven-sh/bun/issues/20877
-       */
-      if (!opts?.scanPath) {
+          candidates.forEach(candidate => scannedCandidates.add(candidate))
+        }
+        : null
+
+      // Track import relationships when dynamically scanning
+      // from tailwind entrypoints.
+      // As of Bun 1.3 this pathway break for Bun Full-Stack server.
+      // Better to pass scanPath explicitly.
+      // @see https://github.com/oven-sh/bun/issues/20877
+      if (!prepopulateCandidates) {
         builder.onResolve({
           filter: /.*/,
         }, (args) => {
@@ -130,14 +131,15 @@ export const make = (opts?: {
           onDependency: (path) => {},
         })
 
+        await prepopulateCandidates?.()
+
         // wait for other files to be loaded so we can collect class name candidates
         await args.defer()
 
-        const candidates = new Set<string>()
+        const candidates = new Set<string>(scannedCandidates)
 
-        scannedCandidates.forEach(candidate => candidates.add(candidate))
-
-        {
+        // when we scan a path, we don't need to track candidate tree
+        if (!prepopulateCandidates) {
           const pendingModules = [
             // get class name candidates from all modules that import this one
             ...(importAncestors.get(args.path) ?? []),
@@ -295,6 +297,10 @@ async function scanFiles(dir: string): Promise<Set<string>> {
       absolute: true,
     })
   ) {
+    if (filePath.includes("/node_modules/")) {
+      continue
+    }
+
     const contents = await Bun.file(filePath).text()
     const classNames = extractClassNames(contents)
 

package/src/JsModule.test.ts

@@ -1,14 +0,0 @@
-import * as t from "bun:test"
-import * as JsModule from "./JsModule.ts"
-
-t.describe(`${JsModule.importSource.name}`, () => {
-  t.it("imports a string", async () => {
-    const mod = await JsModule.importSource<any>(`
-      export const b = "B"
-    `)
-
-    t
-      .expect(mod.b)
-      .toBe("B")
-  })
-})

package/src/JsModule.ts

@@ -1,116 +0,0 @@
-import * as Array from "effect/Array"
-import * as Function from "effect/Function"
-import * as Iterable from "effect/Iterable"
-import * as Order from "effect/Order"
-import * as Record from "effect/Record"
-import * as NFS from "node:fs"
-import * as NFSP from "node:fs/promises"
-import * as NPath from "node:path"
-import * as process from "node:process"
-
-/**
- * Imports a blob as a module.
- * Useful for loading code from build artifacts.
- *
- * Temporary files are wrriten to closest node_modules/ for node resolver
- * to pick up dependencies correctly and to avoid arbitrary file watchers
- * from detecting them.
- */
-export async function importBlob<M = unknown>(
-  blob: Blob,
-  entrypoint = "index.js",
-): Promise<M> {
-  return await importBundle({
-    [entrypoint]: blob,
-  }, entrypoint)
-}
-
-/**
- * Imports an entrypoint from multiple blobs.
- * Useful for loading code from build artifacts.
- *
- * Temporary files are wrriten to closest node_modules/ for node resolver
- * to pick up dependencies correctly and to avoid arbitrary file watchers
- * from detecting them.
- *
- * WARNING: dynamic imports that happened after this function will fail
- */
-export async function importBundle<M = unknown>(
-  blobs: {
-    [path: string]: Blob
-  },
-  entrypoint: string,
-  basePath = findNodeModules() + "/.tmp",
-): Promise<M> {
-  const sortedBlobs = Function.pipe(
-    blobs,
-    Record.toEntries,
-    Array.sortWith(v => v[0], Order.string),
-    Array.map(v => v[1]),
-  )
-  const bundleBlob = new Blob(sortedBlobs)
-  const hashPrefix = await hashBuffer(await bundleBlob.arrayBuffer())
-    .then(v => v.slice(0, 8))
-  const dir = `${basePath}/effect-start-${hashPrefix}`
-
-  await NFSP.mkdir(dir, { recursive: true })
-
-  await Promise.all(Function.pipe(
-    blobs,
-    Record.toEntries,
-    Array.map(([path, blob]) => {
-      const fullPath = `${dir}/${path}`
-
-      return blob
-        .arrayBuffer()
-        .then(v => NFSP.writeFile(fullPath, Buffer.from(v)))
-    }),
-  ))
-
-  const bundleModule = await import(`${dir}/${entrypoint}`)
-
-  await NFSP
-    .rmdir(dir, { recursive: true })
-    // if called concurrently, file sometimes may be deleted
-    // safe ignore when this happens
-    .catch(() => {})
-
-  return bundleModule
-}
-
-export function findNodeModules(startDir = process.cwd()) {
-  let currentDir = NPath.resolve(startDir)
-
-  while (currentDir !== NPath.parse(currentDir).root) {
-    const nodeModulesPath = NPath.join(currentDir, "node_modules")
-    if (
-      NFS.statSync(nodeModulesPath).isDirectory()
-    ) {
-      return nodeModulesPath
-    }
-
-    currentDir = NPath.dirname(currentDir)
-  }
-
-  return null
-}
-
-/**
- * Loads a JS module from a string using data: import
- */
-export async function importSource<M = unknown>(
-  code: string,
-): Promise<M> {
-  const dataUrl = `data:text/javascript,${encodeURIComponent(code)}`
-  return await import(dataUrl)
-}
-
-async function hashBuffer(buffer: BufferSource) {
-  const hashBuffer = await crypto.subtle.digest("SHA-256", buffer)
-
-  return Function.pipe(
-    new Uint8Array(hashBuffer),
-    Iterable.map(b => b.toString(16).padStart(2, "0")),
-    Iterable.reduce("", (a, b) => a + b),
-  )
-}

package/src/PublicDirectory.test.ts

@@ -1,280 +0,0 @@
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
-import * as t from "bun:test"
-import { MemoryFileSystem } from "effect-memfs"
-import {
-  effectFn,
-  TestHttpClient,
-} from "effect-start"
-import * as Effect from "effect/Effect"
-import * as PublicDirectory from "./PublicDirectory.ts"
-
-const TestFiles = {
-  "/test-public/index.html": "<html><body>Hello World</body></html>",
-  "/test-public/style.css": "body { color: red; }",
-  "/test-public/script.js": "console.log('hello');",
-  "/test-public/data.json": "{\"message\": \"test\"}",
-  "/test-public/image.png": "fake-png-data",
-  "/test-public/nested/file.txt": "nested content",
-}
-
-const effect = effectFn()
-
-t.it("serves index.html for root path", () => {
-  effect(function*() {
-    const app = PublicDirectory.make({ directory: "/test-public" })
-    const Client = TestHttpClient.make(app)
-
-    const res = yield* Client.get("/").pipe(
-      Effect.provide(MemoryFileSystem.layerWith(TestFiles)),
-    )
-
-    t
-      .expect(
-        res.status,
-      )
-      .toBe(200)
-
-    const body = yield* res.text
-    t
-      .expect(
-        body,
-      )
-      .toBe("<html><body>Hello World</body></html>")
-
-    t
-      .expect(
-        res.headers["content-type"],
-      )
-      .toBe("text/html")
-  })
-})
-
-t.it("serves CSS files with correct content type", () => {
-  effect(function*() {
-    const app = PublicDirectory.make({ directory: "/test-public" })
-    const Client = TestHttpClient.make(app)
-
-    const res = yield* Client.get("/style.css").pipe(
-      Effect.provide(MemoryFileSystem.layerWith(TestFiles)),
-    )
-
-    t
-      .expect(
-        res.status,
-      )
-      .toBe(200)
-
-    const body = yield* res.text
-    t
-      .expect(
-        body,
-      )
-      .toBe("body { color: red; }")
-
-    t
-      .expect(
-        res.headers["content-type"],
-      )
-      .toBe("text/css")
-  })
-})
-
-t.it("serves JavaScript files with correct content type", () => {
-  effect(function*() {
-    const app = PublicDirectory.make({ directory: "/test-public" })
-    const Client = TestHttpClient.make(app)
-
-    const res = yield* Client.get("/script.js").pipe(
-      Effect.provide(MemoryFileSystem.layerWith(TestFiles)),
-    )
-
-    t
-      .expect(
-        res.status,
-      )
-      .toBe(200)
-
-    const body = yield* res.text
-    t
-      .expect(
-        body,
-      )
-      .toBe("console.log('hello');")
-
-    t
-      .expect(
-        res.headers["content-type"],
-      )
-      .toBe("application/javascript")
-  })
-})
-
-t.it("serves JSON files with correct content type", () => {
-  effect(function*() {
-    const app = PublicDirectory.make({ directory: "/test-public" })
-    const Client = TestHttpClient.make(app)
-
-    const res = yield* Client.get("/data.json").pipe(
-      Effect.provide(MemoryFileSystem.layerWith(TestFiles)),
-    )
-
-    t
-      .expect(
-        res.status,
-      )
-      .toBe(200)
-
-    const body = yield* res.text
-    t
-      .expect(
-        body,
-      )
-      .toBe("{\"message\": \"test\"}")
-
-    t
-      .expect(
-        res.headers["content-type"],
-      )
-      .toBe("application/json")
-  })
-})
-
-t.it("serves nested files", () => {
-  effect(function*() {
-    const app = PublicDirectory.make({ directory: "/test-public" })
-    const Client = TestHttpClient.make(app)
-
-    const res = yield* Client.get("/nested/file.txt").pipe(
-      Effect.provide(MemoryFileSystem.layerWith(TestFiles)),
-    )
-
-    t
-      .expect(
-        res.status,
-      )
-      .toBe(200)
-
-    const body = yield* res.text
-    t
-      .expect(
-        body,
-      )
-      .toBe("nested content")
-
-    t
-      .expect(
-        res.headers["content-type"],
-      )
-      .toBe("text/plain")
-  })
-})
-
-t.it("returns 404 for non-existent files", () => {
-  effect(function*() {
-    const app = PublicDirectory.make({ directory: "/test-public" })
-    const Client = TestHttpClient.make(app)
-
-    const res = yield* Client.get("/nonexistent.txt").pipe(
-      Effect.provide(MemoryFileSystem.layerWith(TestFiles)),
-      Effect.catchTag(
-        "RouteNotFound",
-        () => HttpServerResponse.empty({ status: 404 }),
-      ),
-    )
-
-    t
-      .expect(
-        res.status,
-      )
-      .toBe(404)
-  })
-})
-
-t.it("prevents directory traversal attacks", () => {
-  effect(function*() {
-    const app = PublicDirectory.make({ directory: "/test-public" })
-    const Client = TestHttpClient.make(app)
-
-    const res = yield* Client.get("/../../../etc/passwd").pipe(
-      Effect.provide(MemoryFileSystem.layerWith(TestFiles)),
-      Effect.catchTag(
-        "RouteNotFound",
-        () => HttpServerResponse.empty({ status: 404 }),
-      ),
-    )
-
-    t
-      .expect(
-        res.status,
-      )
-      .toBe(404)
-  })
-})
-
-t.it("works with custom prefix", () => {
-  effect(function*() {
-    const app = PublicDirectory.make({
-      directory: "/test-public",
-      prefix: "/static",
-    })
-    const Client = TestHttpClient.make(app)
-
-    const res = yield* Client.get("/static/style.css").pipe(
-      Effect.provide(MemoryFileSystem.layerWith(TestFiles)),
-    )
-
-    t
-      .expect(
-        res.status,
-      )
-      .toBe(200)
-
-    const body = yield* res.text
-    t
-      .expect(
-        body,
-      )
-      .toBe("body { color: red; }")
-  })
-})
-
-t.it("ignores requests without prefix when prefix is set", () => {
-  effect(function*() {
-    const app = PublicDirectory.make({
-      directory: "/test-public",
-      prefix: "/static",
-    })
-    const Client = TestHttpClient.make(app)
-
-    const res = yield* Client.get("/style.css").pipe(
-      Effect.provide(MemoryFileSystem.layerWith(TestFiles)),
-      Effect.catchTag(
-        "RouteNotFound",
-        () => HttpServerResponse.empty({ status: 404 }),
-      ),
-    )
-
-    t
-      .expect(
-        res.status,
-      )
-      .toBe(404)
-  })
-})
-
-t.it("sets cache control headers", () => {
-  effect(function*() {
-    const app = PublicDirectory.make({ directory: "/test-public" })
-    const Client = TestHttpClient.make(app)
-
-    const res = yield* Client.get("/style.css").pipe(
-      Effect.provide(MemoryFileSystem.layerWith(TestFiles)),
-    )
-
-    t
-      .expect(
-        res.headers["cache-control"],
-      )
-      .toBe("public, max-age=3600")
-  })
-})

package/src/PublicDirectory.ts

@@ -1,108 +0,0 @@
-import * as FileSystem from "@effect/platform/FileSystem"
-import * as HttpApp from "@effect/platform/HttpApp"
-import { RouteNotFound } from "@effect/platform/HttpServerError"
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
-import * as Effect from "effect/Effect"
-import * as Function from "effect/Function"
-import * as NPath from "node:path"
-
-export interface PublicDirectoryOptions {
-  readonly directory?: string
-  readonly prefix?: string
-}
-
-export const make = (
-  options: PublicDirectoryOptions = {},
-): HttpApp.Default<RouteNotFound, FileSystem.FileSystem> =>
-  Effect.gen(function*() {
-    const request = yield* HttpServerRequest.HttpServerRequest
-    const fs = yield* FileSystem.FileSystem
-
-    const directory = options.directory ?? NPath.join(process.cwd(), "public")
-    const prefix = options.prefix ?? ""
-
-    let pathname = request.url
-
-    if (prefix && !pathname.startsWith(prefix)) {
-      return yield* Effect.fail(new RouteNotFound({ request }))
-    }
-
-    if (prefix) {
-      pathname = pathname.slice(prefix.length)
-    }
-
-    if (pathname.startsWith("/")) {
-      pathname = pathname.slice(1)
-    }
-
-    if (pathname === "") {
-      pathname = "index.html"
-    }
-
-    const filePath = NPath.join(directory, pathname)
-
-    if (!filePath.startsWith(directory)) {
-      return yield* Effect.fail(new RouteNotFound({ request }))
-    }
-
-    const exists = yield* Function.pipe(
-      fs.exists(filePath),
-      Effect.catchAll(() => Effect.succeed(false)),
-    )
-
-    if (!exists) {
-      return yield* Effect.fail(new RouteNotFound({ request }))
-    }
-
-    const stat = yield* Function.pipe(
-      fs.stat(filePath),
-      Effect.catchAll(() => Effect.fail(new RouteNotFound({ request }))),
-    )
-
-    if (stat.type !== "File") {
-      return yield* Effect.fail(new RouteNotFound({ request }))
-    }
-
-    const content = yield* Function.pipe(
-      fs.readFile(filePath),
-      Effect.catchAll(() => Effect.fail(new RouteNotFound({ request }))),
-    )
-
-    const mimeType = getMimeType(filePath)
-
-    return HttpServerResponse.uint8Array(content, {
-      headers: {
-        "Content-Type": mimeType,
-        "Cache-Control": "public, max-age=3600",
-      },
-    })
-  })
-
-function getMimeType(filePath: string): string {
-  const ext = NPath.extname(filePath).toLowerCase()
-
-  const mimeTypes: Record<string, string> = {
-    ".html": "text/html",
-    ".htm": "text/html",
-    ".css": "text/css",
-    ".js": "application/javascript",
-    ".mjs": "application/javascript",
-    ".json": "application/json",
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".gif": "image/gif",
-    ".svg": "image/svg+xml",
-    ".ico": "image/x-icon",
-    ".txt": "text/plain",
-    ".pdf": "application/pdf",
-    ".woff": "font/woff",
-    ".woff2": "font/woff2",
-    ".ttf": "font/ttf",
-    ".otf": "font/otf",
-    ".eot": "application/vnd.ms-fontobject",
-  }
-
-  return mimeTypes[ext] ?? "application/octet-stream"
-}

package/src/StartHttp.ts

@@ -1,42 +0,0 @@
-import * as HttpApp from "@effect/platform/HttpApp"
-import * as HttpMiddleware from "@effect/platform/HttpMiddleware"
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
-import * as Effect from "effect/Effect"
-import {
-  Bundle,
-  BundleHttp,
-} from "."
-
-type SsrRenderer = (req: Request) => PromiseLike<Response>
-
-/**
- * Attempts to render SSR page. If the renderer returns 404,
- * we fall back to app.
- */
-export function ssr(renderer: SsrRenderer) {
-  return Effect.gen(function*() {
-    const request = yield* HttpServerRequest.HttpServerRequest
-    const webRequest = request.source as Request
-    const ssrRes = yield* Effect.tryPromise(() => renderer(webRequest))
-
-    return HttpServerResponse.raw(ssrRes.body, {
-      status: ssrRes.status,
-      headers: ssrRes.headers,
-    })
-  })
-}
-
-export function withBundleAssets(opts?: {
-  path?: string
-}) {
-  return HttpMiddleware.make(app =>
-    Effect.gen(function*() {
-      const request = yield* HttpServerRequest.HttpServerRequest
-      const bundleResponse = yield* BundleHttp.httpApp()
-
-      // Fallback to original app
-      return yield* app
-    })
-  )
-}