gorsee 0.2.4 → 0.2.5

package/src/dev/request-handler.ts

@@ -1,127 +0,0 @@
-// Page route request handler — SSR + streaming + layouts + loaders
-
-import { createContext } from "../server/middleware.ts"
-import { renderToString, ssrJsx } from "../runtime/server.ts"
-import { renderToStream, streamJsx } from "../runtime/stream.ts"
-import { resetServerHead, getServerHead } from "../runtime/head.ts"
-import { handleAction } from "../server/action.ts"
-import { log } from "../log/index.ts"
-import { createClientScriptPath, renderPageDocument, resolvePageRoute } from "../server/page-render.ts"
-import { handleRouteRequest } from "../server/route-request.ts"
-import type { MatchResult } from "../router/matcher.ts"
-import type { BuildResult } from "../build/client.ts"
-
-interface RenderOptions {
-  match: MatchResult
-  request: Request
-  nonce: string
-  start: number
-  clientBuild: BuildResult
-  secHeaders: Record<string, string>
-  wrapHTML: (body: string, nonce: string, opts?: { title?: string; clientScript?: string; loaderData?: unknown; params?: Record<string, string>; cssFiles?: string[]; headElements?: string[] }) => string
-}
-
-async function renderPageRoute(mod: Record<string, unknown>, opts: RenderOptions): Promise<Response> {
-  const { match, request, nonce, start, clientBuild, secHeaders, wrapHTML } = opts
-  const ctx = createContext(request, match.params)
-
-  // API route
-  if (typeof mod.GET === "function" && request.method === "GET") return (mod.GET as Function)(ctx)
-  if (typeof mod.POST === "function" && request.method === "POST") return (mod.POST as Function)(ctx)
-
-  // Server Action (POST with action export)
-  if (request.method === "POST" && typeof mod.action === "function") {
-    const result = await handleAction(mod.action as (ctx: import("../server/middleware.ts").Context) => Promise<unknown>, ctx)
-    if (request.headers.get("Accept")?.includes("application/json")) {
-      return new Response(JSON.stringify(result), {
-        status: result.status,
-        headers: { "Content-Type": "application/json" },
-      })
-    }
-    // Progressive enhancement: redirect back to the page after action
-    return new Response(null, {
-      status: 303,
-      headers: { Location: request.url },
-    })
-  }
-
-  const component = mod.default as Function | undefined
-  if (typeof component !== "function") {
-    return new Response("Route has no default export", { status: 500 })
-  }
-
-  const resolved = await resolvePageRoute(mod, match, ctx)
-  if (!resolved) {
-    return new Response("Route has no default export", { status: 500 })
-  }
-
-  const { pageComponent, loaderData, cssFiles, renderMode } = resolved
-  const pageProps = { params: match.params, ctx, data: loaderData }
-  const clientScript = createClientScriptPath(clientBuild.entryMap.get(match.route.path))
-  const htmlOpts = { clientScript, loaderData, params: match.params, cssFiles }
-
-  if (renderMode === "stream") {
-    resetServerHead()
-    const vnode = streamJsx(pageComponent as any, pageProps)
-    const stream = renderToStream(vnode, {
-      shell: (body: string) => wrapHTML(body, nonce, {
-        ...htmlOpts,
-        headElements: getServerHead(),
-      }),
-    })
-    const elapsed = (performance.now() - start).toFixed(1)
-    log.info("request", { method: request.method, path: match.route.path, status: 200, ms: elapsed, mode: "stream" })
-    return new Response(stream, {
-      headers: { "Content-Type": "text/html", ...secHeaders },
-    })
-  }
-
-  // Default: async SSR
-  const rendered = renderPageDocument(pageComponent, ctx, match.params, loaderData)
-  const html = wrapHTML(rendered.html, nonce, {
-    ...htmlOpts,
-    headElements: rendered.headElements,
-  })
-  const elapsed = (performance.now() - start).toFixed(1)
-  log.info("request", { method: request.method, path: match.route.path, status: 200, ms: elapsed })
-
-  return new Response(html, {
-    headers: { "Content-Type": "text/html", ...secHeaders },
-  })
-}
-
-export async function handlePageRequest(opts: RenderOptions): Promise<Response> {
-  const { match, request } = opts
-  return handleRouteRequest({
-    match,
-    request,
-    onPartialRequest: async () => {
-      const { handlePartialNavigation } = await import("./partial-handler.ts")
-      return handlePartialNavigation({ match, request, clientBuild: opts.clientBuild })
-    },
-    onPageRequest: async ({ mod }) => renderPageRoute(mod, opts),
-    onRouteError: async (err) => {
-      if (match.route.errorPath) {
-        const errObj = err instanceof Error ? err : new Error(String(err))
-        return renderErrorBoundary(match.route.errorPath, errObj, opts)
-      }
-      throw err
-    },
-  })
-}
-
-async function renderErrorBoundary(errorPath: string, error: Error, opts: RenderOptions): Promise<Response> {
-  const { nonce, secHeaders, wrapHTML, match } = opts
-  const errorMod = await import(errorPath)
-  const ErrorComponent = errorMod.default
-  if (typeof ErrorComponent !== "function") throw error
-
-  const vnode = ssrJsx(ErrorComponent as any, { error, params: match.params })
-  const body = renderToString(vnode)
-  const html = wrapHTML(body, nonce, { title: "Error" })
-
-  return new Response(html, {
-    status: 500,
-    headers: { "Content-Type": "text/html", ...secHeaders },
-  })
-}

