@pyreon/zero 0.4.1 → 0.11.0

package/src/adapters/static.ts

@@ -1,4 +1,4 @@
-import type { Adapter, AdapterBuildOptions } from '../types'
+import type { Adapter, AdapterBuildOptions } from "../types"
 
 /**
  * Static adapter — just copies the client build output.
@@ -6,9 +6,9 @@ import type { Adapter, AdapterBuildOptions } from '../types'
  */
 export function staticAdapter(): Adapter {
   return {
-    name: 'static',
+    name: "static",
     async build(options: AdapterBuildOptions) {
-      const { cp, mkdir } = await import('node:fs/promises')
+      const { cp, mkdir } = await import("node:fs/promises")
 
       await mkdir(options.outDir, { recursive: true })
       await cp(options.clientOutDir, options.outDir, { recursive: true })

package/src/api-routes.ts

@@ -1,16 +1,9 @@
-import type { Middleware, MiddlewareContext } from '@pyreon/server'
+import type { Middleware, MiddlewareContext } from "@pyreon/server"
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
 /** HTTP methods supported by API routes. */
-export type HttpMethod =
-  | 'GET'
-  | 'POST'
-  | 'PUT'
-  | 'PATCH'
-  | 'DELETE'
-  | 'HEAD'
-  | 'OPTIONS'
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS"
 
 /** Context passed to API route handlers. */
 export interface ApiContext {
@@ -54,12 +47,9 @@ export interface ApiRouteEntry {
  * Match a URL path against an API route pattern.
  * Returns extracted params or null if no match.
  */
-export function matchApiRoute(
-  pattern: string,
-  path: string,
-): Record<string, string> | null {
-  const patternParts = pattern.split('/').filter(Boolean)
-  const pathParts = path.split('/').filter(Boolean)
+export function matchApiRoute(pattern: string, path: string): Record<string, string> | null {
+  const patternParts = pattern.split("/").filter(Boolean)
+  const pathParts = path.split("/").filter(Boolean)
   const params: Record<string, string> = {}
 
   for (let i = 0; i < patternParts.length; i++) {
@@ -67,9 +57,9 @@ export function matchApiRoute(
     if (!pp) continue
 
     // Catch-all: :param*
-    if (pp.endsWith('*')) {
+    if (pp.endsWith("*")) {
       const paramName = pp.slice(1, -1)
-      params[paramName] = pathParts.slice(i).join('/')
+      params[paramName] = pathParts.slice(i).join("/")
       return params
     }
 
@@ -77,7 +67,7 @@ export function matchApiRoute(
     if (i >= pathParts.length) return null
 
     // Dynamic segment: :param
-    if (pp.startsWith(':')) {
+    if (pp.startsWith(":")) {
       params[pp.slice(1)] = pathParts[i]!
       continue
     }
@@ -91,15 +81,7 @@ export function matchApiRoute(
 
 // ─── Middleware ───────────────────────────────────────────────────────────────
 
-const HTTP_METHODS: HttpMethod[] = [
-  'GET',
-  'POST',
-  'PUT',
-  'PATCH',
-  'DELETE',
-  'HEAD',
-  'OPTIONS',
-]
+const HTTP_METHODS: HttpMethod[] = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]
 
 /**
  * Create a middleware that dispatches API route requests.
@@ -116,12 +98,12 @@ export function createApiMiddleware(routes: ApiRouteEntry[]): Middleware {
 
       if (!handler) {
         // Route matched but method not supported
-        const allowed = HTTP_METHODS.filter((m) => route.module[m]).join(', ')
+        const allowed = HTTP_METHODS.filter((m) => route.module[m]).join(", ")
         return new Response(null, {
           status: 405,
           headers: {
             Allow: allowed,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
           },
         })
       }
@@ -144,12 +126,12 @@ export function createApiMiddleware(routes: ApiRouteEntry[]): Middleware {
  * API routes are `.ts` or `.js` files inside an `api/` directory.
  */
 export function isApiRoute(filePath: string): boolean {
-  const normalized = filePath.replace(/\\/g, '/')
+  const normalized = filePath.replace(/\\/g, "/")
   return (
-    normalized.startsWith('api/') &&
-    (normalized.endsWith('.ts') || normalized.endsWith('.js')) &&
-    !normalized.endsWith('.tsx') &&
-    !normalized.endsWith('.jsx')
+    normalized.startsWith("api/") &&
+    (normalized.endsWith(".ts") || normalized.endsWith(".js")) &&
+    !normalized.endsWith(".tsx") &&
+    !normalized.endsWith(".jsx")
   )
 }
 
@@ -165,18 +147,18 @@ export function isApiRoute(filePath: string): boolean {
 export function apiFilePathToPattern(filePath: string): string {
   let route = filePath
   // Remove extension
-  for (const ext of ['.ts', '.js']) {
+  for (const ext of [".ts", ".js"]) {
     if (route.endsWith(ext)) {
       route = route.slice(0, -ext.length)
       break
     }
   }
 
-  const segments = route.split('/')
+  const segments = route.split("/")
   const urlSegments: string[] = []
 
   for (const seg of segments) {
-    if (seg === 'index') continue
+    if (seg === "index") continue
 
     // Catch-all: [...param]
     const catchAll = seg.match(/^\[\.\.\.(\w+)\]$/)
@@ -195,21 +177,18 @@ export function apiFilePathToPattern(filePath: string): string {
     urlSegments.push(seg)
   }
 
-  return `/${urlSegments.join('/')}`
+  return `/${urlSegments.join("/")}`
 }
 
 /**
  * Generate a virtual module that exports API route entries.
  * Each entry maps a URL pattern to a module with HTTP method handlers.
  */
-export function generateApiRouteModule(
-  files: string[],
-  routesDir: string,
-): string {
+export function generateApiRouteModule(files: string[], routesDir: string): string {
   const apiFiles = files.filter(isApiRoute)
 
   if (apiFiles.length === 0) {
-    return 'export const apiRoutes = []\n'
+    return "export const apiRoutes = []\n"
   }
 
   const imports: string[] = []
@@ -226,11 +205,5 @@ export function generateApiRouteModule(
     entries.push(`  { pattern: ${JSON.stringify(pattern)}, module: ${name} }`)
   }
 
-  return [
-    ...imports,
-    '',
-    'export const apiRoutes = [',
-    entries.join(',\n'),
-    ']',
-  ].join('\n')
+  return [...imports, "", "export const apiRoutes = [", entries.join(",\n"), "]"].join("\n")
 }

package/src/app.ts

@@ -1,8 +1,8 @@
-import type { ComponentFn, Props } from '@pyreon/core'
-import { Fragment, h } from '@pyreon/core'
-import { HeadProvider } from '@pyreon/head'
-import type { RouteRecord } from '@pyreon/router'
-import { createRouter, RouterProvider, RouterView } from '@pyreon/router'
+import type { ComponentFn, Props } from "@pyreon/core"
+import { Fragment, h } from "@pyreon/core"
+import { HeadProvider } from "@pyreon/head"
+import type { RouteRecord } from "@pyreon/router"
+import { createRouter, RouterProvider, RouterView } from "@pyreon/router"
 
 // ─── App assembly ────────────────────────────────────────────────────────────
 
@@ -11,7 +11,7 @@ export interface CreateAppOptions {
   routes: RouteRecord[]
 
   /** Router mode. Default: "history" for SSR, "hash" for SPA. */
-  routerMode?: 'hash' | 'history'
+  routerMode?: "hash" | "history"
 
   /** Initial URL for SSR. */
   url?: string
@@ -31,9 +31,9 @@ export interface CreateAppOptions {
 export function createApp(options: CreateAppOptions) {
   const router = createRouter({
     routes: options.routes,
-    mode: options.routerMode ?? 'history',
+    mode: options.routerMode ?? "history",
     ...(options.url ? { url: options.url } : {}),
-    scrollBehavior: 'top',
+    scrollBehavior: "top",
   })
 
   const Layout = options.layout ?? DefaultLayout
@@ -54,9 +54,5 @@ export function createApp(options: CreateAppOptions) {
 }
 
 function DefaultLayout(props: Props) {
-  return h(
-    Fragment,
-    null,
-    ...(Array.isArray(props.children) ? props.children : [props.children]),
-  )
+  return h(Fragment, null, ...(Array.isArray(props.children) ? props.children : [props.children]))
 }

package/src/cache.ts

@@ -1,4 +1,4 @@
-import type { Middleware, MiddlewareContext } from '@pyreon/server'
+import type { Middleware, MiddlewareContext } from "@pyreon/server"
 
 // ─── Cache control middleware ───────────────────────────────────────────────
 //
@@ -32,15 +32,14 @@ export interface CacheRule {
 }
 
 const HASHED_ASSET = /\.[a-f0-9]{8,}\.\w+$/
-const STATIC_EXT =
-  /\.(png|jpe?g|gif|svg|webp|avif|ico|woff2?|ttf|otf|eot|mp4|webm|ogg|mp3|wav)$/i
+const STATIC_EXT = /\.(png|jpe?g|gif|svg|webp|avif|ico|woff2?|ttf|otf|eot|mp4|webm|ogg|mp3|wav)$/i
 const SCRIPT_EXT = /\.(js|css|mjs)$/i
 
 /** @internal Exported for testing */
 export function matchGlob(pattern: string, path: string): boolean {
   // Escape regex special chars, then convert glob wildcards
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&')
-  const regex = escaped.replace(/\*/g, '.*').replace(/\?/g, '.')
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&")
+  const regex = escaped.replace(/\*/g, ".*").replace(/\?/g, ".")
   return new RegExp(`^${regex}$`).test(path)
 }
 
@@ -63,7 +62,7 @@ function resolveControl(
   if (pageDuration > 0) {
     return `public, max-age=${pageDuration}, stale-while-revalidate=${swr}`
   }
-  return 'no-cache'
+  return "no-cache"
 }
 
 /**
@@ -98,19 +97,13 @@ export function cacheMiddleware(config: CacheConfig = {}): Middleware {
 
     for (const rule of rules) {
       if (matchGlob(rule.match, path)) {
-        ctx.headers.set('Cache-Control', rule.control)
+        ctx.headers.set("Cache-Control", rule.control)
         return
       }
     }
 
-    const control = resolveControl(
-      path,
-      immutableDuration,
-      staticDuration,
-      pageDuration,
-      swr,
-    )
-    ctx.headers.set('Cache-Control', control)
+    const control = resolveControl(path, immutableDuration, staticDuration, pageDuration, swr)
+    ctx.headers.set("Cache-Control", control)
   }
 }
 
@@ -120,14 +113,11 @@ export function cacheMiddleware(config: CacheConfig = {}): Middleware {
  */
 export function securityHeaders(): Middleware {
   return (ctx: MiddlewareContext) => {
-    ctx.headers.set('X-Content-Type-Options', 'nosniff')
-    ctx.headers.set('X-Frame-Options', 'DENY')
-    ctx.headers.set('X-XSS-Protection', '1; mode=block')
-    ctx.headers.set('Referrer-Policy', 'strict-origin-when-cross-origin')
-    ctx.headers.set(
-      'Permissions-Policy',
-      'camera=(), microphone=(), geolocation=()',
-    )
+    ctx.headers.set("X-Content-Type-Options", "nosniff")
+    ctx.headers.set("X-Frame-Options", "DENY")
+    ctx.headers.set("X-XSS-Protection", "1; mode=block")
+    ctx.headers.set("Referrer-Policy", "strict-origin-when-cross-origin")
+    ctx.headers.set("Permissions-Policy", "camera=(), microphone=(), geolocation=()")
   }
 }
 
@@ -138,12 +128,9 @@ export function securityHeaders(): Middleware {
  */
 export function varyEncoding(): Middleware {
   return (ctx: MiddlewareContext) => {
-    const existing = ctx.headers.get('Vary')
-    if (!existing?.includes('Accept-Encoding')) {
-      ctx.headers.set(
-        'Vary',
-        existing ? `${existing}, Accept-Encoding` : 'Accept-Encoding',
-      )
+    const existing = ctx.headers.get("Vary")
+    if (!existing?.includes("Accept-Encoding")) {
+      ctx.headers.set("Vary", existing ? `${existing}, Accept-Encoding` : "Accept-Encoding")
     }
   }
 }

package/src/client.ts

@@ -1,8 +1,8 @@
-import type { ComponentFn } from '@pyreon/core'
-import { h } from '@pyreon/core'
-import type { RouteRecord } from '@pyreon/router'
-import { hydrateRoot, mount } from '@pyreon/runtime-dom'
-import { createApp } from './app'
+import type { ComponentFn } from "@pyreon/core"
+import { h } from "@pyreon/core"
+import type { RouteRecord } from "@pyreon/router"
+import { hydrateRoot, mount } from "@pyreon/runtime-dom"
+import { createApp } from "./app"
 
 // ─── Client entry factory ───────────────────────────────────────────────────
 
@@ -23,12 +23,12 @@ export interface StartClientOptions {
  * startClient({ routes })
  */
 export function startClient(options: StartClientOptions) {
-  const container = document.getElementById('app')
-  if (!container) throw new Error('[zero] Missing #app container element')
+  const container = document.getElementById("app")
+  if (!container) throw new Error("[zero] Missing #app container element")
 
   const { App } = createApp({
     routes: options.routes,
-    routerMode: 'history',
+    routerMode: "history",
     ...(options.layout ? { layout: options.layout } : {}),
   })
 

package/src/compression.ts

@@ -1,4 +1,4 @@
-import type { Middleware, MiddlewareContext } from '@pyreon/server'
+import type { Middleware, MiddlewareContext } from "@pyreon/server"
 
 // ─── Compression middleware ─────────────────────────────────────────────────
 
@@ -6,7 +6,7 @@ export interface CompressionConfig {
   /** Minimum response size in bytes to compress. Default: `1024` (1KB) */
   threshold?: number
   /** Encoding preference order. Default: `["gzip", "deflate"]` */
-  encodings?: ('gzip' | 'deflate')[]
+  encodings?: ("gzip" | "deflate")[]
 }
 
 /**
@@ -22,13 +22,11 @@ export interface CompressionConfig {
  * compressionMiddleware() // gzip with 1KB threshold
  * compressionMiddleware({ threshold: 512, encodings: ["gzip"] })
  */
-export function compressionMiddleware(
-  config: CompressionConfig = {},
-): Middleware {
-  const { threshold = 1024, encodings = ['gzip', 'deflate'] } = config
+export function compressionMiddleware(config: CompressionConfig = {}): Middleware {
+  const { threshold = 1024, encodings = ["gzip", "deflate"] } = config
 
   return (ctx: MiddlewareContext) => {
-    const acceptEncoding = ctx.req.headers.get('accept-encoding') ?? ''
+    const acceptEncoding = ctx.req.headers.get("accept-encoding") ?? ""
 
     // Find the best supported encoding
     const encoding = encodings.find((enc) => acceptEncoding.includes(enc))
@@ -37,7 +35,7 @@ export function compressionMiddleware(
     // Store the encoding choice for post-processing
     ctx.locals.__compressionEncoding = encoding
     ctx.locals.__compressionThreshold = threshold
-    ctx.headers.append('Vary', 'Accept-Encoding')
+    ctx.headers.append("Vary", "Accept-Encoding")
   }
 }
 
@@ -51,16 +49,16 @@ export function compressionMiddleware(
  */
 export async function compressResponse(
   response: Response,
-  encoding: 'gzip' | 'deflate',
+  encoding: "gzip" | "deflate",
   threshold: number,
 ): Promise<Response> {
-  const contentType = response.headers.get('content-type') ?? ''
+  const contentType = response.headers.get("content-type") ?? ""
 
   // Only compress text-based content
   if (!isCompressible(contentType)) return response
 
   // Skip if already encoded
-  if (response.headers.get('content-encoding')) return response
+  if (response.headers.get("content-encoding")) return response
 
   const body = await response.arrayBuffer()
 
@@ -70,9 +68,9 @@ export async function compressResponse(
   const compressed = await compress(body, encoding)
 
   const headers = new Headers(response.headers)
-  headers.set('Content-Encoding', encoding)
-  headers.delete('Content-Length')
-  headers.append('Vary', 'Accept-Encoding')
+  headers.set("Content-Encoding", encoding)
+  headers.delete("Content-Length")
+  headers.append("Vary", "Accept-Encoding")
 
   return new Response(compressed, {
     status: response.status,
@@ -82,12 +80,12 @@ export async function compressResponse(
 }
 
 const COMPRESSIBLE_TYPES = [
-  'text/',
-  'application/json',
-  'application/javascript',
-  'application/xml',
-  'application/xhtml+xml',
-  'image/svg+xml',
+  "text/",
+  "application/json",
+  "application/javascript",
+  "application/xml",
+  "application/xhtml+xml",
+  "image/svg+xml",
 ]
 
 /** Check if a content type is compressible. Exported for testing. */
@@ -95,13 +93,8 @@ export function isCompressible(contentType: string): boolean {
   return COMPRESSIBLE_TYPES.some((t) => contentType.includes(t))
 }
 
-async function compress(
-  data: ArrayBuffer,
-  encoding: 'gzip' | 'deflate',
-): Promise<ArrayBuffer> {
-  const format = encoding === 'gzip' ? 'gzip' : 'deflate'
-  const stream = new Blob([data])
-    .stream()
-    .pipeThrough(new CompressionStream(format))
+async function compress(data: ArrayBuffer, encoding: "gzip" | "deflate"): Promise<ArrayBuffer> {
+  const format = encoding === "gzip" ? "gzip" : "deflate"
+  const stream = new Blob([data]).stream().pipeThrough(new CompressionStream(format))
   return new Response(stream).arrayBuffer()
 }

package/src/config.ts

@@ -1,4 +1,4 @@
-import type { ZeroConfig } from './types'
+import type { ZeroConfig } from "./types"
 
 /**
  * Define a Zero configuration.
@@ -20,16 +20,15 @@ export function defineConfig(config: ZeroConfig): ZeroConfig {
 /** Merge user config with defaults. */
 export function resolveConfig(
   userConfig: ZeroConfig = {},
-): Required<Pick<ZeroConfig, 'mode' | 'base' | 'port' | 'adapter'>> &
-  ZeroConfig {
+): Required<Pick<ZeroConfig, "mode" | "base" | "port" | "adapter">> & ZeroConfig {
   return {
-    mode: 'ssr',
-    base: '/',
+    mode: "ssr",
+    base: "/",
     port: 3000,
-    adapter: 'node',
+    adapter: "node",
     ...userConfig,
     ssr: {
-      mode: 'string',
+      mode: "string",
       ...userConfig.ssr,
     },
   }

package/src/cors.ts

@@ -1,4 +1,4 @@
-import type { Middleware, MiddlewareContext } from '@pyreon/server'
+import type { Middleware, MiddlewareContext } from "@pyreon/server"
 
 // ─── CORS middleware ────────────────────────────────────────────────────────
 
@@ -17,8 +17,8 @@ export interface CorsConfig {
   maxAge?: number
 }
 
-const DEFAULT_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS']
-const DEFAULT_HEADERS = ['Content-Type', 'Authorization']
+const DEFAULT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
+const DEFAULT_HEADERS = ["Content-Type", "Authorization"]
 
 /**
  * CORS middleware — handles preflight requests and sets appropriate
@@ -37,7 +37,7 @@ const DEFAULT_HEADERS = ['Content-Type', 'Authorization']
  */
 export function corsMiddleware(config: CorsConfig = {}): Middleware {
   const {
-    origin = '*',
+    origin = "*",
     methods = DEFAULT_METHODS,
     allowedHeaders = DEFAULT_HEADERS,
     exposedHeaders = [],
@@ -46,53 +46,45 @@ export function corsMiddleware(config: CorsConfig = {}): Middleware {
   } = config
 
   return (ctx: MiddlewareContext) => {
-    const requestOrigin = ctx.req.headers.get('origin') ?? ''
+    const requestOrigin = ctx.req.headers.get("origin") ?? ""
     const resolvedOrigin = resolveOrigin(origin, requestOrigin)
 
     if (!resolvedOrigin) return
 
     // Set CORS headers on all responses
-    ctx.headers.set('Access-Control-Allow-Origin', resolvedOrigin)
+    ctx.headers.set("Access-Control-Allow-Origin", resolvedOrigin)
     if (credentials) {
-      ctx.headers.set('Access-Control-Allow-Credentials', 'true')
+      ctx.headers.set("Access-Control-Allow-Credentials", "true")
     }
     if (exposedHeaders.length > 0) {
-      ctx.headers.set(
-        'Access-Control-Expose-Headers',
-        exposedHeaders.join(', '),
-      )
+      ctx.headers.set("Access-Control-Expose-Headers", exposedHeaders.join(", "))
     }
-    if (resolvedOrigin !== '*') {
-      ctx.headers.append('Vary', 'Origin')
+    if (resolvedOrigin !== "*") {
+      ctx.headers.append("Vary", "Origin")
     }
 
     // Handle preflight
-    if (ctx.req.method === 'OPTIONS') {
+    if (ctx.req.method === "OPTIONS") {
       return new Response(null, {
         status: 204,
         headers: {
-          'Access-Control-Allow-Origin': resolvedOrigin,
-          'Access-Control-Allow-Methods': methods.join(', '),
-          'Access-Control-Allow-Headers': allowedHeaders.join(', '),
-          'Access-Control-Max-Age': String(maxAge),
-          ...(credentials
-            ? { 'Access-Control-Allow-Credentials': 'true' }
-            : {}),
+          "Access-Control-Allow-Origin": resolvedOrigin,
+          "Access-Control-Allow-Methods": methods.join(", "),
+          "Access-Control-Allow-Headers": allowedHeaders.join(", "),
+          "Access-Control-Max-Age": String(maxAge),
+          ...(credentials ? { "Access-Control-Allow-Credentials": "true" } : {}),
         },
       })
     }
   }
 }
 
-function resolveOrigin(
-  config: CorsConfig['origin'],
-  requestOrigin: string,
-): string | null {
-  if (config === '*') return '*'
-  if (typeof config === 'string') {
+function resolveOrigin(config: CorsConfig["origin"], requestOrigin: string): string | null {
+  if (config === "*") return "*"
+  if (typeof config === "string") {
     return config === requestOrigin ? config : null
   }
-  if (typeof config === 'function') {
+  if (typeof config === "function") {
     return config(requestOrigin) ? requestOrigin : null
   }
   if (Array.isArray(config)) {

package/src/entry-server.ts

@@ -1,10 +1,10 @@
-import type { RouteRecord } from '@pyreon/router'
-import type { Middleware, MiddlewareContext } from '@pyreon/server'
-import { createHandler } from '@pyreon/server'
-import type { ApiRouteEntry } from './api-routes'
-import { createApiMiddleware } from './api-routes'
-import { createApp } from './app'
-import type { RouteMiddlewareEntry, ZeroConfig } from './types'
+import type { RouteRecord } from "@pyreon/router"
+import type { Middleware, MiddlewareContext } from "@pyreon/server"
+import { createHandler } from "@pyreon/server"
+import type { ApiRouteEntry } from "./api-routes"
+import { createApiMiddleware } from "./api-routes"
+import { createApp } from "./app"
+import type { RouteMiddlewareEntry, ZeroConfig } from "./types"
 
 // ─── Server entry factory ───────────────────────────────────────────────────
 
@@ -28,15 +28,11 @@ export interface CreateServerOptions {
 /**
  * Create a middleware that dispatches per-route middleware based on URL pattern matching.
  */
-function createRouteMiddlewareDispatcher(
-  entries: RouteMiddlewareEntry[],
-): Middleware {
+function createRouteMiddlewareDispatcher(entries: RouteMiddlewareEntry[]): Middleware {
   return async (ctx: MiddlewareContext) => {
     for (const entry of entries) {
       if (matchPattern(entry.pattern, ctx.path)) {
-        const mw = Array.isArray(entry.middleware)
-          ? entry.middleware
-          : [entry.middleware]
+        const mw = Array.isArray(entry.middleware) ? entry.middleware : [entry.middleware]
         for (const fn of mw) {
           const result = await fn(ctx)
           if (result) return result
@@ -48,14 +44,14 @@ function createRouteMiddlewareDispatcher(
 
 /** Simple URL pattern matcher supporting :param and :param* segments. */
 export function matchPattern(pattern: string, path: string): boolean {
-  const patternParts = pattern.split('/').filter(Boolean)
-  const pathParts = path.split('/').filter(Boolean)
+  const patternParts = pattern.split("/").filter(Boolean)
+  const pathParts = path.split("/").filter(Boolean)
 
   for (let i = 0; i < patternParts.length; i++) {
     const pp = patternParts[i]
     if (!pp) continue
-    if (pp.endsWith('*')) return true // catch-all matches everything after
-    if (pp.startsWith(':')) continue // dynamic segment matches anything
+    if (pp.endsWith("*")) return true // catch-all matches everything after
+    if (pp.startsWith(":")) continue // dynamic segment matches anything
     if (pp !== pathParts[i]) return false
   }
 
@@ -93,14 +89,14 @@ export function createServer(options: CreateServerOptions) {
 
   const { App } = createApp({
     routes: options.routes,
-    routerMode: 'history',
+    routerMode: "history",
   })
 
   return createHandler({
     App,
     routes: options.routes,
     middleware: allMiddleware,
-    mode: config.ssr?.mode ?? 'string',
+    mode: config.ssr?.mode ?? "string",
     ...(options.template ? { template: options.template } : {}),
     ...(options.clientEntry ? { clientEntry: options.clientEntry } : {}),
   })