effect-start 0.13.0 → 0.14.0

package/README.md

@@ -52,13 +52,13 @@ src/routes
 
 ### Tailwind CSS Support
 
-Effect Start comes with native Tailwind support that is lightweight and
-works with minimal setup.
+Effect Start comes with Tailwind plugin that is lightweight and
+works with minimal configuration.
 
-First, install Tailwind package:
+First, install official Tailwind package:
 
 ```sh
-bun add tailwindcss
+bun add -D tailwindcss
 ```
 
 Then, register a plugin in `bunfig.toml`:

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "effect-start",
-  "version": "0.13.0",
+  "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",
@@ -32,23 +32,18 @@
   "peerDependencies": {
     "typescript": "^5.9.3"
   },
-  "peerDependenciesMeta": {
-    "@tailwindcss/node": {
-      "optional": true
-    }
-  },
   "devDependencies": {
+    "dprint-cli": "^0.4.1",
+    "dprint-markup": "nounder/dprint-markup",
     "@dprint/json": "^0.21.0",
     "@dprint/markdown": "^0.20.0",
     "@dprint/typescript": "^0.95.13",
     "@effect/language-service": "^0.61.0",
-    "@tailwindcss/node": "^4.1.17",
     "@types/bun": "^1.3.4",
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
-    "dprint-cli": "^0.4.1",
-    "dprint-markup": "nounder/dprint-markup",
     "effect-memfs": "^0.8.0",
+    "tailwindcss": "^4.1.18",
     "ts-namespace-import": "nounder/ts-namespace-import#140c405"
   },
   "files": [

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/bun/_BunEnhancedResolve.ts

@@ -0,0 +1,201 @@
+/**
+ * Bun adapter for enhanced-resolve
+ *
+ * This module provides a drop-in replacement for `enhanced-resolve` that uses
+ * Bun's built-in resolver. It implements the subset of the enhanced-resolve API
+ * used for Tailwind CSS.
+ */
+import fs from "node:fs"
+import path from "node:path"
+
+type ErrorWithDetail =
+  & Error
+  & {
+    details?: string
+  }
+
+interface ResolveRequest {
+  path: string | false
+  context?: object
+  descriptionFilePath?: string
+  descriptionFileRoot?: string
+  descriptionFileData?: Record<string, unknown>
+  relativePath?: string
+  ignoreSymlinks?: boolean
+  fullySpecified?: boolean
+}
+
+interface ResolveContext {
+  contextDependencies?: { add: (item: string) => void }
+  fileDependencies?: { add: (item: string) => void }
+  missingDependencies?: { add: (item: string) => void }
+  stack?: Set<string>
+  log?: (str: string) => void
+  yield?: (request: ResolveRequest) => void
+}
+
+interface ResolveOptions {
+  extensions?: string[]
+  mainFields?: (string | string[])[]
+  conditionNames?: string[]
+  fileSystem?: unknown
+  useSyncFileSystemCalls?: boolean
+  modules?: string | string[]
+}
+
+export interface Resolver {
+  resolve(
+    context: object,
+    path: string,
+    request: string,
+    resolveContext: ResolveContext,
+    callback: (
+      err: null | ErrorWithDetail,
+      res?: string | false,
+      req?: ResolveRequest,
+    ) => void,
+  ): void
+}
+
+export class CachedInputFileSystem {
+  constructor(
+    _fileSystem: unknown,
+    _duration: number,
+  ) {}
+}
+
+export const ResolverFactory = {
+  createResolver(options: ResolveOptions): Resolver {
+    const extensions = options.extensions ?? []
+    const mainFields = (options.mainFields ?? []).flatMap((f) =>
+      Array.isArray(f) ? f : [f]
+    )
+    const conditionNames = options.conditionNames ?? []
+
+    return {
+      resolve(
+        _context: object,
+        basePath: string,
+        id: string,
+        _resolveContext: ResolveContext,
+        callback: (
+          err: null | ErrorWithDetail,
+          res?: string | false,
+          req?: ResolveRequest,
+        ) => void,
+      ): void {
+        try {
+          const result = resolveSync(id, basePath, {
+            extensions,
+            mainFields,
+            conditionNames,
+          })
+          callback(null, result)
+        } catch (err) {
+          callback(err instanceof Error ? err : new Error(String(err)))
+        }
+      },
+    }
+  },
+}
+
+interface ResolveInternalOptions {
+  extensions: string[]
+  mainFields: string[]
+  conditionNames: string[]
+}
+
+function resolveSync(
+  id: string,
+  base: string,
+  options: ResolveInternalOptions,
+): string | undefined {
+  if (id.startsWith(".") || id.startsWith("/")) {
+    for (const ext of ["", ...options.extensions]) {
+      const fullPath = path.resolve(base, id + ext)
+      if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+        return fullPath
+      }
+    }
+    return undefined
+  }
+
+  const packagePath = resolvePackagePath(id, base)
+  if (!packagePath) return undefined
+
+  const packageJsonPath = path.join(packagePath, "package.json")
+  if (!fs.existsSync(packageJsonPath)) return undefined
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"))
+
+  for (const field of options.mainFields) {
+    if (typeof packageJson[field] === "string") {
+      const resolved = path.resolve(packagePath, packageJson[field])
+      if (fs.existsSync(resolved)) return resolved
+    }
+  }
+
+  if (packageJson.exports) {
+    const resolved = resolveExports(
+      packageJson.exports,
+      packagePath,
+      options.conditionNames,
+    )
+    if (resolved && fs.existsSync(resolved)) return resolved
+  }
+
+  try {
+    return Bun.resolveSync(id, base)
+  } catch {
+    return undefined
+  }
+}
+
+function resolvePackagePath(id: string, base: string): string | undefined {
+  const parts = id.split("/")
+  const packageName = id.startsWith("@")
+    ? parts.slice(0, 2).join("/")
+    : parts[0]
+
+  let dir = base
+  while (dir !== path.dirname(dir)) {
+    const candidate = path.join(dir, "node_modules", packageName)
+    if (fs.existsSync(candidate)) return candidate
+    dir = path.dirname(dir)
+  }
+  return undefined
+}
+
+function resolveExports(
+  exports: unknown,
+  packagePath: string,
+  conditionNames: string[],
+): string | undefined {
+  if (typeof exports === "string") {
+    return path.resolve(packagePath, exports)
+  }
+
+  if (exports && typeof exports === "object" && !Array.isArray(exports)) {
+    const exportsObj = exports as Record<string, unknown>
+
+    if ("." in exportsObj) {
+      return resolveExports(exportsObj["."], packagePath, conditionNames)
+    }
+
+    for (const condition of conditionNames) {
+      if (condition in exportsObj) {
+        return resolveExports(
+          exportsObj[condition],
+          packagePath,
+          conditionNames,
+        )
+      }
+    }
+
+    if ("default" in exportsObj) {
+      return resolveExports(exportsObj["default"], packagePath, conditionNames)
+    }
+  }
+
+  return undefined
+}

package/src/bun/index.ts

@@ -2,4 +2,3 @@ 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 BunTailwindPlugin from "./BunTailwindPlugin.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/{bun/BunTailwindPlugin.test.ts → x/tailwind/TailwindPlugin.test.ts}

@@ -1,6 +1,6 @@
 import * as t from "bun:test"
 
-import { extractClassNames } from "./BunTailwindPlugin.ts"
+import { extractClassNames } from "./TailwindPlugin.ts"
 
 // Keep the old broad implementation for comparison tests
 function extractClassNamesBroad(source: string): Set<string> {