package/src/dev/watcher.ts

@@ -1,48 +0,0 @@
-// File watcher for dev mode -- triggers rebuild on changes
-
-import { watch, type FSWatcher } from "node:fs"
-import { join } from "node:path"
-import { log } from "../log/index.ts"
-
-export interface WatcherOptions {
-  dirs: string[]
-  onChange: (path: string) => void
-  debounceMs?: number
-}
-
-export function startWatcher(options: WatcherOptions): () => void {
-  const { dirs, onChange, debounceMs = 100 } = options
-  const watchers: FSWatcher[] = []
-  let timer: ReturnType<typeof setTimeout> | null = null
-  let pendingPath = ""
-
-  function handle(filename: string | null, dir: string) {
-    if (!filename) return
-    if (!filename.match(/\.(tsx?|jsx?|css)$/)) return
-
-    pendingPath = join(dir, filename)
-
-    if (timer) clearTimeout(timer)
-    timer = setTimeout(() => {
-      log.info("file changed", { file: pendingPath })
-      onChange(pendingPath)
-      timer = null
-    }, debounceMs)
-  }
-
-  for (const dir of dirs) {
-    try {
-      const w = watch(dir, { recursive: true }, (_event, filename) => {
-        handle(filename as string | null, dir)
-      })
-      watchers.push(w)
-    } catch {
-      // directory may not exist
-    }
-  }
-
-  return () => {
-    for (const w of watchers) w.close()
-    if (timer) clearTimeout(timer)
-  }
-}

package/src/dev.ts

