gorsee 0.1.3 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gorsee",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Full-stack TypeScript framework — islands, reactive WebSocket, optimistic mutations, built-in auth, type-safe routes",
   "type": "module",
   "license": "MIT",
@@ -42,7 +42,16 @@
     "./env": "./src/env/index.ts",
     "./auth": "./src/auth/index.ts",
     "./routes": "./src/runtime/typed-routes.ts",
-    "./cli/cmd-create": "./src/cli/cmd-create.ts"
+    "./cli/cmd-create": "./src/cli/cmd-create.ts",
+    "./plugins": "./src/plugins/index.ts",
+    "./plugins/drizzle": "./src/plugins/drizzle.ts",
+    "./plugins/prisma": "./src/plugins/prisma.ts",
+    "./plugins/tailwind": "./src/plugins/tailwind.ts",
+    "./plugins/lucia": "./src/plugins/lucia.ts",
+    "./plugins/s3": "./src/plugins/s3.ts",
+    "./plugins/resend": "./src/plugins/resend.ts",
+    "./plugins/stripe": "./src/plugins/stripe.ts",
+    "./deploy": "./src/deploy/index.ts"
   },
   "files": [
     "src/",

package/src/cli/cmd-deploy.ts

@@ -0,0 +1,141 @@
+// Gorsee.js — CLI deploy command
+
+import { writeFile, access, mkdir } from "node:fs/promises"
+import { join } from "node:path"
+
+type Target = "vercel" | "fly" | "cloudflare" | "netlify" | "docker"
+
+const TARGETS: Target[] = ["vercel", "fly", "cloudflare", "netlify", "docker"]
+
+const DETECT_FILES: Record<string, Target> = {
+  "vercel.json": "vercel",
+  "fly.toml": "fly",
+  "wrangler.toml": "cloudflare",
+  "netlify.toml": "netlify",
+  "Dockerfile": "docker",
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function detectTarget(cwd: string): Promise<Target | null> {
+  for (const [file, target] of Object.entries(DETECT_FILES)) {
+    if (await fileExists(join(cwd, file))) return target
+  }
+  return null
+}
+
+async function writeAndLog(filePath: string, content: string): Promise<void> {
+  await writeFile(filePath, content, "utf-8")
+  console.log(`  created ${filePath}`)
+}
+
+async function deployVercel(cwd: string): Promise<void> {
+  const { generateVercelConfig, generateVercelServerlessEntry } = await import("../deploy/vercel.ts")
+  await writeAndLog(join(cwd, "vercel.json"), JSON.stringify(generateVercelConfig(), null, 2))
+  await mkdir(join(cwd, "api"), { recursive: true })
+  await writeAndLog(join(cwd, "api/index.ts"), generateVercelServerlessEntry())
+  console.log("\n  Next steps:")
+  console.log("    1. Install Vercel CLI: npm i -g vercel")
+  console.log("    2. Run: vercel")
+  console.log("    3. Follow prompts to link your project")
+}
+
+async function deployFly(cwd: string, appName: string): Promise<void> {
+  const { generateFlyConfig, generateFlyDockerfile } = await import("../deploy/fly.ts")
+  await writeAndLog(join(cwd, "fly.toml"), generateFlyConfig(appName))
+  await writeAndLog(join(cwd, "Dockerfile"), generateFlyDockerfile())
+  console.log("\n  Next steps:")
+  console.log("    1. Install Fly CLI: curl -L https://fly.io/install.sh | sh")
+  console.log(`    2. Run: fly launch --name ${appName}`)
+  console.log("    3. Deploy: fly deploy")
+}
+
+async function deployCloudflare(cwd: string, name: string): Promise<void> {
+  const { generateWranglerConfig, generateCloudflareEntry, generateCloudflareStaticAssets } =
+    await import("../deploy/cloudflare.ts")
+  await writeAndLog(join(cwd, "wrangler.toml"), generateWranglerConfig(name))
+  await writeAndLog(join(cwd, "worker.ts"), generateCloudflareEntry())
+  await writeAndLog(join(cwd, "_routes.json"), JSON.stringify(generateCloudflareStaticAssets(), null, 2))
+  console.log("\n  Next steps:")
+  console.log("    1. Install Wrangler: npm i -g wrangler")
+  console.log("    2. Authenticate: wrangler login")
+  console.log("    3. Deploy: wrangler deploy")
+}
+
+async function deployNetlify(cwd: string): Promise<void> {
+  const { generateNetlifyConfig, generateNetlifyFunction } = await import("../deploy/netlify.ts")
+  await writeAndLog(join(cwd, "netlify.toml"), generateNetlifyConfig())
+  const edgeFnDir = join(cwd, "netlify/edge-functions")
+  await mkdir(edgeFnDir, { recursive: true })
+  await writeAndLog(join(edgeFnDir, "gorsee-handler.ts"), generateNetlifyFunction())
+  console.log("\n  Next steps:")
+  console.log("    1. Install Netlify CLI: npm i -g netlify-cli")
+  console.log("    2. Run: netlify init")
+  console.log("    3. Deploy: netlify deploy --prod")
+}
+
+async function deployDocker(cwd: string): Promise<void> {
+  const { generateDockerfile, generateDockerignore } = await import("../deploy/dockerfile.ts")
+  await writeAndLog(join(cwd, "Dockerfile"), generateDockerfile())
+  await writeAndLog(join(cwd, ".dockerignore"), generateDockerignore())
+  console.log("\n  Next steps:")
+  console.log("    1. Build image: docker build -t gorsee-app .")
+  console.log("    2. Run: docker run -p 3000:3000 gorsee-app")
+}
+
+export async function runDeploy(args: string[]): Promise<void> {
+  const cwd = process.cwd()
+  const initOnly = args.includes("--init")
+  const targetArg = args.find((a) => !a.startsWith("-")) as Target | undefined
+
+  let target = targetArg ?? null
+  if (!target) {
+    target = await detectTarget(cwd)
+    if (!target) {
+      console.error("  No deploy target specified and none detected.")
+      console.error(`  Usage: gorsee deploy <${TARGETS.join("|")}> [--init]`)
+      process.exit(1)
+    }
+    console.log(`  Auto-detected target: ${target}`)
+  }
+
+  if (!TARGETS.includes(target)) {
+    console.error(`  Unknown target: ${target}`)
+    console.error(`  Available: ${TARGETS.join(", ")}`)
+    process.exit(1)
+  }
+
+  const projectName = cwd.split("/").pop() ?? "gorsee-app"
+  console.log(`\n  Generating ${target} deploy config...\n`)
+
+  switch (target) {
+    case "vercel":
+      await deployVercel(cwd)
+      break
+    case "fly":
+      await deployFly(cwd, projectName)
+      break
+    case "cloudflare":
+      await deployCloudflare(cwd, projectName)
+      break
+    case "netlify":
+      await deployNetlify(cwd)
+      break
+    case "docker":
+      await deployDocker(cwd)
+      break
+  }
+
+  if (initOnly) {
+    console.log("\n  Config generated (--init mode). Deploy manually when ready.")
+  }
+
+  console.log()
+}

package/src/cli/index.ts

@@ -14,6 +14,7 @@ const COMMANDS: Record<string, string> = {
   migrate: "Run database migrations",
   generate: "Generate CRUD scaffold for entity",
   typegen: "Generate typed route definitions",
+  deploy: "Generate deploy config (vercel/fly/cloudflare/netlify/docker)",
   help: "Show this help message",
 }
 
@@ -55,6 +56,10 @@ async function main() {
       const { runTypegen } = await import("./cmd-typegen.ts")
       await runTypegen(args.slice(1))
       break
+    case "deploy":
+      const { runDeploy } = await import("./cmd-deploy.ts")
+      await runDeploy(args.slice(1))
+      break
     case "help":
     case undefined:
     case "--help":

package/src/deploy/cloudflare.ts

@@ -0,0 +1,109 @@
+// Gorsee.js — Cloudflare Workers/Pages deploy adapter
+
+export function generateWranglerConfig(name: string): string {
+  const today = new Date().toISOString().split("T")[0]
+
+  return `# Gorsee.js — Cloudflare Workers configuration
+# Auto-generated by \`gorsee deploy cloudflare\`
+
+name = "${name}"
+main = "dist/worker.js"
+compatibility_date = "${today}"
+compatibility_flags = ["nodejs_compat"]
+
+[site]
+bucket = "./dist/client"
+
+[build]
+command = "bun run build"
+
+# KV namespace for caching (optional)
+# [[kv_namespaces]]
+# binding = "CACHE"
+# id = ""
+
+# Environment variables
+[vars]
+NODE_ENV = "production"
+
+# Production overrides
+[env.production]
+name = "${name}"
+route = { pattern = "*", zone_name = "" }
+`
+}
+
+export function generateCloudflareEntry(): string {
+  return `// Gorsee.js — Cloudflare Worker entry
+// Auto-generated by \`gorsee deploy cloudflare\`
+
+export default {
+  async fetch(
+    request: Request,
+    env: Record<string, unknown>,
+    ctx: ExecutionContext,
+  ): Promise<Response> {
+    const url = new URL(request.url)
+
+    // Serve static client assets from KV/site
+    if (url.pathname.startsWith("/_gorsee/")) {
+      const assetPath = url.pathname.slice("/_gorsee/".length)
+      // @ts-expect-error — __STATIC_CONTENT is injected by Cloudflare
+      const asset = await (env.__STATIC_CONTENT as any)?.get(assetPath)
+      if (asset) {
+        return new Response(asset, {
+          headers: {
+            "Content-Type": "application/javascript",
+            "Cache-Control": "public, max-age=31536000, immutable",
+          },
+        })
+      }
+    }
+
+    // Serve public static files
+    const staticExts = [".css", ".ico", ".svg", ".png", ".jpg", ".woff2", ".txt"]
+    if (staticExts.some((ext) => url.pathname.endsWith(ext))) {
+      // @ts-expect-error — __STATIC_CONTENT is injected by Cloudflare
+      const asset = await (env.__STATIC_CONTENT as any)?.get(url.pathname.slice(1))
+      if (asset) {
+        return new Response(asset, {
+          headers: { "Cache-Control": "public, max-age=3600" },
+        })
+      }
+    }
+
+    // Forward all other requests to Gorsee server handler
+    // In production, this imports the built server bundle
+    try {
+      const { handleRequest } = await import("./server-handler.js")
+      return await handleRequest(request, env)
+    } catch {
+      return new Response("Internal Server Error", { status: 500 })
+    }
+  },
+}
+`
+}
+
+export interface CloudflareRoutesConfig {
+  version: number
+  include: string[]
+  exclude: string[]
+}
+
+export function generateCloudflareStaticAssets(): CloudflareRoutesConfig {
+  return {
+    version: 1,
+    include: ["/*"],
+    exclude: [
+      "/_gorsee/*",
+      "/favicon.ico",
+      "/robots.txt",
+      "/styles.css",
+      "/*.png",
+      "/*.jpg",
+      "/*.svg",
+      "/*.woff2",
+    ],
+  }
+}

package/src/deploy/fly.ts

@@ -0,0 +1,79 @@
+// Gorsee.js — Fly.io deploy adapter
+
+export function generateFlyConfig(appName: string): string {
+  return `# Gorsee.js — Fly.io configuration
+# Auto-generated by \`gorsee deploy fly\`
+
+app = "${appName}"
+primary_region = "iad"
+
+[build]
+  dockerfile = "Dockerfile"
+
+[env]
+  NODE_ENV = "production"
+  PORT = "3000"
+
+[http_service]
+  internal_port = 3000
+  force_https = true
+  auto_stop_machines = "stop"
+  auto_start_machines = true
+  min_machines_running = 1
+
+  [http_service.concurrency]
+    type = "requests"
+    hard_limit = 250
+    soft_limit = 200
+
+[[http_service.checks]]
+  grace_period = "10s"
+  interval = "30s"
+  method = "GET"
+  path = "/api/health"
+  timeout = "5s"
+
+[[vm]]
+  size = "shared-cpu-1x"
+  memory = "512mb"
+  processes = ["app"]
+  count_min = 1
+  count_max = 3
+`
+}
+
+export function generateFlyDockerfile(): string {
+  return `# Gorsee.js — Fly.io optimized Dockerfile
+# Auto-generated by \`gorsee deploy fly\`
+
+FROM oven/bun:1 AS builder
+WORKDIR /app
+COPY package.json bun.lock* ./
+RUN bun install --frozen-lockfile
+COPY . .
+RUN bun run build
+
+FROM oven/bun:1-slim
+WORKDIR /app
+
+COPY --from=builder /app/package.json ./
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/routes ./routes
+COPY --from=builder /app/public ./public
+COPY --from=builder /app/.env* ./
+
+ENV NODE_ENV=production
+ENV PORT=3000
+
+# Fly.io runtime env vars are injected automatically:
+# FLY_ALLOC_ID, FLY_APP_NAME, FLY_REGION, FLY_MACHINE_ID
+
+EXPOSE 3000
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \\
+  CMD curl -f http://localhost:3000/api/health || exit 1
+
+CMD ["bun", "run", "start"]
+`
+}

package/src/deploy/index.ts

@@ -0,0 +1,31 @@
+// Gorsee.js — Deploy adapters barrel export
+
+export {
+  generateDockerfile,
+  generateDockerignore,
+} from "./dockerfile.ts"
+
+export {
+  generateVercelConfig,
+  generateVercelServerlessEntry,
+  generateVercelBuildOutput,
+  type VercelConfig,
+  type VercelOutputConfig,
+} from "./vercel.ts"
+
+export {
+  generateFlyConfig,
+  generateFlyDockerfile,
+} from "./fly.ts"
+
+export {
+  generateWranglerConfig,
+  generateCloudflareEntry,
+  generateCloudflareStaticAssets,
+  type CloudflareRoutesConfig,
+} from "./cloudflare.ts"
+
+export {
+  generateNetlifyConfig,
+  generateNetlifyFunction,
+} from "./netlify.ts"

package/src/deploy/netlify.ts

@@ -0,0 +1,77 @@
+// Gorsee.js — Netlify deploy adapter
+
+export function generateNetlifyConfig(): string {
+  return `# Gorsee.js — Netlify configuration
+# Auto-generated by \`gorsee deploy netlify\`
+
+[build]
+  command = "bun run build"
+  publish = "dist/client"
+
+[build.environment]
+  NODE_VERSION = "20"
+
+[[edge_functions]]
+  function = "gorsee-handler"
+  path = "/*"
+
+# Static assets bypass edge functions
+[[edge_functions]]
+  function = "gorsee-handler"
+  path = "/_gorsee/*"
+  excludedPath = true
+
+[[redirects]]
+  from = "/_gorsee/*"
+  to = "/client/:splat"
+  status = 200
+
+[[redirects]]
+  from = "/*"
+  to = "/.netlify/edge-functions/gorsee-handler"
+  status = 200
+  force = false
+
+[[headers]]
+  for = "/_gorsee/*"
+  [headers.values]
+    Cache-Control = "public, max-age=31536000, immutable"
+`
+}
+
+export function generateNetlifyFunction(): string {
+  return `// Gorsee.js — Netlify Edge Function
+// Auto-generated by \`gorsee deploy netlify\`
+// Place in: netlify/edge-functions/gorsee-handler.ts
+
+import type { Context } from "https://edge.netlify.com"
+
+export default async function handler(
+  request: Request,
+  context: Context,
+): Promise<Response> {
+  const url = new URL(request.url)
+
+  // Skip static assets — handled by Netlify CDN
+  if (url.pathname.startsWith("/_gorsee/")) {
+    return context.next()
+  }
+
+  const staticExts = [".css", ".ico", ".svg", ".png", ".jpg", ".woff2", ".txt"]
+  if (staticExts.some((ext) => url.pathname.endsWith(ext))) {
+    return context.next()
+  }
+
+  // Forward to Gorsee server handler
+  try {
+    const { handleRequest } = await import("../../dist/server-handler.js")
+    return await handleRequest(request, { netlifyContext: context })
+  } catch (err) {
+    console.error("Gorsee handler error:", err)
+    return new Response("Internal Server Error", { status: 500 })
+  }
+}
+
+export const config = { path: "/*" }
+`
+}

package/src/deploy/vercel.ts

@@ -0,0 +1,94 @@
+// Gorsee.js — Vercel deploy adapter
+
+export interface VercelConfig {
+  version: number
+  framework: null
+  buildCommand: string
+  outputDirectory: string
+  routes: Array<{ src: string; dest?: string; headers?: Record<string, string> }>
+}
+
+export function generateVercelConfig(): VercelConfig {
+  return {
+    version: 2,
+    framework: null,
+    buildCommand: "bun run build",
+    outputDirectory: ".vercel/output",
+    routes: [
+      {
+        src: "/_gorsee/(.*)",
+        headers: { "Cache-Control": "public, max-age=31536000, immutable" },
+      },
+      { src: "/(.*)", dest: "/api/index" },
+    ],
+  }
+}
+
+export function generateVercelServerlessEntry(): string {
+  return `// Gorsee.js — Vercel serverless entry
+// Auto-generated by \`gorsee deploy vercel\`
+
+import { startProductionServer } from "./dist/prod.js"
+
+let initialized = false
+
+async function ensureInit() {
+  if (!initialized) {
+    initialized = true
+    // Production server setup without Bun.serve()
+  }
+}
+
+export default async function handler(request: Request): Promise<Response> {
+  await ensureInit()
+
+  const url = new URL(request.url)
+
+  // Serve static client assets
+  if (url.pathname.startsWith("/_gorsee/")) {
+    return new Response(null, { status: 404 })
+  }
+
+  // Forward to Gorsee production handler
+  const { createRouter, matchRoute, buildStaticMap } = await import("./dist/router/index.js")
+  const { renderToString, ssrJsx } = await import("./dist/runtime/server.js")
+  const { handleRPCRequest } = await import("./dist/server/rpc.js")
+
+  // RPC handling
+  const rpcResponse = await handleRPCRequest(request)
+  if (rpcResponse) return rpcResponse
+
+  // Return placeholder — full implementation wires into prod.ts handler
+  return new Response("Gorsee on Vercel", {
+    headers: { "Content-Type": "text/html" },
+  })
+}
+`
+}
+
+export interface VercelOutputConfig {
+  version: number
+  routes: Array<{ src: string; dest?: string; headers?: Record<string, string> }>
+}
+
+export function generateVercelBuildOutput(routes: string[]): VercelOutputConfig {
+  const outputRoutes: VercelOutputConfig["routes"] = [
+    {
+      src: "/_gorsee/(.*)",
+      dest: "/static/_gorsee/$1",
+      headers: { "Cache-Control": "public, max-age=31536000, immutable" },
+    },
+    {
+      src: "/favicon\\.ico|/robots\\.txt|/styles\\.css",
+      dest: "/static/$0",
+    },
+  ]
+
+  for (const route of routes) {
+    outputRoutes.push({ src: route, dest: "/functions/index" })
+  }
+
+  outputRoutes.push({ src: "/(.*)", dest: "/functions/index" })
+
+  return { version: 3, routes: outputRoutes }
+}

package/src/index.ts

@@ -25,3 +25,4 @@ export { createEventSource } from "./server/sse.ts"
 export { createAuth } from "./auth/index.ts"
 export { typedLink, typedNavigate } from "./runtime/typed-routes.ts"
 export { defineForm, validateForm, fieldAttrs } from "./runtime/validated-form.ts"
+export { definePlugin, createPluginRunner, type GorseePlugin, type PluginContext } from "./plugins/index.ts"

package/src/plugins/drizzle.ts

@@ -0,0 +1,84 @@
+// Drizzle ORM integration plugin -- zero external dependencies
+
+import type { MiddlewareFn, Context } from "../server/middleware.ts"
+import type { GorseePlugin } from "./index.ts"
+import { definePlugin } from "./index.ts"
+
+export interface DrizzlePluginConfig {
+  schema: string
+  out: string
+  dialect: "sqlite" | "postgres" | "mysql"
+  connectionUrl?: string
+}
+
+let drizzleInstance: unknown = null
+
+/** Returns the current drizzle instance (available after setup) */
+export function getDrizzle<T = unknown>(): T {
+  if (!drizzleInstance) {
+    throw new Error("Drizzle not initialized. Did you register drizzlePlugin?")
+  }
+  return drizzleInstance as T
+}
+
+/** Middleware that attaches drizzle instance to ctx.locals.db */
+export function drizzleMiddleware(instance: unknown): MiddlewareFn {
+  return async (ctx: Context, next) => {
+    ctx.locals.db = instance
+    return next()
+  }
+}
+
+/** Generates drizzle.config.ts content string */
+export function generateDrizzleConfig(config: DrizzlePluginConfig): string {
+  const dbCredentials =
+    config.dialect === "sqlite"
+      ? `{ url: "${config.connectionUrl ?? "./data.db"}" }`
+      : `{ connectionString: "${config.connectionUrl ?? ""}" }`
+
+  return `import { defineConfig } from "drizzle-kit"
+
+export default defineConfig({
+  schema: "${config.schema}",
+  out: "${config.out}",
+  dialect: "${config.dialect}",
+  dbCredentials: ${dbCredentials},
+})
+`
+}
+
+/** Creates a Drizzle ORM integration plugin */
+export function drizzlePlugin(config: DrizzlePluginConfig): GorseePlugin {
+  return definePlugin({
+    name: "gorsee-drizzle",
+
+    async setup(app) {
+      if (config.dialect === "sqlite") {
+        const { Database } = await import("bun:sqlite" as string)
+        const db = new Database(config.connectionUrl ?? "./data.db")
+        db.exec("PRAGMA journal_mode=WAL")
+
+        // Dynamic import for drizzle-orm/bun-sqlite
+        try {
+          const { drizzle } = await import("drizzle-orm/bun-sqlite" as string)
+          drizzleInstance = drizzle(db)
+        } catch {
+          // If drizzle-orm not installed, store raw db
+          drizzleInstance = db
+        }
+      } else {
+        // For postgres/mysql, store connection URL for user to configure
+        drizzleInstance = { dialect: config.dialect, url: config.connectionUrl }
+      }
+
+      app.addMiddleware(drizzleMiddleware(drizzleInstance))
+    },
+
+    async teardown() {
+      if (drizzleInstance && typeof (drizzleInstance as any).close === "function") {
+        ;(drizzleInstance as any).close()
+      }
+      drizzleInstance = null
+    },
+  })
+}

package/src/plugins/index.ts

@@ -0,0 +1,86 @@
+// Gorsee plugin system -- lifecycle management for framework extensions
+
+import type { MiddlewareFn, Context } from "../server/middleware.ts"
+
+export interface GorseePlugin {
+  name: string
+  /** Hook into server startup */
+  setup?: (app: PluginContext) => void | Promise<void>
+  /** Add middleware to every request */
+  middleware?: MiddlewareFn
+  /** Hook into build pipeline */
+  buildPlugins?: () => import("bun").BunPlugin[]
+  /** Cleanup on shutdown */
+  teardown?: () => void | Promise<void>
+}
+
+export interface PluginContext {
+  /** Register a middleware */
+  addMiddleware(mw: MiddlewareFn): void
+  /** Register a route programmatically */
+  addRoute(path: string, handler: (ctx: Context) => Promise<Response>): void
+  /** Access app config */
+  config: Record<string, unknown>
+}
+
+/** Identity helper for type inference */
+export function definePlugin(plugin: GorseePlugin): GorseePlugin {
+  return plugin
+}
+
+export interface PluginRunner {
+  register(plugin: GorseePlugin): void
+  setupAll(): Promise<void>
+  teardownAll(): Promise<void>
+  getMiddlewares(): MiddlewareFn[]
+  getBuildPlugins(): import("bun").BunPlugin[]
+  getRoutes(): Map<string, (ctx: Context) => Promise<Response>>
+}
+
+/** Creates a plugin runner that manages the full plugin lifecycle */
+export function createPluginRunner(
+  config: Record<string, unknown> = {},
+): PluginRunner {
+  const plugins: GorseePlugin[] = []
+  const middlewares: MiddlewareFn[] = []
+  const routes = new Map<string, (ctx: Context) => Promise<Response>>()
+
+  const pluginCtx: PluginContext = {
+    addMiddleware: (mw) => middlewares.push(mw),
+    addRoute: (path, handler) => routes.set(path, handler),
+    config,
+  }
+
+  return {
+    register(plugin: GorseePlugin) {
+      plugins.push(plugin)
+      if (plugin.middleware) {
+        middlewares.push(plugin.middleware)
+      }
+    },
+
+    async setupAll() {
+      for (const plugin of plugins) {
+        if (plugin.setup) await plugin.setup(pluginCtx)
+      }
+    },
+
+    async teardownAll() {
+      for (const plugin of [...plugins].reverse()) {
+        if (plugin.teardown) await plugin.teardown()
+      }
+    },
+
+    getMiddlewares: () => [...middlewares],
+
+    getBuildPlugins() {
+      const result: import("bun").BunPlugin[] = []
+      for (const plugin of plugins) {
+        if (plugin.buildPlugins) result.push(...plugin.buildPlugins())
+      }
+      return result
+    },
+
+    getRoutes: () => new Map(routes),
+  }
+}

package/src/plugins/lucia.ts

@@ -0,0 +1,111 @@
+// Lucia auth adapter plugin -- session management integration
+
+import type { MiddlewareFn, Context } from "../server/middleware.ts"
+import type { GorseePlugin } from "./index.ts"
+import { definePlugin } from "./index.ts"
+
+export interface LuciaPluginConfig {
+  adapter: "sqlite" | "prisma" | "drizzle"
+  sessionTable?: string
+  userTable?: string
+}
+
+interface LuciaInstance {
+  validateSession(sessionId: string): Promise<{ session: unknown; user: unknown } | null>
+  createSession(userId: string, attributes?: Record<string, unknown>): Promise<{ id: string }>
+  invalidateSession(sessionId: string): Promise<void>
+}
+
+let luciaInstance: LuciaInstance | null = null
+
+/** Returns the Lucia instance (available after setup) */
+export function getLucia(): LuciaInstance {
+  if (!luciaInstance) {
+    throw new Error("Lucia not initialized. Did you register luciaPlugin?")
+  }
+  return luciaInstance
+}
+
+/** Extracts current session from context (set by middleware) */
+export function getSession(ctx: Context): unknown | null {
+  return ctx.locals.session ?? null
+}
+
+/** Extracts current user from context (set by middleware) */
+export function getUser(ctx: Context): unknown | null {
+  return ctx.locals.user ?? null
+}
+
+/** Creates the session validation middleware */
+function createSessionMiddleware(): MiddlewareFn {
+  return async (ctx: Context, next) => {
+    ctx.locals.session = null
+    ctx.locals.user = null
+
+    const sessionId =
+      ctx.cookies.get("auth_session") ??
+      ctx.request.headers.get("Authorization")?.replace("Bearer ", "") ??
+      null
+
+    if (sessionId && luciaInstance) {
+      try {
+        const result = await luciaInstance.validateSession(sessionId)
+        if (result) {
+          ctx.locals.session = result.session
+          ctx.locals.user = result.user
+        }
+      } catch {
+        // Invalid session -- continue without auth
+      }
+    }
+
+    return next()
+  }
+}
+
+/** Creates a Lucia auth integration plugin */
+export function luciaPlugin(config: LuciaPluginConfig): GorseePlugin {
+  return definePlugin({
+    name: "gorsee-lucia",
+
+    async setup() {
+      try {
+        const { Lucia } = await import("lucia" as string)
+        let adapter: unknown
+
+        if (config.adapter === "sqlite") {
+          const { BunSQLiteAdapter } = await import("@lucia-auth/adapter-sqlite" as string)
+          const { Database } = await import("bun:sqlite" as string)
+          const db = new Database("./data.db")
+          adapter = new BunSQLiteAdapter(db, {
+            session: config.sessionTable ?? "session",
+            user: config.userTable ?? "user",
+          })
+        } else if (config.adapter === "prisma") {
+          const { PrismaAdapter } = await import("@lucia-auth/adapter-prisma" as string)
+          const { PrismaClient } = await import("@prisma/client" as string)
+          adapter = new PrismaAdapter(new PrismaClient(), {
+            session: config.sessionTable ?? "session",
+            user: config.userTable ?? "user",
+          })
+        } else {
+          // Drizzle adapter -- user must configure separately
+          adapter = null
+        }
+
+        if (adapter) {
+          luciaInstance = new Lucia(adapter) as unknown as LuciaInstance
+        }
+      } catch {
+        // Lucia not installed -- instance stays null
+        luciaInstance = null
+      }
+    },
+
+    middleware: createSessionMiddleware(),
+
+    async teardown() {
+      luciaInstance = null
+    },
+  })
+}

package/src/plugins/prisma.ts

@@ -0,0 +1,85 @@
+// Prisma integration plugin -- zero external dependencies
+
+import type { MiddlewareFn, Context } from "../server/middleware.ts"
+import type { GorseePlugin } from "./index.ts"
+import { definePlugin } from "./index.ts"
+
+export interface PrismaPluginConfig {
+  schemaPath?: string
+  datasourceUrl?: string
+}
+
+let prismaClient: unknown = null
+
+/** Returns the current Prisma client (available after setup) */
+export function getPrisma<T = unknown>(): T {
+  if (!prismaClient) {
+    throw new Error("Prisma not initialized. Did you register prismaPlugin?")
+  }
+  return prismaClient as T
+}
+
+/** Middleware that attaches prisma to ctx.locals.prisma */
+export function prismaMiddleware(client: unknown): MiddlewareFn {
+  return async (ctx: Context, next) => {
+    ctx.locals.prisma = client
+    return next()
+  }
+}
+
+/** Generates a basic schema.prisma content string */
+export function generatePrismaSchema(config: PrismaPluginConfig): string {
+  const url = config.datasourceUrl ?? "file:./dev.db"
+  const provider = url.startsWith("file:") ? "sqlite"
+    : url.startsWith("postgres") ? "postgresql"
+    : "mysql"
+
+  return `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${provider}"
+  url      = "${url}"
+}
+
+// Add your models below
+// model User {
+//   id    Int     @id @default(autoincrement())
+//   email String  @unique
+//   name  String?
+// }
+`
+}
+
+/** Creates a Prisma integration plugin */
+export function prismaPlugin(config: PrismaPluginConfig = {}): GorseePlugin {
+  return definePlugin({
+    name: "gorsee-prisma",
+
+    async setup(app) {
+      try {
+        // Dynamic import -- PrismaClient must be generated by user
+        const { PrismaClient } = await import("@prisma/client" as string)
+        prismaClient = new PrismaClient({
+          datasourceUrl: config.datasourceUrl,
+        })
+      } catch {
+        // If @prisma/client not available, create a placeholder
+        prismaClient = {
+          _placeholder: true,
+          _message: "Run `bunx prisma generate` to create the client",
+        }
+      }
+
+      app.addMiddleware(prismaMiddleware(prismaClient))
+    },
+
+    async teardown() {
+      if (prismaClient && typeof (prismaClient as any).$disconnect === "function") {
+        await (prismaClient as any).$disconnect()
+      }
+      prismaClient = null
+    },
+  })
+}

package/src/plugins/resend.ts

@@ -0,0 +1,78 @@
+// Resend email plugin -- uses native fetch, no SDK dependency
+
+import type { GorseePlugin } from "./index.ts"
+import { definePlugin } from "./index.ts"
+
+export interface ResendPluginConfig {
+  apiKey: string
+  from?: string
+}
+
+export interface SendEmailOptions {
+  to: string | string[]
+  subject: string
+  html?: string
+  text?: string
+  from?: string
+}
+
+export interface Mailer {
+  send(options: SendEmailOptions): Promise<{ id: string }>
+}
+
+const RESEND_API = "https://api.resend.com"
+
+let mailerInstance: Mailer | null = null
+
+/** Returns the mailer instance (available after setup) */
+export function getMailer(): Mailer {
+  if (!mailerInstance) {
+    throw new Error("Resend not initialized. Did you register resendPlugin?")
+  }
+  return mailerInstance
+}
+
+function createMailer(config: ResendPluginConfig): Mailer {
+  return {
+    async send(options: SendEmailOptions): Promise<{ id: string }> {
+      const body = {
+        from: options.from ?? config.from ?? "onboarding@resend.dev",
+        to: Array.isArray(options.to) ? options.to : [options.to],
+        subject: options.subject,
+        ...(options.html ? { html: options.html } : {}),
+        ...(options.text ? { text: options.text } : {}),
+      }
+
+      const res = await fetch(`${RESEND_API}/emails`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${config.apiKey}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+      })
+
+      if (!res.ok) {
+        const err = await res.text()
+        throw new Error(`Resend API error (${res.status}): ${err}`)
+      }
+
+      return (await res.json()) as { id: string }
+    },
+  }
+}
+
+/** Creates a Resend email plugin */
+export function resendPlugin(config: ResendPluginConfig): GorseePlugin {
+  return definePlugin({
+    name: "gorsee-resend",
+
+    async setup() {
+      mailerInstance = createMailer(config)
+    },
+
+    async teardown() {
+      mailerInstance = null
+    },
+  })
+}

package/src/plugins/s3.ts

@@ -0,0 +1,102 @@
+// S3-compatible object storage plugin -- uses native fetch, no AWS SDK
+
+import type { GorseePlugin } from "./index.ts"
+import { definePlugin } from "./index.ts"
+
+export interface S3PluginConfig {
+  bucket: string
+  region?: string
+  endpoint?: string
+  accessKeyId?: string
+  secretAccessKey?: string
+}
+
+export interface StorageClient {
+  upload(key: string, body: ArrayBuffer | ReadableStream | string, contentType?: string): Promise<string>
+  download(key: string): Promise<Response>
+  delete(key: string): Promise<void>
+  list(prefix?: string): Promise<string[]>
+}
+
+let storageClient: StorageClient | null = null
+
+/** Returns the storage client (available after setup) */
+export function getStorage(): StorageClient {
+  if (!storageClient) {
+    throw new Error("S3 not initialized. Did you register s3Plugin?")
+  }
+  return storageClient
+}
+
+function buildEndpoint(config: S3PluginConfig): string {
+  if (config.endpoint) return config.endpoint.replace(/\/$/, "")
+  const region = config.region ?? "us-east-1"
+  return `https://${config.bucket}.s3.${region}.amazonaws.com`
+}
+
+function createStorageClient(config: S3PluginConfig): StorageClient {
+  const baseUrl = buildEndpoint(config)
+  const headers: Record<string, string> = {}
+
+  // Basic auth headers (simplified -- production should use AWS Signature V4)
+  if (config.accessKeyId) {
+    headers["x-amz-access-key"] = config.accessKeyId
+  }
+
+  return {
+    async upload(key: string, body: ArrayBuffer | ReadableStream | string, contentType?: string) {
+      const url = `${baseUrl}/${encodeURIComponent(key)}`
+      const ct = contentType ?? "application/octet-stream"
+      const fetchBody: BodyInit = body instanceof ArrayBuffer
+        ? new Blob([body], { type: ct })
+        : body
+      const res = await fetch(url, {
+        method: "PUT",
+        headers: { ...headers, "Content-Type": ct },
+        body: fetchBody,
+      })
+      if (!res.ok) throw new Error(`S3 upload failed: ${res.status} ${res.statusText}`)
+      return url
+    },
+
+    async download(key) {
+      const url = `${baseUrl}/${encodeURIComponent(key)}`
+      const res = await fetch(url, { headers })
+      if (!res.ok) throw new Error(`S3 download failed: ${res.status} ${res.statusText}`)
+      return res
+    },
+
+    async delete(key) {
+      const url = `${baseUrl}/${encodeURIComponent(key)}`
+      const res = await fetch(url, { method: "DELETE", headers })
+      if (!res.ok) throw new Error(`S3 delete failed: ${res.status} ${res.statusText}`)
+    },
+
+    async list(prefix) {
+      const params = prefix ? `?list-type=2&prefix=${encodeURIComponent(prefix)}` : "?list-type=2"
+      const res = await fetch(`${baseUrl}${params}`, { headers })
+      if (!res.ok) throw new Error(`S3 list failed: ${res.status} ${res.statusText}`)
+      const xml = await res.text()
+      const keys: string[] = []
+      const regex = /<Key>([^<]+)<\/Key>/g
+      let match: RegExpExecArray | null
+      while ((match = regex.exec(xml)) !== null) keys.push(match[1]!)
+      return keys
+    },
+  }
+}
+
+/** Creates an S3-compatible storage plugin */
+export function s3Plugin(config: S3PluginConfig): GorseePlugin {
+  return definePlugin({
+    name: "gorsee-s3",
+
+    async setup() {
+      storageClient = createStorageClient(config)
+    },
+
+    async teardown() {
+      storageClient = null
+    },
+  })
+}

package/src/plugins/stripe.ts

@@ -0,0 +1,133 @@
+// Stripe payments plugin -- uses native fetch, no stripe SDK dependency
+
+import type { MiddlewareFn, Context } from "../server/middleware.ts"
+import type { GorseePlugin } from "./index.ts"
+import { definePlugin } from "./index.ts"
+
+export interface StripePluginConfig {
+  secretKey: string
+  webhookSecret?: string
+}
+
+export interface CheckoutSessionOptions {
+  lineItems: Array<{ price: string; quantity: number }>
+  mode?: "payment" | "subscription"
+  successUrl: string
+  cancelUrl: string
+}
+
+export interface StripeEvent {
+  id: string
+  type: string
+  data: { object: Record<string, unknown> }
+}
+
+export interface StripeClient {
+  createCheckoutSession(options: CheckoutSessionOptions): Promise<{ url: string; id: string }>
+  verifyWebhook(request: Request): Promise<StripeEvent>
+}
+
+const STRIPE_API = "https://api.stripe.com/v1"
+
+let stripeClient: StripeClient | null = null
+
+/** Returns the Stripe client (available after setup) */
+export function getStripe(): StripeClient {
+  if (!stripeClient) {
+    throw new Error("Stripe not initialized. Did you register stripePlugin?")
+  }
+  return stripeClient
+}
+
+function createStripeClient(config: StripePluginConfig): StripeClient {
+  const authHeader = `Basic ${btoa(config.secretKey + ":")}`
+
+  return {
+    async createCheckoutSession(options) {
+      const params = new URLSearchParams()
+      params.set("mode", options.mode ?? "payment")
+      params.set("success_url", options.successUrl)
+      params.set("cancel_url", options.cancelUrl)
+      options.lineItems.forEach((item, i) => {
+        params.set(`line_items[${i}][price]`, item.price)
+        params.set(`line_items[${i}][quantity]`, String(item.quantity))
+      })
+
+      const res = await fetch(`${STRIPE_API}/checkout/sessions`, {
+        method: "POST",
+        headers: { Authorization: authHeader, "Content-Type": "application/x-www-form-urlencoded" },
+        body: params.toString(),
+      })
+
+      if (!res.ok) {
+        const err = await res.text()
+        throw new Error(`Stripe API error (${res.status}): ${err}`)
+      }
+
+      const data = (await res.json()) as { url: string; id: string }
+      return { url: data.url, id: data.id }
+    },
+
+    async verifyWebhook(request: Request) {
+      const body = await request.text()
+      const sig = request.headers.get("stripe-signature") ?? ""
+
+      if (!config.webhookSecret) {
+        throw new Error("Webhook secret not configured")
+      }
+
+      // Verify signature using HMAC-SHA256
+      const encoder = new TextEncoder()
+      const timestamp = sig.split(",").find((s) => s.startsWith("t="))?.slice(2) ?? ""
+      const v1Sig = sig.split(",").find((s) => s.startsWith("v1="))?.slice(3) ?? ""
+      const payload = `${timestamp}.${body}`
+
+      const key = await crypto.subtle.importKey(
+        "raw",
+        encoder.encode(config.webhookSecret),
+        { name: "HMAC", hash: "SHA-256" },
+        false,
+        ["sign"],
+      )
+      const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload))
+      const expected = Array.from(new Uint8Array(signature))
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("")
+
+      if (expected !== v1Sig) {
+        throw new Error("Invalid webhook signature")
+      }
+
+      return JSON.parse(body) as StripeEvent
+    },
+  }
+}
+
+/** Creates a Stripe payments plugin */
+export function stripePlugin(config: StripePluginConfig): GorseePlugin {
+  return definePlugin({
+    name: "gorsee-stripe",
+
+    async setup(app) {
+      stripeClient = createStripeClient(config)
+
+      // Register webhook route if webhook secret is configured
+      if (config.webhookSecret) {
+        app.addRoute("/api/stripe/webhook", async (ctx) => {
+          try {
+            const event = await stripeClient!.verifyWebhook(ctx.request)
+            return new Response(JSON.stringify({ received: true, type: event.type }), {
+              headers: { "Content-Type": "application/json" },
+            })
+          } catch (err) {
+            return new Response(JSON.stringify({ error: String(err) }), { status: 400 })
+          }
+        })
+      }
+    },
+
+    async teardown() {
+      stripeClient = null
+    },
+  })
+}

