gorsee 0.2.0 → 0.2.2

package/src/build/ssg.ts

@@ -2,9 +2,9 @@
 // Routes with `export const prerender = true` are rendered to static HTML
 
 import { createRouter } from "../router/scanner.ts"
-import { renderToString, ssrJsx } from "../runtime/server.ts"
 import { createContext } from "../server/middleware.ts"
-import { resetServerHead, getServerHead } from "../runtime/head.ts"
+import { renderPageDocument, resolvePageRoute } from "../server/page-render.ts"
+import { wrapHTML, type HTMLWrapOptions } from "../server/html-shell.ts"
 import { join } from "node:path"
 import { mkdir, writeFile } from "node:fs/promises"
 
@@ -16,7 +16,7 @@ export interface SSGResult {
 interface SSGOptions {
   routesDir: string
   outDir: string
-  wrapHTML: (body: string, opts?: Record<string, unknown>) => string
+  wrapHTML?: (body: string, options?: HTMLWrapOptions) => string
 }
 
 export async function generateStaticPages(options: SSGOptions): Promise<SSGResult> {
@@ -34,54 +34,20 @@ export async function generateStaticPages(options: SSGOptions): Promise<SSGResul
       // Skip routes that don't opt-in to prerendering
       if (!mod.prerender) continue
 
-      const component = mod.default as Function | undefined
-      if (typeof component !== "function") continue
-
-      // Parallel loading: import layout modules + run page loader
       const fakeRequest = new Request(`http://localhost${route.path}`)
       const ctx = createContext(fakeRequest, {})
-      const layoutPaths = route.layoutPaths ?? []
-      const layoutImportPromises = layoutPaths.map((lp) => import(lp))
-      const pageLoaderPromise = typeof mod.loader === "function" ? mod.loader(ctx) : undefined
-
-      const [layoutMods, loaderData] = await Promise.all([
-        Promise.all(layoutImportPromises),
-        pageLoaderPromise,
-      ])
-
-      // Run layout loaders in parallel
-      const layoutLoaderPromises = layoutMods.map((lm) =>
-        typeof lm.loader === "function" ? lm.loader(ctx) : undefined,
-      )
-      const layoutLoaderResults = await Promise.all(layoutLoaderPromises)
-
-      // Nested layout wrapping: outermost first, innermost wraps page
-      let pageComponent: Function = component
-      for (let i = layoutMods.length - 1; i >= 0; i--) {
-        const Layout = layoutMods[i]!.default
-        if (typeof Layout === "function") {
-          const inner = pageComponent
-          const layoutData = layoutLoaderResults[i]
-          pageComponent = (props: Record<string, unknown>) =>
-            Layout({ ...props, data: layoutData, children: inner(props) })
-        }
-      }
-
-      // Render
-      resetServerHead()
-      const pageProps = { params: {}, ctx, data: loaderData }
-      const vnode = ssrJsx(pageComponent as any, pageProps)
-      const body = renderToString(vnode)
-      const headElements = getServerHead()
-
-      // Extract title
-      let title: string | undefined
-      for (const el of headElements) {
-        const m = el.match(/<title>(.+?)<\/title>/)
-        if (m) { title = m[1]; break }
-      }
-
-      const html = wrapHTML(body, { title, loaderData, headElements })
+      const match = { route, params: {} }
+      const resolved = await resolvePageRoute(mod, match, ctx)
+      if (!resolved) continue
+
+      const rendered = renderPageDocument(resolved.pageComponent, ctx, {}, resolved.loaderData)
+      const renderHTML = wrapHTML ?? defaultWrapHTML
+      const html = renderHTML(rendered.html, {
+        title: rendered.title,
+        loaderData: resolved.loaderData,
+        headElements: rendered.headElements,
+        cssFiles: resolved.cssFiles,
+      })
 
       // Write file
       const outPath = route.path === "/"
@@ -98,3 +64,7 @@ export async function generateStaticPages(options: SSGOptions): Promise<SSGResul
 
   return { pages, errors }
 }
+
+function defaultWrapHTML(body: string, options: HTMLWrapOptions = {}): string {
+  return wrapHTML(body, undefined, options)
+}

package/src/cli/bun-plugin.ts

@@ -9,8 +9,10 @@ const FRAMEWORK_ROOT = resolve(import.meta.dir, "..")
 
 const EXPORT_MAP: Record<string, string> = {
   "gorsee": resolve(FRAMEWORK_ROOT, "index.ts"),
+  "gorsee/compat": resolve(FRAMEWORK_ROOT, "index.ts"),
+  "gorsee/client": resolve(FRAMEWORK_ROOT, "client.ts"),
   "gorsee/reactive": resolve(FRAMEWORK_ROOT, "reactive/index.ts"),
-  "gorsee/server": resolve(FRAMEWORK_ROOT, "server/index.ts"),
+  "gorsee/server": resolve(FRAMEWORK_ROOT, "server-entry.ts"),
   "gorsee/types": resolve(FRAMEWORK_ROOT, "types/index.ts"),
   "gorsee/db": resolve(FRAMEWORK_ROOT, "db/index.ts"),
   "gorsee/router": resolve(FRAMEWORK_ROOT, "router/index.ts"),
@@ -20,6 +22,25 @@ const EXPORT_MAP: Record<string, string> = {
   "gorsee/security": resolve(FRAMEWORK_ROOT, "security/index.ts"),
   "gorsee/jsx-runtime": resolve(FRAMEWORK_ROOT, "jsx-runtime.ts"),
   "gorsee/jsx-dev-runtime": resolve(FRAMEWORK_ROOT, "jsx-runtime.ts"),
+  "gorsee/testing": resolve(FRAMEWORK_ROOT, "testing/index.ts"),
+  "gorsee/i18n": resolve(FRAMEWORK_ROOT, "i18n/index.ts"),
+  "gorsee/env": resolve(FRAMEWORK_ROOT, "env/index.ts"),
+  "gorsee/auth": resolve(FRAMEWORK_ROOT, "auth/index.ts"),
+  "gorsee/routes": resolve(FRAMEWORK_ROOT, "runtime/typed-routes.ts"),
+  "gorsee/cli/cmd-create": resolve(FRAMEWORK_ROOT, "cli/cmd-create.ts"),
+  "gorsee/plugins": resolve(FRAMEWORK_ROOT, "plugins/index.ts"),
+  "gorsee/plugins/drizzle": resolve(FRAMEWORK_ROOT, "plugins/drizzle.ts"),
+  "gorsee/plugins/prisma": resolve(FRAMEWORK_ROOT, "plugins/prisma.ts"),
+  "gorsee/plugins/tailwind": resolve(FRAMEWORK_ROOT, "plugins/tailwind.ts"),
+  "gorsee/plugins/lucia": resolve(FRAMEWORK_ROOT, "plugins/lucia.ts"),
+  "gorsee/plugins/s3": resolve(FRAMEWORK_ROOT, "plugins/s3.ts"),
+  "gorsee/plugins/resend": resolve(FRAMEWORK_ROOT, "plugins/resend.ts"),
+  "gorsee/plugins/stripe": resolve(FRAMEWORK_ROOT, "plugins/stripe.ts"),
+  "gorsee/deploy": resolve(FRAMEWORK_ROOT, "deploy/index.ts"),
+}
+
+export function resolveFrameworkImport(specifier: string): string | undefined {
+  return EXPORT_MAP[specifier]
 }
 
 plugin({
@@ -27,7 +48,7 @@ plugin({
   setup(build) {
     // Resolve gorsee/* imports
     build.onResolve({ filter: /^gorsee(\/.*)?$/ }, (args) => {
-      const mapped = EXPORT_MAP[args.path]
+      const mapped = resolveFrameworkImport(args.path)
       if (mapped) {
         return { path: mapped }
       }

package/src/cli/cmd-build.ts

@@ -6,14 +6,10 @@ import { mkdir, rm, writeFile, readdir, stat, watch } from "node:fs/promises"
 import { createRouter } from "../router/scanner.ts"
 import { buildClientBundles } from "../build/client.ts"
 import { generateStaticPages } from "../build/ssg.ts"
+import { createBuildManifest } from "../build/manifest.ts"
 import { createHash } from "node:crypto"
-
-interface BuildManifest {
-  routes: Record<string, { js?: string; hasLoader: boolean; prerendered?: boolean }>
-  chunks: string[]
-  prerendered: string[]
-  buildTime: string
-}
+import { wrapHTML } from "../server/html-shell.ts"
+import { createProjectContext, type RuntimeOptions } from "../runtime/project.ts"
 
 async function hashFile(path: string): Promise<string> {
   const content = await Bun.file(path).arrayBuffer()
@@ -36,30 +32,33 @@ async function getAllFiles(dir: string): Promise<string[]> {
   return files
 }
 
-export async function runBuild(_args: string[]) {
-  if (_args.includes("--watch")) {
-    return runBuildWatch()
-  }
-  const cwd = process.cwd()
+export interface BuildCommandOptions extends RuntimeOptions {
+  minify?: boolean
+  sourcemap?: boolean
+}
+
+export async function buildProject(options: BuildCommandOptions = {}) {
+  const { cwd, paths } = createProjectContext(options)
   const startTime = performance.now()
   console.log("\n  Gorsee Build\n")
 
-  const distDir = join(cwd, "dist")
-  await rm(distDir, { recursive: true, force: true })
-  await mkdir(join(distDir, "client"), { recursive: true })
-  await mkdir(join(distDir, "server"), { recursive: true })
+  await rm(paths.distDir, { recursive: true, force: true })
+  await mkdir(paths.clientDir, { recursive: true })
+  await mkdir(paths.serverDir, { recursive: true })
 
   // 1. Scan routes
-  const routesDir = join(cwd, "routes")
-  const routes = await createRouter(routesDir)
+  const routes = await createRouter(paths.routesDir)
   console.log(`  [1/5] Found ${routes.length} route(s)`)
 
   // 2. Build client bundles (minified)
-  const build = await buildClientBundles(routes, cwd, { minify: true, sourcemap: true })
+  const build = await buildClientBundles(routes, cwd, {
+    minify: options.minify ?? true,
+    sourcemap: options.sourcemap ?? true,
+  })
   console.log(`  [2/5] Client bundles built (${build.entryMap.size} entries)`)
 
   // 3. Hash and copy client files to dist
-  const clientSrc = join(cwd, ".gorsee", "client")
+  const clientSrc = join(paths.gorseeDir, "client")
   const clientFiles = await getAllFiles(clientSrc)
   const hashMap = new Map<string, string>()
 
@@ -68,7 +67,7 @@ export async function runBuild(_args: string[]) {
     const hash = await hashFile(file)
     const ext = rel.lastIndexOf(".")
     const hashed = ext > 0 ? `${rel.slice(0, ext)}.${hash}${rel.slice(ext)}` : `${rel}.${hash}`
-    const dest = join(distDir, "client", hashed)
+    const dest = join(paths.clientDir, hashed)
     await mkdir(join(dest, ".."), { recursive: true })
     await Bun.write(dest, Bun.file(file))
     hashMap.set(rel, hashed)
@@ -76,56 +75,22 @@ export async function runBuild(_args: string[]) {
   console.log(`  [3/5] Assets hashed (${hashMap.size} files)`)
 
   // 4. Generate manifest
-  const manifest: BuildManifest = {
-    routes: {},
-    chunks: [],
-    prerendered: [],
-    buildTime: new Date().toISOString(),
-  }
-
-  for (const route of routes) {
-    const jsRel = build.entryMap.get(route.path)
-    manifest.routes[route.path] = {
-      js: jsRel ? hashMap.get(jsRel) : undefined,
-      hasLoader: false, // will be detected at runtime
-    }
-  }
-
-  for (const [, hashed] of hashMap) {
-    if (hashed.includes("chunk-")) manifest.chunks.push(hashed)
-  }
+  const manifest = await createBuildManifest(routes, build.entryMap, hashMap)
 
-  await writeFile(join(distDir, "manifest.json"), JSON.stringify(manifest, null, 2))
+  await writeFile(join(paths.distDir, "manifest.json"), JSON.stringify(manifest, null, 2))
   console.log(`  [4/5] Manifest generated`)
 
   // 5. Static Site Generation (prerender pages with `export const prerender = true`)
   const ssgResult = await generateStaticPages({
-    routesDir,
-    outDir: join(distDir, "static"),
-    wrapHTML: (body, opts: Record<string, unknown> = {}) => {
-      const title = (opts.title as string) ?? "Gorsee App"
-      const headElements = (opts.headElements as string[]) ?? []
-      return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>${title}</title>
-  <link rel="stylesheet" href="/styles.css" />
-${headElements.join("\n")}
-</head>
-<body>
-  <div id="app">${body}</div>
-</body>
-</html>`
-    },
+    routesDir: paths.routesDir,
+    outDir: join(paths.distDir, "static"),
+    wrapHTML: (body, options = {}) => wrapHTML(body, undefined, options),
   })
-  for (const path of ssgResult.pages.keys()) {
-    manifest.prerendered.push(path)
-    if (manifest.routes[path]) manifest.routes[path]!.prerendered = true
-  }
+  const finalManifest = ssgResult.pages.size > 0
+    ? await createBuildManifest(routes, build.entryMap, hashMap, ssgResult.pages.keys())
+    : manifest
   if (ssgResult.pages.size > 0) {
-    await writeFile(join(distDir, "manifest.json"), JSON.stringify(manifest, null, 2))
+    await writeFile(join(paths.distDir, "manifest.json"), JSON.stringify(finalManifest, null, 2))
   }
   if (ssgResult.errors.length > 0) {
     for (const err of ssgResult.errors) console.error(`  SSG error: ${err}`)
@@ -134,7 +99,7 @@ ${headElements.join("\n")}
 
   // Stats
   let totalSize = 0
-  for (const file of await getAllFiles(join(distDir, "client"))) {
+  for (const file of await getAllFiles(paths.clientDir)) {
     const s = await stat(file)
     totalSize += s.size
   }
@@ -147,13 +112,12 @@ ${headElements.join("\n")}
   console.log()
 }
 
-async function runBuildWatch() {
-  const cwd = process.cwd()
-  const routesDir = join(cwd, "routes")
+export async function watchBuildProject(options: BuildCommandOptions = {}) {
+  const { paths } = createProjectContext(options)
 
   console.log("\n  Gorsee Build --watch\n")
   console.log("  Performing initial build...")
-  await runBuild([])
+  await buildProject(options)
 
   let building = false
   let queued = false
@@ -163,7 +127,7 @@ async function runBuildWatch() {
     building = true
     try {
       const start = performance.now()
-      await runBuild([])
+      await buildProject(options)
       const ms = (performance.now() - start).toFixed(0)
       console.log(`  Rebuilt in ${ms}ms`)
     } catch (err) {
@@ -175,8 +139,15 @@ async function runBuildWatch() {
   }
 
   console.log("  Watching for changes...")
-  const watcher = watch(routesDir, { recursive: true })
+  const watcher = watch(paths.routesDir, { recursive: true })
   for await (const _event of watcher) {
     await rebuild()
   }
 }
+
+export async function runBuild(args: string[], options: BuildCommandOptions = {}) {
+  if (args.includes("--watch")) {
+    return watchBuildProject(options)
+  }
+  return buildProject(options)
+}

package/src/cli/cmd-check.ts

@@ -3,6 +3,7 @@
 import { join, relative } from "node:path"
 import { readdir, stat, readFile } from "node:fs/promises"
 import { createRouter } from "../router/scanner.ts"
+import { createProjectContext, type RuntimeOptions } from "../runtime/project.ts"
 
 interface CheckResult {
   errors: CheckIssue[]
@@ -20,6 +21,8 @@ interface CheckIssue {
 
 const MAX_FILE_LINES = 500
 
+export type { CheckResult, CheckIssue }
+
 async function getAllTsFiles(dir: string): Promise<string[]> {
   const files: string[] = []
   let entries: string[]
@@ -144,31 +147,31 @@ async function checkProjectStructure(cwd: string): Promise<CheckIssue[]> {
   return issues
 }
 
-export async function runCheck(_args: string[]) {
-  const cwd = process.cwd()
-  console.log("\n  Gorsee Check\n")
+export interface CheckCommandOptions extends RuntimeOptions {
+  runTypeScript?: boolean
+}
 
+export async function checkProject(options: CheckCommandOptions = {}): Promise<CheckResult> {
+  const { cwd, paths } = createProjectContext(options)
+  const runTypeScript = options.runTypeScript ?? true
   const result: CheckResult = { errors: [], warnings: [], info: [] }
 
-  // 1. Project structure
   const structIssues = await checkProjectStructure(cwd)
   for (const issue of structIssues) {
     if (issue.code.startsWith("E")) result.errors.push(issue)
     else result.warnings.push(issue)
   }
 
-  // 2. Routes
   try {
-    const routes = await createRouter(join(cwd, "routes"))
+    const routes = await createRouter(paths.routesDir)
     result.info.push(`Found ${routes.length} route(s)`)
   } catch {
     result.info.push("Could not scan routes")
   }
 
-  // 3. File checks
-  const files = await getAllTsFiles(join(cwd, "routes"))
-  files.push(...(await getAllTsFiles(join(cwd, "shared"))))
-  files.push(...(await getAllTsFiles(join(cwd, "middleware"))))
+  const files = await getAllTsFiles(paths.routesDir)
+  files.push(...(await getAllTsFiles(paths.sharedDir)))
+  files.push(...(await getAllTsFiles(paths.middlewareDir)))
 
   for (const file of files) {
     const sizeIssues = await checkFileSize(file, cwd)
@@ -179,24 +182,35 @@ export async function runCheck(_args: string[]) {
     }
   }
 
-  // 4. TypeScript check
-  console.log("  Running TypeScript check...")
-  const tsc = Bun.spawn(["bun", "x", "tsc", "--noEmit"], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-  const tscExit = await tsc.exited
-  if (tscExit !== 0) {
-    const stderr = await new Response(tsc.stderr).text()
-    result.errors.push({
-      code: "TSC",
-      file: ".",
-      message: `TypeScript errors:\n${stderr.trim()}`,
+  if (runTypeScript) {
+    const tsc = Bun.spawn(["bun", "x", "tsc", "--noEmit"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe",
     })
-  } else {
-    result.info.push("TypeScript: no errors")
+    const tscExit = await tsc.exited
+    if (tscExit !== 0) {
+      const stderr = await new Response(tsc.stderr).text()
+      result.errors.push({
+        code: "TSC",
+        file: ".",
+        message: `TypeScript errors:\n${stderr.trim()}`,
+      })
+    } else {
+      result.info.push("TypeScript: no errors")
+    }
+  }
+
+  return result
+}
+
+/** @deprecated Use checkProject() for programmatic access. */
+export async function runCheck(_args: string[], options: CheckCommandOptions = {}) {
+  console.log("\n  Gorsee Check\n")
+  if (options.runTypeScript ?? true) {
+    console.log("  Running TypeScript check...")
   }
+  const result = await checkProject(options)
 
   // Report
   for (const info of result.info) {

package/src/cli/cmd-create.ts

@@ -3,6 +3,7 @@
 import { mkdir, writeFile } from "node:fs/promises"
 import { join } from "node:path"
 import { generateFrameworkMD } from "./framework-md.ts"
+import { createProjectContext, type RuntimeOptions } from "../runtime/project.ts"
 
 const DIRS = [
   "routes",
@@ -13,7 +14,7 @@ const DIRS = [
   "public",
 ]
 
-const INDEX_ROUTE = `import { createSignal, Head, Link } from "gorsee"
+const INDEX_ROUTE = `import { createSignal, Head, Link } from "gorsee/client"
 
 export default function HomePage() {
   const [count, setCount] = createSignal(0)
@@ -37,7 +38,7 @@ export default function HomePage() {
 }
 `
 
-const ABOUT_ROUTE = `import { Head, Link } from "gorsee"
+const ABOUT_ROUTE = `import { Head, Link } from "gorsee/client"
 
 export default function AboutPage() {
   return (
@@ -81,7 +82,7 @@ const ERROR_PAGE = `export default function ErrorPage(props: { error: Error }) {
 }
 `
 
-const NOT_FOUND_PAGE = `import { Head, Link } from "gorsee"
+const NOT_FOUND_PAGE = `import { Head, Link } from "gorsee/client"
 
 export default function NotFoundPage() {
   return (
@@ -211,6 +212,12 @@ Open [http://localhost:3000](http://localhost:3000).
 | \`bunx gorsee typegen\` | Generate typed routes |
 | \`bunx gorsee migrate\` | Run DB migrations |
 
+## Import Boundaries
+
+- Use \`gorsee/client\` for route components, islands, links, forms, and reactive primitives.
+- Use \`gorsee/server\` for loaders, middleware, auth, db, cache, RPC, security, env, and logging.
+- Do not use root \`gorsee\` in new code. It exists only as a compatibility entrypoint.
+
 ## Project Structure
 
 \`\`\`
@@ -233,14 +240,17 @@ See \`FRAMEWORK.md\` for the full API reference (AI-friendly).
 `
 }
 
-export async function runCreate(args: string[]) {
+export interface CreateCommandOptions extends RuntimeOptions {}
+
+export async function createProject(args: string[], options: CreateCommandOptions = {}) {
   const name = args[0]
   if (!name) {
     console.error("Usage: gorsee create <project-name>")
     process.exit(1)
   }
 
-  const dir = join(process.cwd(), name)
+  const { cwd } = createProjectContext(options)
+  const dir = join(cwd, name)
   console.log(`\n  Creating ${name}...\n`)
 
   await mkdir(dir, { recursive: true })
@@ -311,3 +321,8 @@ export async function runCreate(args: string[]) {
   console.log("  Then open http://localhost:3000")
   console.log()
 }
+
+/** @deprecated Use createProject() for programmatic access. */
+export async function runCreate(args: string[], options: CreateCommandOptions = {}) {
+  return createProject(args, options)
+}

package/src/cli/cmd-deploy.ts

@@ -2,6 +2,7 @@
 
 import { writeFile, access, mkdir } from "node:fs/promises"
 import { join } from "node:path"
+import { createProjectContext, type RuntimeOptions } from "../runtime/project.ts"
 
 type Target = "vercel" | "fly" | "cloudflare" | "netlify" | "docker"
 
@@ -90,8 +91,10 @@ async function deployDocker(cwd: string): Promise<void> {
   console.log("    2. Run: docker run -p 3000:3000 gorsee-app")
 }
 
-export async function runDeploy(args: string[]): Promise<void> {
-  const cwd = process.cwd()
+export interface DeployCommandOptions extends RuntimeOptions {}
+
+export async function generateDeployConfig(args: string[], options: DeployCommandOptions = {}): Promise<void> {
+  const { cwd } = createProjectContext(options)
   const initOnly = args.includes("--init")
   const targetArg = args.find((a) => !a.startsWith("-")) as Target | undefined
 
@@ -139,3 +142,8 @@ export async function runDeploy(args: string[]): Promise<void> {
 
   console.log()
 }
+
+/** @deprecated Use generateDeployConfig() for programmatic access. */
+export async function runDeploy(args: string[], options: DeployCommandOptions = {}): Promise<void> {
+  return generateDeployConfig(args, options)
+}

package/src/cli/cmd-dev.ts

@@ -1,13 +1,13 @@
 // gorsee dev -- start dev server
 
-import { join } from "node:path"
+import { createProjectContext, type RuntimeOptions } from "../runtime/project.ts"
 
-export async function runDev(_args: string[]) {
-  const devPath = join(import.meta.dir, "../dev.ts")
-  const proc = Bun.spawn(["bun", "run", devPath], {
-    cwd: process.cwd(),
-    stdio: ["inherit", "inherit", "inherit"],
-    env: { ...process.env },
-  })
-  await proc.exited
+export interface DevCommandOptions extends RuntimeOptions {
+  port?: number
+}
+
+export async function runDev(_args: string[], options: DevCommandOptions = {}) {
+  const { cwd } = createProjectContext(options)
+  const { startDevServer } = await import("../dev.ts")
+  await startDevServer({ cwd, port: options.port })
 }