@@ -1,208 +0,0 @@
-// Gorsee.js Dev Server
-// Orchestrator: routing + security + HMR + static serving
-
-import { createRouter, matchRoute, buildStaticMap } from "./router/index.ts"
-import { __resetRPCState } from "./server/rpc.ts"
-import { securityHeaders } from "./security/headers.ts"
-import { createRateLimiter } from "./security/rate-limit.ts"
-import { EVENT_REPLAY_SCRIPT } from "./runtime/event-replay.ts"
-import { log, setLogLevel } from "./log/index.ts"
-import { buildClientBundles, type BuildResult } from "./build/client.ts"
-import { HMR_CLIENT_SCRIPT, addHMRClient, removeHMRClient, notifyReload } from "./dev/hmr.ts"
-import { startWatcher } from "./dev/watcher.ts"
-import { renderErrorOverlay } from "./dev/error-overlay.ts"
-import { handlePageRequest } from "./dev/request-handler.ts"
-import { handlePartialNavigation } from "./dev/partial-handler.ts"
-import { loadEnv } from "./env/index.ts"
-import { generateNonce, wrapHTML } from "./server/html-shell.ts"
-import { renderNotFoundPage } from "./server/not-found.ts"
-import { createRateLimitResponse, handleRPCWithHeaders } from "./server/request-preflight.ts"
-import { servePrefixedStaticFile, serveStaticFile } from "./server/static-file.ts"
-import { join } from "node:path"
-import type { Route } from "./router/index.ts"
-import { createProjectContext, resolveRuntimeEnv, type RuntimeOptions } from "./runtime/project.ts"
-
-interface StartDevServerOptions extends RuntimeOptions {
-  port?: number
-}
-
-interface DevRuntimeState {
-  cwd: string
-  routesDir: string
-  publicDir: string
-  clientDir: string
-  rateLimiter: ReturnType<typeof createRateLimiter>
-  routes: Route[]
-  staticMap: Map<string, Route>
-  clientBuild: BuildResult
-}
-
-// --- Static file serving ---
-
-async function tryServeStatic(publicDir: string, pathname: string): Promise<Response | null> {
-  if (pathname === "/") return null
-  return serveStaticFile(publicDir, pathname.slice(1))
-}
-
-async function tryServeClientBundle(clientDir: string, pathname: string): Promise<Response | null> {
-  return servePrefixedStaticFile(pathname, "/_gorsee/", clientDir, {
-    contentType: "application/javascript",
-  })
-}
-
-// --- 404 page ---
-
-async function render404Page(routesDir: string, nonce: string): Promise<string> {
-  return renderNotFoundPage(routesDir, nonce, {
-    bodyPrefix: [EVENT_REPLAY_SCRIPT.replace("<script", `<script nonce="${nonce}"`)],
-    bodySuffix: [HMR_CLIENT_SCRIPT.replace("<script", `<script nonce="${nonce}"`)],
-  })
-}
-
-// --- Build & watch ---
-
-async function createDevRuntimeState(cwd: string): Promise<DevRuntimeState> {
-  const { paths } = createProjectContext({ cwd })
-  return {
-    cwd,
-    routesDir: paths.routesDir,
-    publicDir: paths.publicDir,
-    clientDir: join(paths.gorseeDir, "client"),
-    rateLimiter: createRateLimiter(200, "1m"),
-    routes: [],
-    staticMap: new Map(),
-    clientBuild: { entryMap: new Map() },
-  }
-}
-
-async function rebuildClient(state: DevRuntimeState, buildState: { inProgress: boolean, queued: boolean }) {
-  if (buildState.inProgress) {
-    buildState.queued = true
-    return
-  }
-  buildState.inProgress = true
-  try {
-    __resetRPCState()
-    state.routes = await createRouter(state.routesDir)
-    state.staticMap = buildStaticMap(state.routes)
-    state.clientBuild = await buildClientBundles(state.routes, state.cwd)
-    log.info("client build complete", { routes: state.clientBuild.entryMap.size })
-  } catch (err) {
-    log.error("client build failed", { error: String(err) })
-  } finally {
-    buildState.inProgress = false
-    if (buildState.queued) {
-      buildState.queued = false
-      await rebuildClient(state, buildState)
-    }
-  }
-}
-
-// --- Server ---
-
-export async function startDevServer(options: StartDevServerOptions = {}) {
-  const runtime = createProjectContext(options)
-  const cwd = runtime.cwd
-  const state = await createDevRuntimeState(cwd)
-  const buildState = { inProgress: false, queued: false }
-
-  await loadEnv(cwd)
-  const envConfig = resolveRuntimeEnv(process.env)
-  const port = options.port ?? envConfig.port
-  setLogLevel(envConfig.logLevel)
-  log.info("scanning routes", { dir: state.routesDir })
-
-  state.routes = await createRouter(state.routesDir)
-  state.staticMap = buildStaticMap(state.routes)
-  for (const route of state.routes) {
-    log.info("route registered", { path: route.path, file: route.filePath })
-  }
-
-  await rebuildClient(state, buildState)
-
-  startWatcher({
-    dirs: [state.routesDir, runtime.paths.sharedDir, runtime.paths.middlewareDir],
-    onChange: async () => {
-      await rebuildClient(state, buildState)
-      notifyReload()
-    },
-  })
-
-  const server = Bun.serve({
-    port,
-    async fetch(request, server) {
-      const url = new URL(request.url)
-      const pathname = url.pathname
-
-      // WebSocket upgrade for HMR
-      if (pathname === "/__gorsee_hmr") {
-        if (server.upgrade(request)) return new Response(null, { status: 101 })
-        return new Response("WebSocket upgrade failed", { status: 400 })
-      }
-
-      // Rate limiting by IP
-      const ip = server.requestIP(request)?.address ?? "unknown"
-      const rateLimitResponse = createRateLimitResponse(state.rateLimiter, ip)
-      if (rateLimitResponse) return rateLimitResponse
-
-      const start = performance.now()
-      const nonce = generateNonce()
-      const secHeaders = securityHeaders({}, nonce)
-
-      // 1. RPC
-      const rpcResponse = await handleRPCWithHeaders(request, secHeaders)
-      if (rpcResponse) return rpcResponse
-
-      // 2. Client bundles
-      const bundleResponse = await tryServeClientBundle(state.clientDir, pathname)
-      if (bundleResponse) return bundleResponse
-
-      // 3. Static files
-      const staticResponse = await tryServeStatic(state.publicDir, pathname)
-      if (staticResponse) return staticResponse
-
-      // 4. Route matching
-      const match = matchRoute(state.routes, pathname, state.staticMap)
-      if (!match) {
-        const notFoundHtml = await render404Page(state.routesDir, nonce)
-        return new Response(notFoundHtml, {
-          status: 404,
-          headers: { "Content-Type": "text/html", ...secHeaders },
-        })
-      }
-
-      try {
-        // Partial navigation (SPA client-side routing)
-        if (request.headers.get("X-Gorsee-Navigate") === "partial") {
-          return await handlePartialNavigation({ match, request, clientBuild: state.clientBuild })
-        }
-
-        return await handlePageRequest({
-          match, request, nonce, start, clientBuild: state.clientBuild, secHeaders, wrapHTML,
-        })
-      } catch (err) {
-        const errObj = err instanceof Error ? err : new Error(String(err))
-        log.error("request error", { path: pathname, error: errObj.message })
-        return new Response(renderErrorOverlay(errObj, nonce), {
-          status: 500,
-          headers: { "Content-Type": "text/html", ...secHeaders },
-        })
-      }
-    },
-    websocket: {
-      open(ws) { addHMRClient(ws) },
-      close(ws) { removeHMRClient(ws) },
-      message() {},
-    },
-  })
-
-  log.info("dev server started", { url: `http://localhost:${server.port}` })
-  return server
-}
-
-if (import.meta.main) {
-  startDevServer().catch((err) => {
-    console.error("Failed to start dev server:", err)
-    process.exit(1)
-  })
-}

