effect-start 0.21.0 → 0.22.1

package/src/FileRouterCodegen.ts

@@ -7,9 +7,7 @@ import * as FilePathPattern from "./FilePathPattern.ts"
 import * as FileRouter from "./FileRouter.ts"
 import * as SchemaExtra from "./SchemaExtra.ts"
 
-export function validateRouteModule(
-  module: unknown,
-): module is FileRouter.RouteModule {
+export function validateRouteModule(module: unknown): module is FileRouter.RouteModule {
   if (typeof module !== "object" || module === null) {
     return false
   }
@@ -25,10 +23,7 @@ export function validateRouteModule(
 export function generatePathParamsSchema(
   segments: ReadonlyArray<FilePathPattern.Segment>,
 ): Schema.Struct<any> | null {
-  const fields: Record<
-    PropertyKey,
-    Schema.Schema.Any | Schema.PropertySignature.All
-  > = {}
+  const fields: Record<PropertyKey, Schema.Schema.Any | Schema.PropertySignature.All> = {}
 
   for (const segment of segments) {
     if (segment._tag === "ParamSegment") {
@@ -53,17 +48,17 @@ export function validateRouteModules(
   path: string,
   routes: FileRouter.OrderedFileRoutes,
 ): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem> {
-  return Effect.gen(function*() {
+  return Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem
-    const routeHandles = routes.filter(h => h.handle === "route")
+    const routeHandles = routes.filter((h) => h.handle === "route")
 
     for (const handle of routeHandles) {
       const routeModulePath = NPath.resolve(path, handle.modulePath)
       const expectedSchema = generatePathParamsSchema(handle.segments)
 
-      const fileExists = yield* fs.exists(routeModulePath).pipe(
-        Effect.catchAll(() => Effect.succeed(false)),
-      )
+      const fileExists = yield* fs
+        .exists(routeModulePath)
+        .pipe(Effect.catchAll(() => Effect.succeed(false)))
       if (!fileExists) {
         continue
       }
@@ -79,9 +74,7 @@ export function validateRouteModules(
       })
 
       if (!validateRouteModule(module)) {
-        yield* Effect.logWarning(
-          `Route module ${routeModulePath} should export default Route`,
-        )
+        yield* Effect.logWarning(`Route module ${routeModulePath} should export default Route`)
         continue
       }
 
@@ -89,30 +82,27 @@ export function validateRouteModules(
       // extract user schema
       const userSchema = undefined
 
-      if (
-        expectedSchema
-        && userSchema
-        && !SchemaExtra.schemaEqual(userSchema, expectedSchema)
-      ) {
+      if (expectedSchema && userSchema && !SchemaExtra.schemaEqual(userSchema, expectedSchema)) {
         const relativeFilePath = NPath.relative(process.cwd(), routeModulePath)
         yield* Effect.logError(
-          `Route '${relativeFilePath}' has incorrect PathParams schema, expected schemaPathParams(${
-            SchemaExtra.formatSchemaCode(expectedSchema)
-          })`,
+          `Route '${relativeFilePath}' has incorrect PathParams schema, expected schemaPathParams(${SchemaExtra.formatSchemaCode(
+            expectedSchema,
+          )})`,
         )
       }
     }
   })
 }
 
-export function generateCode(
-  fileRoutes: FileRouter.OrderedFileRoutes,
-): string | null {
+export function generateCode(fileRoutes: FileRouter.OrderedFileRoutes): string | null {
   // Group routes by path to find layers
-  const routesByPath = new Map<string, {
-    route?: FileRouter.FileRoute
-    layers: FileRouter.FileRoute[]
-  }>()
+  const routesByPath = new Map<
+    string,
+    {
+      route?: FileRouter.FileRoute
+      layers: Array<FileRouter.FileRoute>
+    }
+  >()
 
   for (const fileRoute of fileRoutes) {
     const existing = routesByPath.get(fileRoute.routePath) || { layers: [] }
@@ -125,31 +115,26 @@ export function generateCode(
   }
 
   // Helper to check if layer's path is an ancestor of route's path
-  const layerMatchesRoute = (
-    layer: FileRouter.FileRoute,
-    route: FileRouter.FileRoute,
-  ): boolean => {
+  const layerMatchesRoute = (layer: FileRouter.FileRoute, route: FileRouter.FileRoute): boolean => {
     const layerDir = layer.modulePath.replace(/\/(layer)\.(tsx?|jsx?)$/, "")
     if (layerDir === "/") return true
     return route.modulePath.startsWith(layerDir + "/")
   }
 
   // Build entries for each route path
-  const entries: Array<{ path: string; loaders: string[] }> = []
+  const entries: Array<{ path: string; loaders: Array<string> }> = []
 
   for (const [path, { route }] of routesByPath) {
     if (!route) continue
 
     // Collect all parent layers that match the route's groups
-    const allLayers: FileRouter.FileRoute[] = []
+    const allLayers: Array<FileRouter.FileRoute> = []
     let currentPath = path
 
     while (true) {
       const pathData = routesByPath.get(currentPath)
       if (pathData?.layers) {
-        const matchingLayers = pathData.layers.filter(layer =>
-          layerMatchesRoute(layer, route)
-        )
+        const matchingLayers = pathData.layers.filter((layer) => layerMatchesRoute(layer, route))
         allLayers.unshift(...matchingLayers)
       }
 
@@ -167,11 +152,9 @@ export function generateCode(
     const pathPattern = pathPatternResult.right
 
     // Order: route first, then layers from innermost to outermost
-    const loaders: string[] = [
+    const loaders: Array<string> = [
       `() => import(".${route.modulePath}")`,
-      ...allLayers.reverse().map(layer =>
-        `() => import(".${layer.modulePath}")`
-      ),
+      ...allLayers.reverse().map((layer) => `() => import(".${layer.modulePath}")`),
     ]
 
     entries.push({ path: pathPattern, loaders })
@@ -207,13 +190,18 @@ export function update(
   routesPath: string,
   treePath = "server.gen.ts",
 ): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem> {
-  return Effect.gen(function*() {
+  return Effect.gen(function* () {
     treePath = NPath.resolve(routesPath, treePath)
 
     const fs = yield* FileSystem.FileSystem
     const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(
-      Effect.mapError((cause) =>
-        new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: routesPath })
+      Effect.mapError(
+        (cause) =>
+          new FileRouter.FileRouterError({
+            reason: "FileSystem",
+            cause,
+            path: routesPath,
+          }),
       ),
     )
     const fileRoutes = yield* FileRouter.getFileRoutes(files)
@@ -236,8 +224,13 @@ export function update(
         if (existingCode !== emptyCode) {
           yield* Effect.logDebug(`Clearing file routes tree: ${treePath}`)
           yield* fs.writeFileString(treePath, emptyCode).pipe(
-            Effect.mapError((cause) =>
-              new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: treePath })
+            Effect.mapError(
+              (cause) =>
+                new FileRouter.FileRouterError({
+                  reason: "FileSystem",
+                  cause,
+                  path: treePath,
+                }),
             ),
           )
         }
@@ -249,8 +242,13 @@ export function update(
     if (existingCode !== newCode) {
       yield* Effect.logDebug(`Updating file routes tree: ${treePath}`)
       yield* fs.writeFileString(treePath, newCode).pipe(
-        Effect.mapError((cause) =>
-          new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: treePath })
+        Effect.mapError(
+          (cause) =>
+            new FileRouter.FileRouterError({
+              reason: "FileSystem",
+              cause,
+              path: treePath,
+            }),
         ),
       )
     } else {
@@ -263,13 +261,18 @@ export function dump(
   routesPath: string,
   treePath = "server.gen.ts",
 ): Effect.Effect<void, FileRouter.FileRouterError, FileSystem.FileSystem> {
-  return Effect.gen(function*() {
+  return Effect.gen(function* () {
     treePath = NPath.resolve(routesPath, treePath)
 
     const fs = yield* FileSystem.FileSystem
     const files = yield* fs.readDirectory(routesPath, { recursive: true }).pipe(
-      Effect.mapError((cause) =>
-        new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: routesPath })
+      Effect.mapError(
+        (cause) =>
+          new FileRouter.FileRouterError({
+            reason: "FileSystem",
+            cause,
+            path: routesPath,
+          }),
       ),
     )
     const fileRoutes = yield* FileRouter.getFileRoutes(files)
@@ -288,8 +291,13 @@ export function dump(
     yield* Effect.logDebug(`Generating file routes tree: ${treePath}`)
 
     yield* fs.writeFileString(treePath, code).pipe(
-      Effect.mapError((cause) =>
-        new FileRouter.FileRouterError({ reason: "FileSystem", cause, path: treePath })
+      Effect.mapError(
+        (cause) =>
+          new FileRouter.FileRouterError({
+            reason: "FileSystem",
+            cause,
+            path: treePath,
+          }),
       ),
     )
   })

package/src/FileSystem.ts

@@ -28,18 +28,13 @@ export interface FileSystem {
     fromPath: string,
     toPath: string,
   ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly chmod: (
-    path: string,
-    mode: number,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  readonly chmod: (path: string, mode: number) => Effect.Effect<void, PlatformError.PlatformError>
   readonly chown: (
     path: string,
     uid: number,
     gid: number,
   ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly exists: (
-    path: string,
-  ) => Effect.Effect<boolean, PlatformError.PlatformError>
+  readonly exists: (path: string) => Effect.Effect<boolean, PlatformError.PlatformError>
   readonly link: (
     fromPath: string,
     toPath: string,
@@ -68,19 +63,13 @@ export interface FileSystem {
     path: string,
     options?: ReadDirectoryOptions,
   ) => Effect.Effect<Array<string>, PlatformError.PlatformError>
-  readonly readFile: (
-    path: string,
-  ) => Effect.Effect<Uint8Array, PlatformError.PlatformError>
+  readonly readFile: (path: string) => Effect.Effect<Uint8Array, PlatformError.PlatformError>
   readonly readFileString: (
     path: string,
     encoding?: string,
   ) => Effect.Effect<string, PlatformError.PlatformError>
-  readonly readLink: (
-    path: string,
-  ) => Effect.Effect<string, PlatformError.PlatformError>
-  readonly realPath: (
-    path: string,
-  ) => Effect.Effect<string, PlatformError.PlatformError>
+  readonly readLink: (path: string) => Effect.Effect<string, PlatformError.PlatformError>
+  readonly realPath: (path: string) => Effect.Effect<string, PlatformError.PlatformError>
   readonly remove: (
     path: string,
     options?: RemoveOptions,
@@ -93,9 +82,7 @@ export interface FileSystem {
     path: string,
     options?: SinkOptions,
   ) => Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError>
-  readonly stat: (
-    path: string,
-  ) => Effect.Effect<File.Info, PlatformError.PlatformError>
+  readonly stat: (path: string) => Effect.Effect<File.Info, PlatformError.PlatformError>
   readonly stream: (
     path: string,
     options?: StreamOptions,
@@ -138,19 +125,9 @@ export type Size = Brand.Branded<bigint, "Size">
 export type SizeInput = bigint | number | Size
 
 export const Size = (bytes: SizeInput): Size =>
-  typeof bytes === "bigint" ? bytes as Size : BigInt(bytes) as Size
-
-export type OpenFlag =
-  | "r"
-  | "r+"
-  | "w"
-  | "wx"
-  | "w+"
-  | "wx+"
-  | "a"
-  | "ax"
-  | "a+"
-  | "ax+"
+  typeof bytes === "bigint" ? (bytes as Size) : (BigInt(bytes) as Size)
+
+export type OpenFlag = "r" | "r+" | "w" | "wx" | "w+" | "wx+" | "a" | "ax" | "a+" | "ax+"
 
 export type SeekMode = "start" | "current"
 
@@ -229,7 +206,9 @@ export interface File {
   readonly seek: (offset: SizeInput, from: SeekMode) => Effect.Effect<void>
   readonly sync: Effect.Effect<void, PlatformError.PlatformError>
   readonly read: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError.PlatformError>
-  readonly readAlloc: (size: SizeInput) => Effect.Effect<Option.Option<Uint8Array>, PlatformError.PlatformError>
+  readonly readAlloc: (
+    size: SizeInput,
+  ) => Effect.Effect<Option.Option<Uint8Array>, PlatformError.PlatformError>
   readonly truncate: (length?: SizeInput) => Effect.Effect<void, PlatformError.PlatformError>
   readonly write: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError.PlatformError>
   readonly writeAll: (buffer: Uint8Array) => Effect.Effect<void, PlatformError.PlatformError>
@@ -287,17 +266,14 @@ export declare namespace WatchEvent {
   }
 }
 
-export const WatchEventCreate: Data.Case.Constructor<WatchEvent.Create, "_tag"> = Data.tagged<WatchEvent.Create>(
-  "Create",
-)
+export const WatchEventCreate: Data.Case.Constructor<WatchEvent.Create, "_tag"> =
+  Data.tagged<WatchEvent.Create>("Create")
 
-export const WatchEventUpdate: Data.Case.Constructor<WatchEvent.Update, "_tag"> = Data.tagged<WatchEvent.Update>(
-  "Update",
-)
+export const WatchEventUpdate: Data.Case.Constructor<WatchEvent.Update, "_tag"> =
+  Data.tagged<WatchEvent.Update>("Update")
 
-export const WatchEventRemove: Data.Case.Constructor<WatchEvent.Remove, "_tag"> = Data.tagged<WatchEvent.Remove>(
-  "Remove",
-)
+export const WatchEventRemove: Data.Case.Constructor<WatchEvent.Remove, "_tag"> =
+  Data.tagged<WatchEvent.Remove>("Remove")
 
 export class WatchBackend extends Context.Tag("@effect/platform/FileSystem/WatchBackend")<
   WatchBackend,
@@ -319,7 +295,9 @@ export const make = (
       Function.pipe(
         impl.access(path),
         Effect.as(true),
-        Effect.catchTag("SystemError", (e) => e.reason === "NotFound" ? Effect.succeed(false) : Effect.fail(e)),
+        Effect.catchTag("SystemError", (e) =>
+          e.reason === "NotFound" ? Effect.succeed(false) : Effect.fail(e),
+        ),
       ),
     readFileString: (path, encoding) =>
       Effect.tryMap(impl.readFile(path), {
@@ -364,40 +342,49 @@ export const make = (
   })
 }
 
-const fileStream = (file: File, {
-  bufferSize = 16,
-  bytesToRead: bytesToRead_,
-  chunkSize: chunkSize_ = Size(64 * 1024),
-}: StreamOptions = {}) => {
+const fileStream = (
+  file: File,
+  {
+    bufferSize = 16,
+    bytesToRead: bytesToRead_,
+    chunkSize: chunkSize_ = Size(64 * 1024),
+  }: StreamOptions = {},
+) => {
   const bytesToRead = bytesToRead_ !== undefined ? Size(bytesToRead_) : undefined
   const chunkSize = Size(chunkSize_)
 
   function loop(
     totalBytesRead: bigint,
-  ): Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, PlatformError.PlatformError, unknown, void, unknown> {
+  ): Channel.Channel<
+    Chunk.Chunk<Uint8Array>,
+    unknown,
+    PlatformError.PlatformError,
+    unknown,
+    void,
+    unknown
+  > {
     if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
       return Channel.void
     }
 
-    const toRead = bytesToRead !== undefined && (bytesToRead - totalBytesRead) < chunkSize
-      ? bytesToRead - totalBytesRead
-      : chunkSize
+    const toRead =
+      bytesToRead !== undefined && bytesToRead - totalBytesRead < chunkSize
+        ? bytesToRead - totalBytesRead
+        : chunkSize
 
     return Channel.flatMap(
       file.readAlloc(toRead),
       Option.match({
         onNone: () => Channel.void,
         onSome: (buf) =>
-          Channel.flatMap(
-            Channel.write(Chunk.of(buf)),
-            () => loop(totalBytesRead + BigInt(buf.length)),
+          Channel.flatMap(Channel.write(Chunk.of(buf)), () =>
+            loop(totalBytesRead + BigInt(buf.length)),
           ),
       }),
     )
   }
 
-  return Stream.bufferChunks(
-    Stream.fromChannel(loop(BigInt(0))),
-    { capacity: bufferSize },
-  )
+  return Stream.bufferChunks(Stream.fromChannel(loop(BigInt(0))), {
+    capacity: bufferSize,
+  })
 }

package/src/Http.ts

@@ -1,38 +1,21 @@
 import * as Values from "./Values.ts"
 
-export type Method =
-  | "GET"
-  | "POST"
-  | "PUT"
-  | "DELETE"
-  | "PATCH"
-  | "HEAD"
-  | "OPTIONS"
-
-type Respondable =
-  | Response
-  | Promise<Response>
+export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS"
+
+type Respondable = Response | Promise<Response>
 
 export type WebHandler = (request: Request) => Respondable
 
-export type WebMiddleware = (
-  request: Request,
-  next: WebHandler,
-) => Respondable
+export type WebMiddleware = (request: Request, next: WebHandler) => Respondable
 
 export function fetch(
   handler: WebHandler,
-  init:
-    & Omit<RequestInit, "body">
-    & (
-      | { url: string }
-      | { path: `/${string}` }
-    )
-    & { body?: RequestInit["body"] | Record<string, unknown> },
+  init: Omit<RequestInit, "body"> &
+    ({ url: string } | { path: `/${string}` }) & {
+      body?: RequestInit["body"] | Record<string, unknown>
+    },
 ): Promise<Response> {
-  const url = "path" in init
-    ? `http://localhost${init.path}`
-    : init.url
+  const url = "path" in init ? `http://localhost${init.path}` : init.url
 
   const isPlain = Values.isPlainObject(init.body)
 
@@ -52,24 +35,15 @@ export function fetch(
 }
 
 export function createAbortableRequest(
-  init:
-    & Omit<RequestInit, "signal">
-    & (
-      | { url: string }
-      | { path: `/${string}` }
-    ),
+  init: Omit<RequestInit, "signal"> & ({ url: string } | { path: `/${string}` }),
 ): { request: Request; abort: () => void } {
-  const url = "path" in init
-    ? `http://localhost${init.path}`
-    : init.url
+  const url = "path" in init ? `http://localhost${init.path}` : init.url
   const controller = new AbortController()
   const request = new Request(url, { ...init, signal: controller.signal })
   return { request, abort: () => controller.abort() }
 }
 
-export function mapHeaders(
-  headers: Headers,
-): Record<string, string | undefined> {
+export function mapHeaders(headers: Headers): Record<string, string | undefined> {
   const result: Record<string, string | undefined> = {}
   headers.forEach((value, key) => {
     result[key.toLowerCase()] = value
@@ -77,9 +51,7 @@ export function mapHeaders(
   return result
 }
 
-export function parseCookies(
-  cookieHeader: string | null,
-): Record<string, string | undefined> {
+export function parseCookies(cookieHeader: string | null): Record<string, string | undefined> {
   if (!cookieHeader) return {}
   const result: Record<string, string | undefined> = {}
   for (const part of cookieHeader.split(";")) {
@@ -130,23 +102,18 @@ export type MultipartPart = FilePart | FieldPart
 
 export async function parseFormData(
   request: Request,
-): Promise<
-  Record<string, ReadonlyArray<FilePart> | ReadonlyArray<string> | string>
-> {
+): Promise<Record<string, ReadonlyArray<FilePart> | ReadonlyArray<string> | string>> {
   const formData = await request.formData()
-  const result: Record<
-    string,
-    ReadonlyArray<FilePart> | ReadonlyArray<string> | string
-  > = {}
+  const result: Record<string, ReadonlyArray<FilePart> | ReadonlyArray<string> | string> = {}
 
   for (const key of new Set(formData.keys())) {
     const values = formData.getAll(key)
     const first = values[0]
 
     if (typeof first === "string") {
-      result[key] = values.length === 1 ? first : (values as string[])
+      result[key] = values.length === 1 ? first : (values as Array<string>)
     } else {
-      const files: FilePart[] = []
+      const files: Array<FilePart> = []
       for (const value of values) {
         if (typeof value !== "string") {
           const content = new Uint8Array(await value.arrayBuffer())

package/src/PathPattern.ts

@@ -2,24 +2,29 @@ export type PathPattern = `/${string}`
 
 export type Segments<Path extends string> = Path extends `/${infer Rest}`
   ? Segments<Rest>
-  : Path extends `${infer Head}/${infer Tail}` ? [Head, ...Segments<Tail>]
-  : Path extends "" ? []
-  : [Path]
-
-export type Params<T extends string> = string extends T ? Record<string, string>
+  : Path extends `${infer Head}/${infer Tail}`
+    ? [Head, ...Segments<Tail>]
+    : Path extends ""
+      ? []
+      : [Path]
+
+export type Params<T extends string> = string extends T
+  ? Record<string, string>
   : T extends `${infer _Start}:${infer Param}?/${infer Rest}`
     ? { [K in Param]?: string } & Params<`/${Rest}`>
-  : T extends `${infer _Start}:${infer Param}/${infer Rest}`
-    ? { [K in Param]: string } & Params<`/${Rest}`>
-  : T extends `${infer _Start}:${infer Param}+` ? { [K in Param]: string }
-  : T extends `${infer _Start}:${infer Param}*` ? { [K in Param]?: string }
-  : T extends `${infer _Start}:${infer Param}?` ? { [K in Param]?: string }
-  : T extends `${infer _Start}:${infer Param}` ? { [K in Param]: string }
-  : {}
-
-export type ValidateResult =
-  | { ok: true; segments: string[] }
-  | { ok: false; error: string }
+    : T extends `${infer _Start}:${infer Param}/${infer Rest}`
+      ? { [K in Param]: string } & Params<`/${Rest}`>
+      : T extends `${infer _Start}:${infer Param}+`
+        ? { [K in Param]: string }
+        : T extends `${infer _Start}:${infer Param}*`
+          ? { [K in Param]?: string }
+          : T extends `${infer _Start}:${infer Param}?`
+            ? { [K in Param]?: string }
+            : T extends `${infer _Start}:${infer Param}`
+              ? { [K in Param]: string }
+              : {}
+
+export type ValidateResult = { ok: true; segments: Array<string> } | { ok: false; error: string }
 
 function isValidSegment(segment: string): boolean {
   if (segment.startsWith(":")) {
@@ -46,10 +51,7 @@ export function validate(path: string): ValidateResult {
   return { ok: true, segments }
 }
 
-export function match(
-  pattern: string,
-  path: string,
-): Record<string, string> | null {
+export function match(pattern: string, path: string): Record<string, string> | null {
   const patternSegments = pattern.split("/").filter(Boolean)
   const pathSegments = path.split("/").filter(Boolean)
   const params: Record<string, string> = {}
@@ -153,11 +155,9 @@ function getParamName(seg: string): string {
  * - `:param+` → `/*param`
  * - `:param*` → `/`, `/*param`
  */
-export function toExpress(path: string): string[] {
+export function toExpress(path: string): Array<string> {
   const segments = path.split("/").filter(Boolean)
-  const optionalWildcardIndex = segments.findIndex(
-    (s) => s.startsWith(":") && s.endsWith("*"),
-  )
+  const optionalWildcardIndex = segments.findIndex((s) => s.startsWith(":") && s.endsWith("*"))
 
   if (optionalWildcardIndex !== -1) {
     const before = segments.slice(0, optionalWildcardIndex)
@@ -207,7 +207,7 @@ export function toExpress(path: string): string[] {
  * - `:param+` → `:param+`
  * - `:param*` → `:param*`
  */
-export function toURLPattern(path: string): string[] {
+export function toURLPattern(path: string): Array<string> {
   const segments = path.split("/").filter(Boolean)
   const joined = segments
     .map((seg) => {
@@ -230,11 +230,9 @@ export function toURLPattern(path: string): string[] {
  * - `:param+` → `*` (splat, required)
  * - `:param*` → `/`, `/*` (splat, optional - two routes)
  */
-export function toReactRouter(path: string): string[] {
+export function toReactRouter(path: string): Array<string> {
   const segments = path.split("/").filter(Boolean)
-  const optionalWildcardIndex = segments.findIndex(
-    (s) => s.startsWith(":") && s.endsWith("*"),
-  )
+  const optionalWildcardIndex = segments.findIndex((s) => s.startsWith(":") && s.endsWith("*"))
 
   if (optionalWildcardIndex !== -1) {
     const before = segments.slice(0, optionalWildcardIndex)
@@ -361,11 +359,9 @@ export function toTanStack(path: string): string {
  * - `:param+` → `*` (unnamed, required)
  * - `:param*` → `/`, `/*` (unnamed, optional - two routes)
  */
-export function toHono(path: string): string[] {
+export function toHono(path: string): Array<string> {
   const segments = path.split("/").filter(Boolean)
-  const optionalWildcardIndex = segments.findIndex(
-    (s) => s.startsWith(":") && s.endsWith("*"),
-  )
+  const optionalWildcardIndex = segments.findIndex((s) => s.startsWith(":") && s.endsWith("*"))
 
   if (optionalWildcardIndex !== -1) {
     const before = segments.slice(0, optionalWildcardIndex)
@@ -413,7 +409,7 @@ export function toHono(path: string): string[] {
  * - `:param+` → `*` (unnamed)
  * - `:param*` → `/`, `/*` (two routes)
  */
-export function toEffect(path: string): string[] {
+export function toEffect(path: string): Array<string> {
   return toHono(path)
 }
 
@@ -430,7 +426,7 @@ export function toEffect(path: string): string[] {
  * - `:param+` → `/*`
  * - `:param*` → `/`, `/*` (two routes)
  */
-export function toBun(path: string): PathPattern[] {
+export function toBun(path: string): Array<PathPattern> {
   const segments = path.split("/").filter(Boolean)
 
   const optionalIndex = segments.findIndex(
@@ -472,14 +468,10 @@ export function toBun(path: string): PathPattern[] {
 
   const optionalModifier = getModifier(optional)
   const optionalName = getParamName(optional)
-  const requiredOptional = optionalModifier === "*"
-    ? `:${optionalName}+`
-    : `:${optionalName}`
+  const requiredOptional = optionalModifier === "*" ? `:${optionalName}+` : `:${optionalName}`
 
   const withOptionalSegments = [...before, requiredOptional, ...after]
-  const withOptionalPath: PathPattern = `/${
-    withOptionalSegments.map(formatSegment).join("/")
-  }`
+  const withOptionalPath: PathPattern = `/${withOptionalSegments.map(formatSegment).join("/")}`
 
   return [...toBun(basePath), ...toBun(withOptionalPath)]
 }