effect-start 0.30.0 → 0.31.0

package/src/RouteTree.ts

@@ -1,10 +1,11 @@
 import * as Predicate from "effect/Predicate"
-import * as PathPattern from "./_PathPattern.ts"
+import type * as PathPattern from "./_PathPattern.ts"
 import * as Route from "./Route.ts"
 import type * as RouteMount from "./RouteMount.ts"
 
 const TypeId = "~effect-start/RouteTree" as const
 const RouteTreeRoutes: unique symbol = Symbol()
+const CompiledRoutesKey: unique symbol = Symbol()
 
 type MethodRoute = Route.Route.With<{ method: string }>
 
@@ -27,40 +28,25 @@ export type RouteMap = {
 
 export type Routes<T extends RouteTree> = T[typeof RouteTreeRoutes]
 
-export interface RouteTree<Routes extends RouteMap = RouteMap> {
-  [TypeId]: typeof TypeId
-  [RouteTreeRoutes]: Routes
+interface CompiledMethod {
+  regex: RegExp
+  table: Array<{
+    path: PathPattern.PathPattern
+    routes: Array<RouteMount.MountedRoute>
+    paramNames: Array<string>
+    paramGroupIndices: Array<number>
+    sentinelIndex: number
+  }>
 }
 
-function routes<Routes extends RouteMap>(tree: RouteTree<Routes>): Routes {
-  return tree[RouteTreeRoutes]
+interface CompiledRoutes {
+  methods: Record<string, CompiledMethod>
 }
 
-// segment priority: static (0) < :param (1) < :param? (2) < :param+ (3) < :param* (4)
-function sortScore(path: string): number {
-  const segments = path.split("/")
-  const greedyIdx = segments.findIndex((s) => s.endsWith("*") || s.endsWith("+"))
-  const maxPriority = Math.max(
-    ...segments.map((s) =>
-      !s.startsWith(":") ? 0 : s.endsWith("*") ? 4 : s.endsWith("+") ? 3 : s.endsWith("?") ? 2 : 1,
-    ),
-    0,
-  )
-
-  return greedyIdx === -1
-    ? // non-greedy: sort by depth, then by max segment priority
-      (segments.length << 16) + (maxPriority << 8)
-    : // greedy: sort after non-greedy, by greedy position (later = first), then priority
-      (1 << 24) + ((16 - greedyIdx) << 16) + (maxPriority << 8)
-}
-
-function sortRoutes(input: RouteMap): RouteMap {
-  const keys = Object.keys(input).sort((a, b) => sortScore(a) - sortScore(b) || a.localeCompare(b))
-  const sorted: RouteMap = {}
-  for (const key of keys) {
-    sorted[key as PathPattern.PathPattern] = input[key as PathPattern.PathPattern]
-  }
-  return sorted
+export interface RouteTree<Routes extends RouteMap = RouteMap> {
+  [TypeId]: typeof TypeId
+  [RouteTreeRoutes]: Routes
+  [CompiledRoutesKey]?: CompiledRoutes
 }
 
 type PrefixKeys<T, Prefix extends string> = {
@@ -92,6 +78,16 @@ type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (
   ? I
   : never
 
+export type WalkDescriptor = {
+  path: PathPattern.PathPattern
+  method: string
+} & Route.RouteDescriptor.Any
+
+export interface LookupResult {
+  route: RouteMount.MountedRoute
+  params: Record<string, string>
+}
+
 export function make<const Routes extends InputRouteMap>(
   input: Routes,
 ): RouteTree<FlattenRouteMap<Routes>> {
@@ -115,30 +111,13 @@ export function make<const Routes extends InputRouteMap>(
 
   flatten(input, "", layerRoutes)
 
+  const sorted = sortRoutes(merged)
   return {
     [TypeId]: TypeId,
-    [RouteTreeRoutes]: sortRoutes(merged),
+    [RouteTreeRoutes]: sorted,
   } as RouteTree<FlattenRouteMap<Routes>>
 }
 
-export type WalkDescriptor = {
-  path: PathPattern.PathPattern
-  method: string
-} & Route.RouteDescriptor.Any
-
-function* flattenRoutes(
-  path: PathPattern.PathPattern,
-  routes: Iterable<MethodRoute>,
-): Generator<RouteMount.MountedRoute> {
-  for (const route of routes) {
-    const descriptor = {
-      ...route[Route.RouteDescriptor],
-      path,
-    }
-    yield Route.make(route.handler as any, descriptor) as RouteMount.MountedRoute
-  }
-}
-
 export function* walk(tree: RouteTree): Generator<RouteMount.MountedRoute> {
   const _routes = routes(tree) as RouteMap
 
@@ -153,9 +132,10 @@ export function merge(a: RouteTree, b: RouteTree): RouteTree {
     const key = path as PathPattern.PathPattern
     combined[key] = combined[key] ? [...combined[key], ...items] : items
   }
+  const sorted = sortRoutes(combined)
   return {
     [TypeId]: TypeId,
-    [RouteTreeRoutes]: sortRoutes(combined),
+    [RouteTreeRoutes]: sorted,
   } as RouteTree
 }
 
@@ -163,21 +143,232 @@ export function isRouteTree(input: unknown): input is RouteTree {
   return Predicate.hasProperty(input, TypeId)
 }
 
-export interface LookupResult {
-  route: RouteMount.MountedRoute
-  params: Record<string, string>
+export function lookup(tree: RouteTree, method: string, path: string): LookupResult | null {
+  tree[CompiledRoutesKey] ??= compileRoutes(routes(tree))
+  const { methods } = tree[CompiledRoutesKey]
+
+  const wildcard = methods["*"]
+  if (wildcard) {
+    const result = execCompiled(wildcard, path)
+    if (result) return result
+  }
+
+  const specific = methods[method]
+  if (specific) {
+    const result = execCompiled(specific, path)
+    if (result) return result
+  }
+
+  return null
 }
 
-export function lookup(tree: RouteTree, method: string, path: string): LookupResult | null {
-  for (const route of walk(tree)) {
-    const descriptor = Route.descriptor(route)
+function routes<Routes extends RouteMap>(tree: RouteTree<Routes>): Routes {
+  return tree[RouteTreeRoutes]
+}
 
-    if (descriptor.method !== "*" && descriptor.method !== method) continue
+// segment priority: static (0) < :param (1) < :param? (2) < :param+ (3) < :param* (4)
+function sortScore(path: string): number {
+  const segments = path.split("/")
+  const greedyIdx = segments.findIndex((s) => s.endsWith("*") || s.endsWith("+"))
+  const maxPriority = Math.max(
+    ...segments.map((s) =>
+      !s.startsWith(":") ? 0 : s.endsWith("*") ? 4 : s.endsWith("+") ? 3 : s.endsWith("?") ? 2 : 1,
+    ),
+    0,
+  )
+
+  return greedyIdx === -1
+    ? // non-greedy: sort by depth, then by max segment priority
+      (segments.length << 16) + (maxPriority << 8)
+    : // greedy: sort after non-greedy, by greedy position (later = first), then priority
+      (1 << 24) + ((16 - greedyIdx) << 16) + (maxPriority << 8)
+}
+
+function sortRoutes(input: RouteMap): RouteMap {
+  const keys = Object.keys(input).sort((a, b) => sortScore(a) - sortScore(b) || a.localeCompare(b))
+  const sorted: RouteMap = {}
+  for (const key of keys) {
+    sorted[key as PathPattern.PathPattern] = input[key as PathPattern.PathPattern]
+  }
+  return sorted
+}
+
+function* flattenRoutes(
+  path: PathPattern.PathPattern,
+  routes: Iterable<MethodRoute>,
+): Generator<RouteMount.MountedRoute> {
+  for (const route of routes) {
+    const descriptor = {
+      ...route[Route.RouteDescriptor],
+      path,
+    }
+    yield Route.make(route.handler as any, descriptor) as RouteMount.MountedRoute
+  }
+}
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}
+
+function patternToRegex(pattern: string): {
+  fragment: string
+  paramNames: Array<string>
+  groupCount: number
+} {
+  const segments = pattern.split("/").filter(Boolean)
+  const paramNames: Array<string> = []
+  let fragment = ""
+  let groupCount = 0
+
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i]
+
+    if (seg.startsWith(":")) {
+      const last = seg[seg.length - 1]
+      if (last === "+") {
+        const name = seg.slice(1, -1)
+        paramNames.push(name)
+        fragment += "\\/(.+)"
+        groupCount++
+      } else if (last === "*") {
+        const name = seg.slice(1, -1)
+        paramNames.push(name)
+        fragment += "(?:\\/(.+))?"
+        groupCount++
+      } else if (last === "?") {
+        const name = seg.slice(1, -1)
+        paramNames.push(name)
+        fragment += "(?:\\/([^\\/]+))?"
+        groupCount++
+      } else {
+        const name = seg.slice(1)
+        paramNames.push(name)
+        fragment += "\\/([^\\/]+)"
+        groupCount++
+      }
+    } else {
+      fragment += "\\/" + escapeRegex(seg)
+    }
+  }
+
+  return { fragment, paramNames, groupCount }
+}
+
+function compileRoutes(sortedRoutes: RouteMap): CompiledRoutes {
+  const methodGroups: Record<
+    string,
+    Array<{
+      path: PathPattern.PathPattern
+      route: RouteMount.MountedRoute
+    }>
+  > = {}
+
+  for (const path of Object.keys(sortedRoutes) as Array<PathPattern.PathPattern>) {
+    for (const routeData of sortedRoutes[path]) {
+      const descriptor = {
+        ...routeData[Route.RouteDescriptor],
+        path,
+      }
+      const mounted = Route.make(routeData.handler as any, descriptor) as RouteMount.MountedRoute
+      const method = (descriptor as { method: string }).method
+
+      if (!methodGroups[method]) methodGroups[method] = []
+      methodGroups[method].push({ path, route: mounted })
+    }
+  }
+
+  const pathRoutesByMethod: Record<
+    string,
+    Map<
+      string,
+      {
+        path: PathPattern.PathPattern
+        routes: Array<RouteMount.MountedRoute>
+      }
+    >
+  > = {}
+
+  for (const method of Object.keys(methodGroups)) {
+    const map = new Map<
+      string,
+      {
+        path: PathPattern.PathPattern
+        routes: Array<RouteMount.MountedRoute>
+      }
+    >()
+    for (const { path, route } of methodGroups[method]) {
+      let entry = map.get(path)
+      if (!entry) {
+        entry = { path, routes: [] }
+        map.set(path, entry)
+      }
+      entry.routes.push(route)
+    }
+    pathRoutesByMethod[method] = map
+  }
 
-    const params = PathPattern.match(descriptor.path, path)
-    if (params !== null) {
-      return { route, params }
+  const methods: Record<string, CompiledMethod> = {}
+
+  for (const method of Object.keys(pathRoutesByMethod)) {
+    const pathMap = pathRoutesByMethod[method]
+    const sortedPaths = Object.keys(sortedRoutes) as Array<PathPattern.PathPattern>
+    const orderedPaths = sortedPaths.filter((p) => pathMap.has(p))
+
+    const branches: Array<string> = []
+    const table: CompiledMethod["table"] = []
+    let groupOffset = 1
+
+    for (const path of orderedPaths) {
+      const entry = pathMap.get(path)!
+      const { fragment, paramNames, groupCount } = patternToRegex(path)
+
+      const paramGroupIndices: Array<number> = []
+      for (let i = 0; i < groupCount; i++) {
+        paramGroupIndices.push(groupOffset + i)
+      }
+
+      const sentinelIndex = groupOffset + groupCount
+      branches.push(fragment + "()")
+      groupOffset += groupCount + 1
+
+      table.push({
+        path: entry.path,
+        routes: entry.routes,
+        paramNames,
+        paramGroupIndices,
+        sentinelIndex,
+      })
+    }
+
+    if (branches.length === 0) continue
+
+    const pattern = "^(?:" + branches.join("|") + ")\\/*$"
+    methods[method] = {
+      regex: new RegExp(pattern),
+      table,
     }
   }
+
+  return { methods }
+}
+
+function execCompiled(compiled: CompiledMethod, path: string): LookupResult | null {
+  const match = compiled.regex.exec(path)
+  if (!match) return null
+
+  for (const entry of compiled.table) {
+    if (match[entry.sentinelIndex] === undefined) continue
+
+    const params: Record<string, string> = {}
+    for (let i = 0; i < entry.paramNames.length; i++) {
+      const val = match[entry.paramGroupIndices[i]]
+      if (val !== undefined) {
+        params[entry.paramNames[i]] = val
+      }
+    }
+
+    return { route: entry.routes[0], params }
+  }
+
   return null
 }

package/src/StaticFiles.ts

@@ -0,0 +1,112 @@
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as Schema from "effect/Schema"
+import * as Entity from "./Entity.ts"
+import * as FileSystem from "./FileSystem.ts"
+import * as PathPattern from "./_PathPattern.ts"
+import * as Mime from "./_Mime.ts"
+import * as Route from "./Route.ts"
+import * as RouteSchema from "./RouteSchema.ts"
+import * as RouteTree from "./RouteTree.ts"
+import * as System from "./System.ts"
+
+const defaultMountPath = "/assets"
+const PathParamsSchema = Schema.Struct({
+  path: Schema.optional(Schema.String),
+})
+
+const emptyNotFound = Entity.make(new Uint8Array(0), { status: 404 })
+
+export const make = (directory: string) =>
+  Route.get(
+    RouteSchema.schemaPathParams(PathParamsSchema),
+    Route.render(function* (ctx) {
+      const fs = yield* FileSystem.FileSystem
+      const relativePath =
+        typeof ctx.pathParams.path === "string" ? normalizeRelativePath(ctx.pathParams.path) : null
+
+      if (!relativePath) {
+        return emptyNotFound
+      }
+
+      const absolutePath = `${directory.replace(/[\\/]+$/, "")}/${relativePath}`
+      const info = yield* fs.stat(absolutePath).pipe(
+        Effect.catchAll((error) =>
+          isNotFound(error) ? Effect.succeed(null) : Effect.fail(error),
+        ),
+      )
+
+      if (info === null || info.type !== "File") {
+        return emptyNotFound
+      }
+
+      const headers: Entity.Headers = {
+        "content-length": String(info.size),
+        "content-type": Mime.fromPath(relativePath),
+      }
+
+      if (Option.isSome(info.mtime)) {
+        headers["last-modified"] = info.mtime.value.toUTCString()
+      }
+
+      const bytes = yield* fs.readFile(absolutePath)
+      return Entity.make(bytes, { headers })
+    }),
+  )
+
+export const layer = (options: {
+  directory: string
+  path?: string
+}) =>
+  Layer.effect(
+    Route.Routes,
+    Effect.gen(function* () {
+      const existing = yield* Effect.serviceOption(Route.Routes).pipe(
+        Effect.andThen(Option.getOrUndefined),
+      )
+      const trimmedMountPath = (options.path ?? defaultMountPath).trim().replace(/^\/+|\/+$/g, "")
+      const mountPattern = (
+        trimmedMountPath.length > 0 ? `/${trimmedMountPath}/:path+` : "/:path+"
+      ) as PathPattern.PathPattern
+      const staticFilesTree = Route.tree({
+        [mountPattern]: make(options.directory),
+      })
+      if (!existing) {
+        return staticFilesTree
+      }
+      return RouteTree.merge(existing, staticFilesTree)
+    }),
+  )
+
+function normalizeRelativePath(path: string): string | null {
+  if (path.length === 0 || path.startsWith("/") || path.startsWith("\\")) {
+    return null
+  }
+
+  const segments = path.split(/[\\/]+/)
+  const normalized: Array<string> = []
+
+  for (const segment of segments) {
+    if (segment === "" || segment === ".") {
+      continue
+    }
+    if (segment === ".." || segment.includes("\0")) {
+      return null
+    }
+    normalized.push(segment)
+  }
+
+  return normalized.length > 0 ? normalized.join("/") : null
+}
+
+function isNotFound(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "_tag" in error &&
+    error._tag === "SystemError" &&
+    "reason" in error &&
+    error.reason === "NotFound"
+  )
+}

package/src/_Mime.ts

@@ -0,0 +1,33 @@
+const mediaTypes: Record<string, string> = {
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".css": "text/css",
+  ".csv": "text/csv",
+  ".gif": "image/gif",
+  ".html": "text/html",
+  ".ico": "image/x-icon",
+  ".js": "text/javascript",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".json": "application/json",
+  ".map": "application/json",
+  ".md": "text/markdown",
+  ".mjs": "text/javascript",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain",
+  ".wasm": "application/wasm",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".xml": "application/xml",
+}
+
+export function fromPath(path: string): string {
+  const dotIndex = path.lastIndexOf(".")
+  const extension = dotIndex === -1 ? "" : path.slice(dotIndex).toLowerCase()
+  const mediaType = mediaTypes[extension] ?? "application/octet-stream"
+  return mediaType.startsWith("text/") ? `${mediaType}; charset=utf-8` : mediaType
+}

package/src/_PathPattern.ts

@@ -175,7 +175,7 @@ export function match(pattern: string, path: string): Record<string, string> | n
         if (remaining.length === 0) {
           return null
         }
-        params[name] = remaining.join("/")
+        params[name] = remaining.map(decodeURIComponent).join("/")
         return params
       }
 
@@ -183,7 +183,7 @@ export function match(pattern: string, path: string): Record<string, string> | n
         const name = rest.slice(0, -1)
         const remaining = pathSegments.slice(pathIndex)
         if (remaining.length > 0) {
-          params[name] = remaining.join("/")
+          params[name] = remaining.map(decodeURIComponent).join("/")
         }
         return params
       }
@@ -191,7 +191,7 @@ export function match(pattern: string, path: string): Record<string, string> | n
       if (rest.endsWith("?")) {
         const name = rest.slice(0, -1)
         if (pathIndex < pathSegments.length) {
-          params[name] = pathSegments[pathIndex]
+          params[name] = decodeURIComponent(pathSegments[pathIndex])
           pathIndex++
         }
         patternIndex++
@@ -202,7 +202,7 @@ export function match(pattern: string, path: string): Record<string, string> | n
         return null
       }
 
-      params[rest] = pathSegments[pathIndex]
+      params[rest] = decodeURIComponent(pathSegments[pathIndex])
       pathIndex++
       patternIndex++
       continue

package/src/bun/BunRoute.ts

@@ -139,6 +139,16 @@ export function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModu
         const childEntity = yield* next(context).pipe(
           Effect.locally(bundleDepthRef, bundleDepth + 1),
         )
+
+        if (
+          Entity.isEntity(childEntity) &&
+          childEntity.status &&
+          childEntity.status >= 300 &&
+          childEntity.status < 400
+        ) {
+          return childEntity
+        }
+
         const children = childEntity?.body ?? childEntity
 
         let childrenHtml = ""

package/src/bun/BunServer.ts

@@ -50,6 +50,7 @@ export type BunServer = {
   readonly server: Bun.Server<WebSocketContext>
   readonly pushHandler: (fetch: FetchHandler) => void
   readonly popHandler: () => void
+  readonly setRoutes: (tree: RouteTree.RouteTree) => Effect.Effect<void>
 }
 
 export const BunServer = Context.GenericTag<BunServer>("effect-start/BunServer")
@@ -77,6 +78,9 @@ export const make = (
       },
     ]
 
+    const setRoutesDeferred =
+      yield* Deferred.make<(tree: RouteTree.RouteTree) => Effect.Effect<void>>()
+
     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
@@ -93,6 +97,11 @@ export const make = (
         handlerStack.pop()
         reload()
       },
+      setRoutes(tree) {
+        return Deferred.await(setRoutesDeferred).pipe(
+          Effect.flatMap((applyRoutes) => applyRoutes(tree)),
+        )
+      },
     })
 
     const runtime = yield* Effect.runtime().pipe(
@@ -150,6 +159,18 @@ export const make = (
       })
     }
 
+    yield* Deferred.succeed(setRoutesDeferred, (tree) =>
+      walkBunRoutes(runtime, tree).pipe(
+        Effect.tap((bunRoutes) =>
+          Effect.sync(() => {
+            currentRoutes = bunRoutes
+            reload()
+          }),
+        ),
+        Effect.asVoid,
+      ),
+    )
+
     const bunServer = BunServer.of({
       server,
       pushHandler(fetch) {
@@ -160,6 +181,11 @@ export const make = (
         handlerStack.pop()
         reload()
       },
+      setRoutes(tree) {
+        return Deferred.await(setRoutesDeferred).pipe(
+          Effect.flatMap((applyRoutes) => applyRoutes(tree)),
+        )
+      },
     })
 
     return bunServer
@@ -185,6 +211,7 @@ export const layerRoutes = (
 /**
  * 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.
+ *    If Route.Routes are available, upgrade the existing server with them.
  * 2) Otherwise create the server from Route.Routes when routes are available.
  * 3) Otherwise create a fallback server with the default 404 handler.
  */
@@ -195,18 +222,17 @@ export const layerStart = (
     BunServer,
     Effect.gen(function* () {
       const app = yield* StartApp.StartApp
+      const routes = yield* Effect.serviceOption(Route.Routes)
+      const routeTree = Option.getOrNull(routes)
       const existing = yield* Effect.serviceOption(BunServer)
       if (Option.isSome(existing)) {
+        if (routeTree !== null) {
+          yield* existing.value.setRoutes(routeTree)
+        }
         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 ?? {})
+      const server = yield* make(options ?? {}, routeTree ?? undefined)
       yield* Deferred.succeed(app.server, server)
       return server
     }),

package/src/studio/routes/errors/route.tsx

@@ -75,10 +75,7 @@ export default Route.get(
     Stream.fromPubSub(StudioStore.store.events).pipe(
       Stream.filter((e) => e._tag === "Error"),
       Stream.map((e) => {
-        const html = Html.renderToString(<Errors.ErrorLine error={e.error} />).replace(
-          /\n/g,
-          "",
-        )
+        const html = Html.renderToString(<Errors.ErrorLine error={e.error} />).replace(/\n/g, "")
         return {
           event: "datastar-patch-elements",
           data: `selector #errors-list\nmode prepend\nelements ${html}`,

package/src/studio/routes/traces/route.tsx

@@ -56,10 +56,7 @@ export default Route.get(
       Stream.mapEffect(() =>
         Effect.gen(function* () {
           const spans = yield* StudioStore.allSpans(StudioStore.store.sql)
-          const html = Html.renderToString(<Traces.TraceGroups spans={spans} />).replace(
-            /\n/g,
-            "",
-          )
+          const html = Html.renderToString(<Traces.TraceGroups spans={spans} />).replace(/\n/g, "")
           return {
             event: "datastar-patch-elements",
             data: `selector #traces-container\nmode inner\nelements ${html}`,