package/src/env/index.ts

@@ -1,74 +0,0 @@
-// Environment variable loading from .env files
-// Priority: .env.local > .env.{NODE_ENV} > .env
-// Only PUBLIC_ prefixed vars are exposed to client bundles
-
-import { readFile } from "node:fs/promises"
-import { join } from "node:path"
-
-function parseEnvFile(content: string): Record<string, string> {
-  const result: Record<string, string> = {}
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim()
-    if (!trimmed || trimmed.startsWith("#")) continue
-    const eqIndex = trimmed.indexOf("=")
-    if (eqIndex < 0) continue
-    const key = trimmed.slice(0, eqIndex).trim()
-    let value = trimmed.slice(eqIndex + 1).trim()
-    // Remove quotes
-    if ((value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))) {
-      value = value.slice(1, -1)
-    }
-    result[key] = value
-  }
-  return result
-}
-
-async function loadFile(path: string): Promise<Record<string, string>> {
-  try {
-    const content = await readFile(path, "utf-8")
-    return parseEnvFile(content)
-  } catch {
-    return {}
-  }
-}
-
-export async function loadEnv(cwd: string): Promise<void> {
-  const mode = process.env.NODE_ENV ?? "development"
-
-  // Load in priority order (lower priority first, higher overwrites)
-  const files = [
-    join(cwd, ".env"),
-    join(cwd, `.env.${mode}`),
-    join(cwd, ".env.local"),
-  ]
-
-  for (const file of files) {
-    const vars = await loadFile(file)
-    for (const [key, value] of Object.entries(vars)) {
-      // Don't overwrite existing env vars (process env takes precedence)
-      if (process.env[key] === undefined) {
-        process.env[key] = value
-      }
-    }
-  }
-}
-
-export function getPublicEnv(): Record<string, string> {
-  const result: Record<string, string> = {}
-  for (const [key, value] of Object.entries(process.env)) {
-    if (key.startsWith("PUBLIC_") && value !== undefined) {
-      result[key] = value
-    }
-  }
-  return result
-}
-
-export function env(key: string, defaultValue?: string): string {
-  const value = process.env[key]
-  if (value === undefined) {
-    if (defaultValue !== undefined) return defaultValue
-    throw new Error(`[GORSEE] Missing required environment variable: ${key}`)
-  }
-  return value
-}