package/src/plugins/tailwind.ts

@@ -0,0 +1,92 @@
+// Tailwind CSS integration plugin -- build pipeline hook
+
+import type { GorseePlugin } from "./index.ts"
+import { definePlugin } from "./index.ts"
+
+export interface TailwindPluginConfig {
+  configPath?: string
+  inputCSS?: string
+  outputCSS?: string
+}
+
+/** Generates tailwind.config.ts content */
+export function generateTailwindConfig(options?: {
+  content?: string[]
+  theme?: Record<string, unknown>
+}): string {
+  const content = options?.content ?? [
+    "./routes/**/*.{tsx,ts}",
+    "./components/**/*.{tsx,ts}",
+  ]
+  const themeStr = options?.theme
+    ? JSON.stringify(options.theme, null, 4)
+    : "{}"
+
+  return `/** @type {import('tailwindcss').Config} */
+export default {
+  content: ${JSON.stringify(content, null, 4)},
+  theme: {
+    extend: ${themeStr},
+  },
+  plugins: [],
+}
+`
+}
+
+/** Generates base CSS with @tailwind directives */
+export function generateTailwindCSS(): string {
+  return `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`
+}
+
+/** Creates a Tailwind CSS integration plugin */
+export function tailwindPlugin(config: TailwindPluginConfig = {}): GorseePlugin {
+  const inputCSS = config.inputCSS ?? "./styles/globals.css"
+  const outputCSS = config.outputCSS ?? "./.gorsee/client/tailwind.css"
+
+  return definePlugin({
+    name: "gorsee-tailwind",
+
+    async setup() {
+      // Generate tailwind.config.ts if it doesn't exist
+      const configPath = config.configPath ?? "./tailwind.config.ts"
+      const file = Bun.file(configPath)
+      if (!(await file.exists())) {
+        await Bun.write(configPath, generateTailwindConfig())
+      }
+    },
+
+    buildPlugins() {
+      return [
+        {
+          name: "gorsee-tailwind-transform",
+          setup(build) {
+            build.onLoad({ filter: /\.css$/ }, async (args) => {
+              const source = await Bun.file(args.path).text()
+
+              // If file contains @tailwind directives, process it
+              if (source.includes("@tailwind")) {
+                try {
+                  const proc = Bun.spawn(
+                    ["bunx", "tailwindcss", "-i", args.path, "-o", outputCSS, "--minify"],
+                    { stdin: "inherit", stdout: "pipe", stderr: "pipe" },
+                  )
+                  await proc.exited
+                  const processed = await Bun.file(outputCSS).text()
+                  return { contents: processed, loader: "css" }
+                } catch {
+                  // Fallback: return raw CSS if tailwindcss CLI not available
+                  return { contents: source, loader: "css" }
+                }
+              }
+
+              return undefined
+            })
+          },
+        },
+      ]
+    },
+  })
+}