effect-start 0.27.0 → 0.29.0

package/package.json

@@ -1,59 +1,122 @@
 {
   "name": "effect-start",
-  "version": "0.27.0",
+  "version": "0.29.0",
   "license": "MIT",
   "files": [
     "src/",
-    "!src/**/*.test.ts",
-    "!src/**/*.test.tsx",
-    "!src/tower",
     "dist/",
     "README.md",
     "package.json"
   ],
   "type": "module",
   "exports": {
-    ".": "./src/index.ts",
-    "./bun": "./src/bun/index.ts",
-    "./client": "./src/client/index.ts",
-    "./testing": "./src/testing/index.ts",
-    "./tower": "./src/tower/index.ts",
-    "./sql": "./src/sql/index.ts",
-    "./sql/*": "./src/sql/*/index.ts",
-    "./x/*": "./src/x/*/index.ts",
-    "./x/tailwind/plugin": "./src/x/tailwind/plugin.ts",
-    "./System": "./src/System.ts",
-    "./Unique": "./src/Unique.ts",
-    "./FileRouter": "./src/FileRouter.ts",
-    "./FileSystem": "./src/FileSystem.ts",
-    "./experimental": "./src/experimental/index.ts",
+    ".": {
+      "source": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
     "./client/assets.d.ts": "./src/assets.d.ts",
-    "./hyper": "./src/hyper/index.ts",
-    "./jsx-runtime": "./src/hyper/jsx-runtime.ts",
-    "./jsx-dev-runtime": "./src/hyper/jsx-runtime.ts",
-    "./datastar": "./src/datastar/index.ts",
-    "./lint/plugin": "./src/lint/plugin.js",
+    "./jsx-runtime": {
+      "source": "./src/hyper/jsx-runtime.ts",
+      "default": "./dist/hyper/jsx-runtime.js"
+    },
+    "./jsx-dev-runtime": {
+      "source": "./src/hyper/jsx-runtime.ts",
+      "default": "./dist/hyper/jsx-runtime.js"
+    },
+    "./lint/plugin": {
+      "source": "./src/lint/plugin.js",
+      "default": "./dist/lint/plugin.js"
+    },
+    "./x/*": {
+      "source": "./src/x/*/index.ts",
+      "default": "./dist/x/*/index.js"
+    },
+    "./x/tailwind/plugin": {
+      "source": "./src/x/tailwind/plugin.ts",
+      "default": "./dist/x/tailwind/plugin.js"
+    },
+    "./bun": {
+      "source": "./src/bun/index.ts",
+      "default": "./dist/bun/index.js"
+    },
+    "./cli": {
+      "source": "./src/cli/index.ts",
+      "default": "./dist/cli/index.js"
+    },
+    "./client": {
+      "source": "./src/client/index.ts",
+      "default": "./dist/client/index.js"
+    },
+    "./datastar": {
+      "source": "./src/datastar/index.ts",
+      "default": "./dist/datastar/index.js"
+    },
+    "./experimental": {
+      "source": "./src/experimental/index.ts",
+      "default": "./dist/experimental/index.js"
+    },
+    "./hyper": {
+      "source": "./src/hyper/index.ts",
+      "default": "./dist/hyper/index.js"
+    },
+    "./sql/*": {
+      "source": "./src/sql/*/index.ts",
+      "default": "./dist/sql/*/index.js"
+    },
+    "./sql": {
+      "source": "./src/sql/index.ts",
+      "default": "./dist/sql/index.js"
+    },
+    "./testing": {
+      "source": "./src/testing/index.ts",
+      "default": "./dist/testing/index.js"
+    },
+    "./studio": {
+      "source": "./src/studio/index.ts",
+      "default": "./dist/studio/index.js"
+    },
+    "./*": {
+      "source": "./src/*.ts",
+      "default": "./dist/*.js"
+    },
+    "./_*": null,
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "bunx --bun tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json && cd src && find . -name '*.html' -exec rsync -R {} ../dist/ \\;",
     "format": "bunx oxfmt",
     "lint": "oxlint --import-plugin --tsconfig tsconfig.json src/",
-    "test": "bun test ./src/",
+    "test": "bun test ./test/",
     "test-sql": "bun add --no-save mssql @types/mssql postgres && TEST_SQL=1 bun test ./src/sql/",
+    "bump": "bun scripts/bump",
+    "prepublishOnly": "bun run build",
     "deploy": "bunx --bun npm publish --access public"
   },
   "devDependencies": {
+    "@libsql/client": "^0.17.0",
     "@types/bun": "^1.3.4",
     "@types/jsdom": "^27.0.0",
     "effect-memfs": "^0.8.0",
     "jsdom": "^28.0.0",
+    "mssql": "^12.2.0",
     "oxfmt": "latest",
     "oxlint": "^1.43.0",
+    "postgres": "^3.4.8",
     "tailwindcss": "^4.1.18",
+    "ts-morph": "^27.0.2",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "effect": "^3.19.11"
+    "@libsql/client": ">=0.17.0",
+    "effect": "^3.19.11",
+    "mssql": ">=12.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@libsql/client": {
+      "optional": true
+    },
+    "mssql": {
+      "optional": true
+    }
   }
 }

package/src/Cookies.ts

@@ -9,23 +9,19 @@ import * as Pipeable from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
 import type * as Types from "effect/Types"
 
-export const TypeId: unique symbol = Symbol.for("effect-start/Cookies")
-
-export type TypeId = typeof TypeId
+export const TypeId = "~effect-start/Cookies" as const
 
 export const isCookies = (u: unknown): u is Cookies => Predicate.hasProperty(u, TypeId)
 
 export interface Cookies extends Pipeable.Pipeable, Inspectable.Inspectable {
-  readonly [TypeId]: TypeId
+  readonly [TypeId]: typeof TypeId
   readonly cookies: Record<string, Cookie>
 }
 
-export const CookieTypeId: unique symbol = Symbol.for("effect-start/Cookies/Cookie")
-
-export type CookieTypeId = typeof CookieTypeId
+export const CookieTypeId = "~effect-start/Cookies/Cookie" as const
 
 export interface Cookie extends Inspectable.Inspectable {
-  readonly [CookieTypeId]: CookieTypeId
+  readonly [CookieTypeId]: typeof CookieTypeId
   readonly name: string
   readonly value: string
   readonly valueEncoded: string

package/src/Entity.ts

@@ -4,11 +4,10 @@ import * as ParseResult from "effect/ParseResult"
 import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
-import * as StreamExtra from "./StreamExtra.ts"
-import * as Values from "./Values.ts"
+import * as StreamExtra from "./_StreamExtra.ts"
+import * as Values from "./_Values.ts"
 
-export const TypeId: unique symbol = Symbol.for("effect-start/Entity")
-export type TypeId = typeof TypeId
+export const TypeId = "~effect-start/Entity" as const
 
 const textDecoder = new TextDecoder()
 const textEncoder = new TextEncoder()
@@ -25,7 +24,7 @@ export type Headers = {
 }
 
 export interface Entity<T = unknown, E = never> extends Effect.Effect<Entity<T, E>, E> {
-  readonly [TypeId]: TypeId
+  readonly [TypeId]: typeof TypeId
   readonly body: T
   readonly headers: Headers
   /**
@@ -58,7 +57,7 @@ export interface Entity<T = unknown, E = never> extends Effect.Effect<Entity<T,
 }
 
 export interface Proto extends Effect.Effect<Entity, never> {
-  readonly [TypeId]: TypeId
+  readonly [TypeId]: typeof TypeId
 }
 
 function parseJson(s: string): Effect.Effect<unknown, ParseResult.ParseError> {
@@ -325,21 +324,27 @@ export function length(self: Entity): number | undefined {
   return undefined
 }
 
-export function fromResponse(
+export function fromResponse<E extends Error = Error>(
   response: Response,
   request?: Request,
-): Entity<Effect.Effect<Uint8Array, Error, never>, Error> {
-  return make(
-    Effect.tryPromise({
-      try: () => response.arrayBuffer().then((buf) => new Uint8Array(buf)),
-      catch: (e) => (e instanceof Error ? e : new Error(String(e))),
-    }),
-    {
-      headers: Object.fromEntries(response.headers.entries()),
-      status: response.status,
-      url: response.url || request?.url,
-    },
-  )
+): Entity<Stream.Stream<Uint8Array, E, never>, E> {
+  const body = response.body
+    ? Stream.fromReadableStream(
+        () => response.body!,
+        (e) => (e instanceof Error ? e : new Error(String(e))) as E,
+      )
+    : Stream.fromEffect(
+        Effect.tryPromise({
+          try: () => response.arrayBuffer().then((buf) => new Uint8Array(buf)),
+          catch: (e) => (e instanceof Error ? e : new Error(String(e))) as E,
+        }),
+      )
+
+  return make(body, {
+    headers: Object.fromEntries(response.headers.entries()),
+    status: response.status,
+    url: response.url || request?.url,
+  })
 }
 
 function mismatch(expected: Schema.Schema.Any, actual: unknown): ParseResult.ParseError {

package/src/Fetch.ts

@@ -1,12 +1,13 @@
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Schedule from "effect/Schedule"
+import * as Stream from "effect/Stream"
 import * as Entity from "./Entity.ts"
+import * as Values from "./_Values.ts"
 
-const TypeId: unique symbol = Symbol.for("effect-start/FetchClient")
-type TypeId = typeof TypeId
+const TypeId = "~effect-start/FetchClient" as const
 
-export type FetchEntity = Entity.Entity<Effect.Effect<Uint8Array, FetchError, never>, FetchError>
+export type FetchEntity = Entity.Entity<Stream.Stream<Uint8Array, FetchError, never>, FetchError>
 
 export class FetchError extends Data.TaggedError("FetchError")<{
   readonly reason: "Network" | "Status"
@@ -28,7 +29,7 @@ const tryFetch: Middleware = (request) =>
       try: () => globalThis.fetch(request),
       catch: (e) => new FetchError({ reason: "Network", cause: e, request }),
     }),
-    (response) => Entity.fromResponse(response, request) as FetchEntity,
+    (response) => Entity.fromResponse<FetchError>(response, request),
   )
 
 const defaultMiddleware: ReadonlyArray<Middleware> = [tryFetch]
@@ -64,7 +65,7 @@ function withTrace<E, R>(
 }
 
 export interface FetchClient<E = never, R = never> {
-  readonly [TypeId]: TypeId
+  readonly [TypeId]: typeof TypeId
   readonly middleware: ReadonlyArray<Middleware<any, any>>
   readonly fetch: (
     input: string | URL | Request,
@@ -172,6 +173,46 @@ const ClientProto: any = {
   use,
 }
 
+type WebHandler = (request: Request) => Response | Promise<Response>
+
+type FromHandlerInit = Omit<RequestInit, "body"> &
+  ({ url: string } | { path: `/${string}` }) & {
+    body?: RequestInit["body"] | Record<string, unknown>
+  }
+
+export function fromHandler(handler: WebHandler): FetchClient
+export function fromHandler(handler: WebHandler, init: FromHandlerInit): Promise<Response>
+export function fromHandler(
+  handler: WebHandler,
+  init?: FromHandlerInit,
+): FetchClient | Promise<Response> {
+  if (init === undefined) {
+    const transport: Middleware = (request) =>
+      Effect.map(
+        Effect.tryPromise({
+          try: () => Promise.resolve(handler(request)),
+          catch: (e) => new FetchError({ reason: "Network", cause: e, request }),
+        }),
+        (response) => Entity.fromResponse<FetchError>(response, request),
+      )
+    return use(transport)
+  }
+
+  const url = "path" in init ? `http://localhost${init.path}` : init.url
+  const isPlain = Values.isPlainObject(init.body)
+  const headers = new Headers(init.headers)
+  if (isPlain && !headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json")
+  }
+  const body = isPlain ? JSON.stringify(init.body) : init.body
+  const request = new Request(url, {
+    ...init,
+    headers,
+    body: body as BodyInit,
+  })
+  return Promise.resolve(handler(request))
+}
+
 export function filterStatus(
   predicate: (status: number) => boolean,
   options?: {
@@ -269,3 +310,85 @@ export function retry(options: {
     )
   }) as Middleware
 }
+
+interface SseEvent {
+  data?: string | undefined
+  type?: string
+  retry?: number
+  id?: string
+}
+
+export function sse(_options?: {
+  readonly retry?: Schedule.Schedule<any, any, any>
+}): (entity: FetchEntity) => Stream.Stream<SseEvent, FetchError> {
+  return (entity) => {
+    const contentType = entity.headers["content-type"] ?? ""
+    if (!contentType.includes("text/event-stream")) {
+      return Stream.fail(
+        new FetchError({
+          reason: "Status",
+          cause: new Error(`Expected content-type text/event-stream, got: ${contentType}`),
+          response: entity,
+        }),
+      )
+    }
+
+    const byteStream = entity.body as Stream.Stream<Uint8Array, FetchError, never>
+    const decoder = new TextDecoder()
+    const empty = {
+      partial: "",
+      eventType: undefined as string | undefined,
+      dataLines: [] as Array<string>,
+      retryMs: undefined as number | undefined,
+      lastEventId: undefined as string | undefined,
+    }
+    type Acc = typeof empty
+
+    return byteStream.pipe(
+      Stream.mapAccum(empty, (acc, chunk: Uint8Array): [Acc, Array<string>] => {
+        const text = acc.partial + decoder.decode(chunk, { stream: true })
+        const parts = text.split("\n")
+        const partial = parts.pop()!
+        const lines = parts.map((l) => (l.endsWith("\r") ? l.slice(0, -1) : l))
+        return [{ ...acc, partial }, lines]
+      }),
+      Stream.flatMap(Stream.fromIterable),
+      Stream.mapAccum(empty, (acc, line: string): [Acc, SseEvent | undefined] => {
+        if (line === "") {
+          if (acc.dataLines.length > 0) {
+            const event: SseEvent = { data: acc.dataLines.join("\n") }
+            if (acc.eventType !== undefined) event.type = acc.eventType
+            if (acc.retryMs !== undefined) event.retry = acc.retryMs
+            if (acc.lastEventId !== undefined) event.id = acc.lastEventId
+            return [{ ...empty, lastEventId: acc.lastEventId }, event]
+          }
+          return [{ ...empty, lastEventId: acc.lastEventId }, undefined]
+        }
+
+        if (line.startsWith(":")) return [acc, undefined]
+
+        const colonIdx = line.indexOf(":")
+        const field = colonIdx === -1 ? line : line.slice(0, colonIdx)
+        let value = colonIdx === -1 ? "" : line.slice(colonIdx + 1)
+        if (value.startsWith(" ")) value = value.slice(1)
+
+        switch (field) {
+          case "event":
+            return [{ ...acc, eventType: value }, undefined]
+          case "data":
+            return [{ ...acc, dataLines: [...acc.dataLines, value] }, undefined]
+          case "retry": {
+            const n = parseInt(value, 10)
+            if (!isNaN(n)) return [{ ...acc, retryMs: n }, undefined]
+            return [acc, undefined]
+          }
+          case "id":
+            return [{ ...acc, lastEventId: value }, undefined]
+          default:
+            return [acc, undefined]
+        }
+      }),
+      Stream.filter((event): event is SseEvent => event !== undefined),
+    )
+  }
+}

package/src/FileRouter.ts

@@ -7,12 +7,11 @@ import * as Layer from "effect/Layer"
 import * as Stream from "effect/Stream"
 import * as NPath from "node:path"
 import * as NUrl from "node:url"
-import * as Development from "./Development.ts"
-import * as FilePathPattern from "./FilePathPattern.ts"
+import * as Development from "./_Development.ts"
 import * as FileRouterCodegen from "./FileRouterCodegen.ts"
 import * as NodeUtils from "./node/NodeUtils.ts"
-import type * as PathPattern from "./PathPattern.ts"
-import type * as PlatformError from "./PlatformError.ts"
+import * as PathPattern from "./_PathPattern.ts"
+import type * as System from "./System.ts"
 import * as Route from "./Route.ts"
 import * as RouteTree from "./RouteTree.ts"
 
@@ -32,15 +31,12 @@ export type FileRoutes = {
   [path: PathPattern.PathPattern]: [LazyRouteModule, ...LazyRouteModule[]]
 }
 
-export type Segment = FilePathPattern.Segment
-
 export type FileRoute = {
   handle: "route" | "layer"
   // eg. `/about/route.tsx`, `/users/[userId]/route.tsx`, `/(admin)/users/route.tsx`
   modulePath: `/${string}`
-  // eg. `/about`, `/users/[userId]`, `/users` (groups stripped)
-  routePath: `/${string}`
-  segments: Array<Segment>
+  // eg. `/about`, `/users/:userId`, `/users` (groups stripped)
+  routePath: PathPattern.PathPattern
 }
 
 /**
@@ -52,40 +48,26 @@ export type FileRoute = {
  */
 export type OrderedFileRoutes = Array<FileRoute>
 
-const ROUTE_PATH_REGEX = /^\/?(.*\/?)(?:route|layer)\.(jsx?|tsx?)$/
+const ROUTE_PATH_REGEX = /^(.*\/)?(route|layer)\.(jsx?|tsx?)$/
 
 export function parseRoute(path: string): FileRoute | null {
-  const segs = FilePathPattern.segments(path)
-
-  const lastSeg = segs.at(-1)
-  const handleMatch =
-    lastSeg?._tag === "LiteralSegment" && lastSeg.value.match(/^(route|layer)\.(tsx?|jsx?)$/)
-  const handle = handleMatch ? (handleMatch[1] as "route" | "layer") : null
-
-  if (!handle) {
-    return null
-  }
-
-  const pathSegments = segs.slice(0, -1)
-
-  const validated = FilePathPattern.validate(FilePathPattern.format(pathSegments))
-  if (Either.isLeft(validated)) {
+  const normalizedPath = path.replace(/^\/+/, "")
+  const matched = normalizedPath.match(ROUTE_PATH_REGEX)
+  if (!matched) {
     return null
   }
 
-  const restIndex = pathSegments.findIndex((seg) => seg._tag === "RestSegment")
-  if (restIndex !== -1 && restIndex !== pathSegments.length - 1) {
+  const routeDir = matched[1]?.replace(/\/$/, "") ?? ""
+  const handle = matched[2] as "route" | "layer"
+  const routePathResult = PathPattern.fromFilePath(routeDir)
+  if (Either.isLeft(routePathResult)) {
     return null
   }
 
-  const routePathSegments = pathSegments.filter((seg) => seg._tag !== "GroupSegment")
-  const routePath = FilePathPattern.format(routePathSegments)
-
   return {
     handle,
-    modulePath: `/${path}`,
-    routePath,
-    segments: pathSegments,
+    modulePath: `/${normalizedPath}`,
+    routePath: routePathResult.right,
   }
 }
 
@@ -123,7 +105,7 @@ export function layer(
     treePath = NUrl.fileURLToPath(treePath)
   }
   if (NPath.extname(treePath) === "") {
-    treePath = NPath.join(treePath, "server.gen.ts")
+    treePath = NPath.join(treePath, ".server.ts")
   }
 
   const routesPath = NPath.dirname(treePath)
@@ -142,7 +124,7 @@ export function layer(
 
       // Watch for changes (only when Development service is available)
       yield* Function.pipe(
-        Development.stream(),
+        Development.events,
         Stream.filter((e) => e._tag !== "Reload" && e.path.startsWith(relativeRoutesPath)),
         Stream.runForEach(() => FileRouterCodegen.update(routesPath, treeFilename)),
         Effect.fork,
@@ -158,15 +140,30 @@ export function fromFileRoutes(fileRoutes: FileRoutes): Effect.Effect<RouteTree.
     const mounts: RouteTree.InputRouteMap = {}
 
     for (const [path, loaders] of Object.entries(fileRoutes)) {
-      const modules = yield* Effect.forEach(loaders, (loader) => Effect.promise(() => loader()))
-
       const allRoutes: RouteTree.RouteTuple = [] as unknown as RouteTree.RouteTuple
 
-      for (const m of modules) {
-        if (Route.isRouteSet(m.default)) {
-          for (const route of m.default) {
+      for (const loader of loaders) {
+        const result = yield* Effect.either(
+          Effect.tryPromise({
+            try: () => loader(),
+            catch: (cause) => new FileRouterError({ reason: "Import", cause, path }),
+          }),
+        )
+
+        if (Either.isLeft(result)) {
+          const error = result.left
+          for (const route of Route.use(
+            Route.render((): Effect.Effect<string, FileRouterError> => Effect.fail(error)),
+          )) {
             ;(allRoutes as Array<any>).push(route)
           }
+        } else {
+          const m = result.right
+          if (Route.isRouteSet(m.default)) {
+            for (const route of m.default) {
+              ;(allRoutes as Array<any>).push(route)
+            }
+          }
         }
       }
 
@@ -179,11 +176,7 @@ export function fromFileRoutes(fileRoutes: FileRoutes): Effect.Effect<RouteTree.
 
 export function walkRoutesDirectory(
   dir: string,
-): Effect.Effect<
-  OrderedFileRoutes,
-  PlatformError.PlatformError | FileRouterError,
-  FileSystem.FileSystem
-> {
+): Effect.Effect<OrderedFileRoutes, System.SystemError | FileRouterError, FileSystem.FileSystem> {
   return Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem
     const files = yield* fs.readDirectory(dir, { recursive: true })
@@ -209,10 +202,14 @@ export function getFileRoutes(
       })
       .filter((route): route is FileRoute => route !== null)
       .toSorted((a, b) => {
-        const aDepth = a.segments.length
-        const bDepth = b.segments.length
-        const aHasRest = a.segments.some((seg) => seg._tag === "RestSegment")
-        const bHasRest = b.segments.some((seg) => seg._tag === "RestSegment")
+        const aDepth = a.modulePath.split("/").filter(Boolean).length - 1
+        const bDepth = b.modulePath.split("/").filter(Boolean).length - 1
+        const aHasRest = a.routePath
+          .split("/")
+          .some((seg) => seg.startsWith(":") && seg.endsWith("*"))
+        const bHasRest = b.routePath
+          .split("/")
+          .some((seg) => seg.startsWith(":") && seg.endsWith("*"))
 
         return (
           // rest is a dominant factor (routes with rest come last)

package/src/FileRouterCodegen.ts

@@ -1,11 +1,10 @@
 import * as FileSystem from "./FileSystem.ts"
 import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
 import * as Schema from "effect/Schema"
 import * as NPath from "node:path"
-import * as FilePathPattern from "./FilePathPattern.ts"
 import * as FileRouter from "./FileRouter.ts"
-import * as SchemaExtra from "./SchemaExtra.ts"
+import * as PathPattern from "./_PathPattern.ts"
+import * as SchemaExtra from "./_SchemaExtra.ts"
 
 export function validateRouteModule(module: unknown): module is FileRouter.RouteModule {
   if (typeof module !== "object" || module === null) {
@@ -20,17 +19,11 @@ export function validateRouteModule(module: unknown): module is FileRouter.Route
   return true
 }
 
-export function generatePathParamsSchema(
-  segments: ReadonlyArray<FilePathPattern.Segment>,
-): Schema.Struct<any> | null {
+export function generatePathParamsSchema(path: PathPattern.PathPattern): Schema.Struct<any> | null {
   const fields: Record<PropertyKey, Schema.Schema.Any | Schema.PropertySignature.All> = {}
 
-  for (const segment of segments) {
-    if (segment._tag === "ParamSegment") {
-      fields[segment.name] = Schema.String
-    } else if (segment._tag === "RestSegment") {
-      fields[segment.name] = Schema.optional(Schema.String)
-    }
+  for (const param of PathPattern.params(path)) {
+    fields[param.name] = param.optional ? Schema.optional(Schema.String) : Schema.String
   }
 
   if (Object.keys(fields).length === 0) {
@@ -54,7 +47,7 @@ export function validateRouteModules(
 
     for (const handle of routeHandles) {
       const routeModulePath = NPath.resolve(path, handle.modulePath)
-      const expectedSchema = generatePathParamsSchema(handle.segments)
+      const expectedSchema = generatePathParamsSchema(handle.routePath)
 
       const fileExists = yield* fs
         .exists(routeModulePath)
@@ -144,20 +137,13 @@ export function generateCode(fileRoutes: FileRouter.OrderedFileRoutes): string |
       currentPath = parentPath || "/"
     }
 
-    // Convert file-style path to colon-style PathPattern
-    const pathPatternResult = FilePathPattern.toPathPattern(path)
-    if (Either.isLeft(pathPatternResult)) {
-      continue
-    }
-    const pathPattern = pathPatternResult.right
-
     // Order: route first, then layers from innermost to outermost
     const loaders: Array<string> = [
       `() => import(".${route.modulePath}")`,
       ...allLayers.reverse().map((layer) => `() => import(".${layer.modulePath}")`),
     ]
 
-    entries.push({ path: pathPattern, loaders })
+    entries.push({ path, loaders })
   }
 
   // No routes found - don't create file
@@ -188,7 +174,7 @@ ${routeEntries},
  */
 export function update(
   routesPath: string,
-  treePath = "server.gen.ts",
+  treePath = ".server.ts",
 ): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem> {
   return Effect.gen(function* () {
     treePath = NPath.resolve(routesPath, treePath)
@@ -259,7 +245,7 @@ export function update(
 
 export function dump(
   routesPath: string,
-  treePath = "server.gen.ts",
+  treePath = ".server.ts",
 ): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem> {
   return Effect.gen(function* () {
     treePath = NPath.resolve(routesPath, treePath)