package/src/errors/formatter.ts

@@ -1,63 +0,0 @@
-import { ERROR_CATALOG, type ErrorCode } from "./catalog.ts"
-
-export class GorseeError extends Error {
-  readonly code: ErrorCode
-  readonly filePath?: string
-  readonly line?: number
-
-  constructor(code: ErrorCode, details?: { filePath?: string; line?: number; extra?: string }) {
-    const entry = ERROR_CATALOG[code]
-    const title = entry?.title ?? "Unknown error"
-    super(`[GORSEE ${code}] ${title}${details?.extra ? `: ${details.extra}` : ""}`)
-
-    this.code = code
-    this.filePath = details?.filePath
-    this.line = details?.line
-  }
-}
-
-export interface FormattedError {
-  human: string
-  json: {
-    code: ErrorCode
-    title: string
-    file?: string
-    line?: number
-    fix: string
-  }
-}
-
-export function formatError(err: GorseeError): FormattedError {
-  const entry = ERROR_CATALOG[err.code]
-
-  const location = err.filePath
-    ? `\n  ${err.filePath}${err.line ? `:${err.line}` : ""}`
-    : ""
-
-  const human = [
-    `GORSEE ${err.code}: ${entry?.title ?? "Unknown"}`,
-    location,
-    `\n  What: ${entry?.description ?? err.message}`,
-    `  Fix: ${entry?.fix ?? "See documentation"}`,
-    `\n  AI context (copy entire block):`,
-    `  +${"─".repeat(45)}`,
-    `  | Framework: Gorsee.js`,
-    `  | Error: ${err.code} - ${entry?.title}`,
-    err.filePath ? `  | File: ${err.filePath}${err.line ? `:${err.line}` : ""}` : null,
-    `  | Fix: ${entry?.fix}`,
-    `  +${"─".repeat(45)}`,
-  ]
-    .filter(Boolean)
-    .join("\n")
-
-  return {
-    human,
-    json: {
-      code: err.code,
-      title: entry?.title ?? "Unknown",
-      file: err.filePath,
-      line: err.line,
-      fix: entry?.fix ?? "See documentation",
-    },
-  }
-}

package/src/errors/index.ts

@@ -1,2 +0,0 @@
-export { GorseeError, formatError } from "./formatter.ts"
-export { ERROR_CATALOG, type ErrorCode } from "./catalog.ts"

package/src/i18n/index.ts

@@ -1,72 +0,0 @@
-// Basic i18n support
-// Dictionary-based translations with locale detection
-
-import { createSignal, type SignalGetter } from "../reactive/signal.ts"
-
-type Translations = Record<string, string | Record<string, string>>
-type LocaleDict = Record<string, Translations>
-
-let dictionaries: LocaleDict = {}
-let defaultLocale = "en"
-
-const [currentLocale, setCurrentLocale] = createSignal(defaultLocale)
-
-export function setupI18n(config: {
-  locales: LocaleDict
-  defaultLocale?: string
-  detectLocale?: boolean
-}): void {
-  dictionaries = config.locales
-  defaultLocale = config.defaultLocale ?? "en"
-
-  if (config.detectLocale && typeof navigator !== "undefined") {
-    const browserLang = navigator.language.split("-")[0] ?? defaultLocale
-    if (dictionaries[browserLang]) {
-      setCurrentLocale(browserLang)
-      return
-    }
-  }
-
-  setCurrentLocale(defaultLocale)
-}
-
-export function getLocale(): SignalGetter<string> {
-  return currentLocale
-}
-
-export function setLocale(locale: string): void {
-  if (!dictionaries[locale]) {
-    console.warn(`[gorsee/i18n] Locale "${locale}" not found, available: ${Object.keys(dictionaries).join(", ")}`)
-    return
-  }
-  setCurrentLocale(locale)
-}
-
-export function t(key: string, params?: Record<string, string | number>): string {
-  const locale = currentLocale()
-  const dict = dictionaries[locale] ?? dictionaries[defaultLocale] ?? {}
-
-  // Support nested keys: "nav.home"
-  const parts = key.split(".")
-  let value: unknown = dict
-  for (const part of parts) {
-    if (typeof value !== "object" || value === null) { value = undefined; break }
-    value = (value as Record<string, unknown>)[part]
-  }
-
-  if (typeof value !== "string") return key
-
-  // Replace {{param}} placeholders
-  if (params) {
-    return value.replace(/\{\{(\w+)\}\}/g, (_, name) => {
-      return params[name] !== undefined ? String(params[name]) : `{{${name}}}`
-    })
-  }
-
-  return value
-}
-
-export function plural(key: string, count: number, params?: Record<string, string | number>): string {
-  const suffix = count === 1 ? "one" : "other"
-  return t(`${key}.${suffix}`, { count, ...params })
-}

package/src/index-client.ts

@@ -1,4 +0,0 @@
-// Browser-safe root entry used by client bundling.
-// Mirrors the explicit public `gorsee/client` entrypoint.
-
-export * from "./client.ts"

package/src/index.ts

@@ -1,43 +0,0 @@
-// Gorsee.js -- compatibility entry point.
-// Prefer "gorsee/client" for browser-safe APIs, "gorsee/server" for server-only APIs,
-// or "gorsee/compat" when you need an explicit legacy migration path.
-
-/** @deprecated Import from "gorsee/client" instead. */
-export {
-  createSignal,
-  createComputed,
-  createEffect,
-  createResource,
-  createStore,
-  createLive,
-  invalidateResource,
-  invalidateAll,
-  createMutation,
-} from "./reactive/index.ts"
-
-/** @deprecated Import from "gorsee/client" instead. */
-export { Suspense } from "./runtime/suspense.ts"
-/** @deprecated Import from "gorsee/client" instead. */
-export { Link } from "./runtime/link.ts"
-/** @deprecated Import from "gorsee/client" instead. */
-export { Head } from "./runtime/head.ts"
-/** @deprecated Import from "gorsee/client" instead. */
-export { navigate, onNavigate, beforeNavigate, getCurrentPath } from "./runtime/router.ts"
-/** @deprecated Import from "gorsee/client" instead. */
-export { useFormAction } from "./runtime/form.ts"
-/** @deprecated Import from "gorsee/client" instead. */
-export { Image } from "./runtime/image.ts"
-/** @deprecated Import from "gorsee/client" instead. */
-export { ErrorBoundary } from "./runtime/error-boundary.ts"
-/** @deprecated Import from "gorsee/client" instead. */
-export { island } from "./runtime/island.ts"
-/** @deprecated Import from "gorsee/client" instead. */
-export { createEventSource } from "./server/sse.ts"
-/** @deprecated Import from "gorsee/server" instead. */
-export { createAuth } from "./auth/index.ts"
-/** @deprecated Import from "gorsee/client" instead. */
-export { typedLink, typedNavigate } from "./runtime/typed-routes.ts"
-/** @deprecated Import from "gorsee/client" instead. */
-export { defineForm, validateForm, fieldAttrs } from "./runtime/validated-form.ts"
-/** @deprecated Import from "gorsee/server" instead. */
-export { definePlugin, createPluginRunner, type GorseePlugin, type PluginContext } from "./plugins/index.ts"

package/src/jsx-runtime-client.ts

@@ -1,13 +0,0 @@
-// Client-side JSX runtime -- creates real DOM nodes with reactive bindings
-// Used by client bundles (browser target)
-
-export { jsx, jsxs, jsxDEV, Fragment } from "./runtime/jsx-runtime.ts"
-
-export namespace JSX {
-  export type Element = Node | DocumentFragment
-  export type IntrinsicElements = import("./jsx-types-html.ts").GorseeIntrinsicElements
-
-  export interface ElementChildrenAttribute {
-    children: unknown
-  }
-}

package/src/jsx-runtime.ts

@@ -1,20 +0,0 @@
-// JSX automatic runtime entry point
-// jsxImportSource: "gorsee" resolves to gorsee/jsx-runtime
-// In dev/SSR mode this uses ssrJsx; client build would swap to DOM jsx
-
-import { ssrJsx, ssrJsxs } from "./runtime/server.ts"
-import { Fragment } from "./runtime/jsx-runtime.ts"
-
-export { Fragment }
-export const jsx = ssrJsx
-export const jsxs = ssrJsxs
-export const jsxDEV = ssrJsx
-
-export namespace JSX {
-  export type Element = import("./runtime/server.ts").VNode | Node | DocumentFragment
-  export type IntrinsicElements = import("./jsx-types-html.ts").GorseeIntrinsicElements
-
-  export interface ElementChildrenAttribute {
-    children: unknown
-  }
-}