gorsee 0.2.3 → 0.2.5

package/dist-pkg/auth/index.js

@@ -0,0 +1,199 @@
+import { verifySignedValue, signValue } from "./signing.js";
+export { createNamespacedSessionStore } from "./store-utils.js";
+export { createRedisSessionStore } from "./redis-session-store.js";
+export { createSQLiteSessionStore } from "./sqlite-session-store.js";
+export {
+  createAuthActionTokenManager,
+  createMemoryAuthActionTokenStore
+} from "./action-tokens.js";
+function composeMiddlewares(...middlewares) {
+  return async (ctx, next) => {
+    let index = -1;
+    const dispatch = async (position) => {
+      if (position <= index)
+        throw Error("Middleware chain re-entry is not allowed.");
+      index = position;
+      const middleware = middlewares[position];
+      if (!middleware)
+        return next();
+      return middleware(ctx, () => dispatch(position + 1));
+    };
+    return dispatch(0);
+  };
+}
+export function createMemorySessionStore() {
+  const sessions = new Map;
+  return {
+    get: (id) => sessions.get(id),
+    set: (id, session) => {
+      sessions.set(id, session);
+    },
+    delete: (id) => {
+      sessions.delete(id);
+    },
+    entries: () => sessions.entries()
+  };
+}
+const defaultSessionStore = createMemorySessionStore();
+async function pruneExpired(store) {
+  const now = Date.now(), entries = await store.entries();
+  for await (const [id, session] of entries)
+    if (session.expiresAt <= now)
+      await store.delete(id);
+}
+function resolveConfig(config) {
+  return {
+    secret: config.secret,
+    cookieName: config.cookieName ?? "gorsee_session",
+    maxAge: config.maxAge ?? 86400,
+    loginPath: config.loginPath ?? "/login",
+    store: config.store ?? defaultSessionStore,
+    events: config.events,
+    permissionResolver: config.permissionResolver
+  };
+}
+function getSessionRole(session) {
+  const role = session?.data?.role;
+  return typeof role === "string" ? role : null;
+}
+function getSessionPermissions(session) {
+  const permissions = session?.data?.permissions;
+  return Array.isArray(permissions) ? permissions.filter((value) => typeof value === "string") : [];
+}
+export function sessionHasRole(session, role) {
+  return getSessionRole(session) === role;
+}
+export async function sessionHasPermission(session, permission, resolver) {
+  if (!session)
+    return !1;
+  if (getSessionPermissions(session).includes(permission))
+    return !0;
+  if (!resolver)
+    return !1;
+  return resolver(session, permission);
+}
+export function createAuth(config) {
+  const cfg = resolveConfig(config), middleware = async (ctx, next) => {
+    const cookie = ctx.cookies.get(cfg.cookieName);
+    if (cookie) {
+      const sessionId = await verifySignedValue(cookie, cfg.secret);
+      if (sessionId) {
+        const session = await cfg.store.get(sessionId);
+        if (session && session.expiresAt > Date.now())
+          ctx.locals.session = session;
+        else if (session) {
+          await cfg.store.delete(sessionId);
+          await cfg.events?.({
+            type: "expired-session",
+            sessionId: session.id,
+            userId: session.userId
+          });
+        }
+      } else
+        await cfg.events?.({ type: "invalid-cookie", cookieName: cfg.cookieName });
+    }
+    return next();
+  }, requireAuth = async (ctx, next) => {
+    if (!ctx.locals.session)
+      return ctx.redirect(cfg.loginPath);
+    return next();
+  }, requireRole = (role) => async (ctx, next) => {
+    if (!sessionHasRole(getSession(ctx), role))
+      return new Response("Forbidden", { status: 403 });
+    return next();
+  }, requirePermission = (permission) => async (ctx, next) => {
+    if (!await sessionHasPermission(getSession(ctx), permission, cfg.permissionResolver))
+      return new Response("Forbidden", { status: 403 });
+    return next();
+  }, protect = (...middlewares) => composeMiddlewares(middleware, requireAuth, ...middlewares), protectRole = (role, ...middlewares) => protect(requireRole(role), ...middlewares), protectPermission = (permission, ...middlewares) => protect(requirePermission(permission), ...middlewares);
+  async function login(ctx, userId, data = {}) {
+    await pruneExpired(cfg.store);
+    const id = crypto.randomUUID(), session = {
+      id,
+      userId,
+      data,
+      expiresAt: Date.now() + cfg.maxAge * 1000
+    };
+    await cfg.store.set(id, session);
+    ctx.locals.session = session;
+    const signed = await signValue(id, cfg.secret), isProduction = !1;
+    ctx.setCookie(cfg.cookieName, signed, {
+      maxAge: cfg.maxAge,
+      httpOnly: !0,
+      secure: isProduction,
+      sameSite: "Lax",
+      path: "/"
+    });
+    await cfg.events?.({
+      type: "login",
+      sessionId: session.id,
+      userId: session.userId,
+      expiresAt: session.expiresAt
+    });
+  }
+  async function rotateSession(ctx, data) {
+    const current = getSession(ctx);
+    if (!current)
+      throw Error("Cannot rotate session without an authenticated session.");
+    await cfg.store.delete(current.id);
+    await pruneExpired(cfg.store);
+    const nextSession = {
+      id: crypto.randomUUID(),
+      userId: current.userId,
+      data: data ?? current.data,
+      expiresAt: Date.now() + cfg.maxAge * 1000
+    };
+    await cfg.store.set(nextSession.id, nextSession);
+    ctx.locals.session = nextSession;
+    const signed = await signValue(nextSession.id, cfg.secret), isProduction = !1;
+    ctx.setCookie(cfg.cookieName, signed, {
+      maxAge: cfg.maxAge,
+      httpOnly: !0,
+      secure: isProduction,
+      sameSite: "Lax",
+      path: "/"
+    });
+    await cfg.events?.({
+      type: "rotate",
+      previousSessionId: current.id,
+      sessionId: nextSession.id,
+      userId: nextSession.userId,
+      expiresAt: nextSession.expiresAt
+    });
+  }
+  async function logout(ctx) {
+    const session = ctx.locals.session;
+    if (session) {
+      await cfg.store.delete(session.id);
+      ctx.locals.session = void 0;
+      await cfg.events?.({
+        type: "logout",
+        sessionId: session.id,
+        userId: session.userId
+      });
+    }
+    ctx.deleteCookie(cfg.cookieName);
+  }
+  function getSession(ctx) {
+    return ctx.locals.session ?? null;
+  }
+  return {
+    middleware,
+    requireAuth,
+    requireRole,
+    requirePermission,
+    protect,
+    protectRole,
+    protectPermission,
+    login,
+    rotateSession,
+    logout,
+    getSession,
+    hasRole(ctx, role) {
+      return sessionHasRole(getSession(ctx), role);
+    },
+    hasPermission(ctx, permission) {
+      return sessionHasPermission(getSession(ctx), permission, cfg.permissionResolver);
+    }
+  };
+}

package/dist-pkg/auth/redis-session-store.d.ts

@@ -0,0 +1,7 @@
+import type { SessionStore } from "./index.js";
+import { type RedisLikeClient } from "../server/redis-client.js";
+interface RedisSessionStoreOptions {
+    prefix?: string;
+}
+export declare function createRedisSessionStore(client: RedisLikeClient, options?: RedisSessionStoreOptions): SessionStore;
+export {};

package/dist-pkg/auth/redis-session-store.js

@@ -0,0 +1,42 @@
+import { buildRedisKey, stripRedisPrefix } from "../server/redis-client.js";
+export function createRedisSessionStore(client, options = {}) {
+  const prefix = options.prefix ?? "gorsee:session";
+  return {
+    async get(id) {
+      const raw = await client.get(buildRedisKey(prefix, id));
+      if (!raw)
+        return;
+      try {
+        return JSON.parse(raw).session;
+      } catch {
+        await client.del(buildRedisKey(prefix, id));
+        return;
+      }
+    },
+    async set(id, session) {
+      const key = buildRedisKey(prefix, id);
+      await client.set(key, JSON.stringify({ session }));
+      const ttlSeconds = Math.max(1, Math.ceil((session.expiresAt - Date.now()) / 1000));
+      if (client.expire)
+        await client.expire(key, ttlSeconds);
+    },
+    async delete(id) {
+      await client.del(buildRedisKey(prefix, id));
+    },
+    async entries() {
+      const keys = await client.keys(`${prefix}:*`), sessions = [];
+      for (const key of keys) {
+        const raw = await client.get(key);
+        if (!raw)
+          continue;
+        try {
+          const payload = JSON.parse(raw);
+          sessions.push([stripRedisPrefix(prefix, key), payload.session]);
+        } catch {
+          await client.del(key);
+        }
+      }
+      return sessions;
+    }
+  };
+}

package/dist-pkg/auth/signing.d.ts

@@ -0,0 +1,4 @@
+export declare function signValue(value: string, secret: string): Promise<string>;
+export declare function verifySignedValue(signed: string, secret: string): Promise<string | null>;
+export declare function encodeBase64Url(value: string): string;
+export declare function decodeBase64Url(value: string): string;

package/dist-pkg/auth/signing.js

@@ -0,0 +1,33 @@
+import { timingSafeEqual } from "node:crypto";
+let cachedKey = null, cachedSecret = "";
+async function getSigningKey(secret) {
+  if (cachedKey && cachedSecret === secret)
+    return cachedKey;
+  const enc = new TextEncoder;
+  cachedKey = await crypto.subtle.importKey("raw", enc.encode(secret), { name: "HMAC", hash: "SHA-256" }, !1, ["sign", "verify"]);
+  cachedSecret = secret;
+  return cachedKey;
+}
+export async function signValue(value, secret) {
+  const key = await getSigningKey(secret), enc = new TextEncoder, signature = await crypto.subtle.sign("HMAC", key, enc.encode(value)), sigHex = Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `${value}.${sigHex}`;
+}
+export async function verifySignedValue(signed, secret) {
+  const dotIndex = signed.lastIndexOf(".");
+  if (dotIndex === -1)
+    return null;
+  const value = signed.slice(0, dotIndex), expected = await signValue(value, secret);
+  if (expected.length !== signed.length)
+    return null;
+  const a = Buffer.from(expected), b = Buffer.from(signed);
+  if (!timingSafeEqual(a, b))
+    return null;
+  return value;
+}
+export function encodeBase64Url(value) {
+  return Buffer.from(value, "utf-8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+export function decodeBase64Url(value) {
+  const normalized = value.replace(/-/g, "+").replace(/_/g, "/"), padding = normalized.length % 4 === 0 ? "" : "=".repeat(4 - normalized.length % 4);
+  return Buffer.from(`${normalized}${padding}`, "base64").toString("utf-8");
+}

package/dist-pkg/auth/sqlite-session-store.d.ts

@@ -0,0 +1,12 @@
+import type { SessionStore } from "./index.js";
+interface SQLiteSessionStoreOptions {
+    pruneExpiredOnInit?: boolean;
+    pruneExpiredOnGet?: boolean;
+    pruneExpiredOnSet?: boolean;
+    pruneExpiredOnEntries?: boolean;
+}
+export declare function createSQLiteSessionStore(path?: string, options?: SQLiteSessionStoreOptions): SessionStore & {
+    close(): void;
+    deleteExpired(now?: number): number;
+};
+export {};

package/dist-pkg/auth/sqlite-session-store.js

@@ -0,0 +1,83 @@
+import { Database } from "bun:sqlite";
+function ensureSessionTable(sqlite) {
+  sqlite.run(`
+    CREATE TABLE IF NOT EXISTS gorsee_sessions (
+      id TEXT PRIMARY KEY,
+      payload TEXT NOT NULL,
+      expires_at INTEGER NOT NULL
+    )
+  `);
+  sqlite.run("CREATE INDEX IF NOT EXISTS idx_gorsee_sessions_expires_at ON gorsee_sessions (expires_at)");
+}
+function pruneExpiredRows(sqlite, now = Date.now()) {
+  return sqlite.prepare("DELETE FROM gorsee_sessions WHERE expires_at <= ?1").run(now).changes ?? 0;
+}
+function parseStoredSession(sqlite, id, payload, expiresAt) {
+  try {
+    return {
+      ...JSON.parse(payload),
+      expiresAt
+    };
+  } catch {
+    sqlite.prepare("DELETE FROM gorsee_sessions WHERE id = ?1").run(id);
+    return;
+  }
+}
+export function createSQLiteSessionStore(path = ":memory:", options = {}) {
+  const sqlite = new Database(path);
+  sqlite.run("PRAGMA journal_mode=WAL;");
+  ensureSessionTable(sqlite);
+  const {
+    pruneExpiredOnInit = !0,
+    pruneExpiredOnGet = !0,
+    pruneExpiredOnSet = !0,
+    pruneExpiredOnEntries = !0
+  } = options;
+  if (pruneExpiredOnInit)
+    pruneExpiredRows(sqlite);
+  return {
+    async get(id) {
+      if (pruneExpiredOnGet)
+        pruneExpiredRows(sqlite);
+      const row = sqlite.prepare("SELECT payload, expires_at FROM gorsee_sessions WHERE id = ?1").get(id);
+      if (!row)
+        return;
+      return parseStoredSession(sqlite, id, row.payload, row.expires_at);
+    },
+    async set(id, session) {
+      if (pruneExpiredOnSet)
+        pruneExpiredRows(sqlite);
+      sqlite.prepare(`
+        INSERT INTO gorsee_sessions (id, payload, expires_at)
+        VALUES (?1, ?2, ?3)
+        ON CONFLICT(id) DO UPDATE SET
+          payload = excluded.payload,
+          expires_at = excluded.expires_at
+      `).run(id, JSON.stringify({
+        id: session.id,
+        userId: session.userId,
+        data: session.data
+      }), session.expiresAt);
+    },
+    async delete(id) {
+      sqlite.prepare("DELETE FROM gorsee_sessions WHERE id = ?1").run(id);
+    },
+    async entries() {
+      if (pruneExpiredOnEntries)
+        pruneExpiredRows(sqlite);
+      const rows = sqlite.prepare("SELECT id, payload, expires_at FROM gorsee_sessions").all(), sessions = [];
+      for (const row of rows) {
+        const session = parseStoredSession(sqlite, row.id, row.payload, row.expires_at);
+        if (session)
+          sessions.push([row.id, session]);
+      }
+      return sessions;
+    },
+    deleteExpired(now = Date.now()) {
+      return pruneExpiredRows(sqlite, now);
+    },
+    close() {
+      sqlite.close();
+    }
+  };
+}

package/dist-pkg/auth/store-utils.d.ts

@@ -0,0 +1,2 @@
+import type { SessionStore } from "./index.js";
+export declare function createNamespacedSessionStore(store: SessionStore, namespace: string): SessionStore;

package/dist-pkg/auth/store-utils.js

@@ -0,0 +1,20 @@
+export function createNamespacedSessionStore(store, namespace) {
+  const prefix = `${namespace}:`;
+  return {
+    get: (id) => store.get(prefix + id),
+    set: async (id, session) => {
+      await store.set(prefix + id, { ...session, id });
+    },
+    delete: async (id) => {
+      await store.delete(prefix + id);
+    },
+    entries: async function* () {
+      const entries = await store.entries();
+      for await (const [id, session] of entries) {
+        if (!id.startsWith(prefix))
+          continue;
+        yield [id.slice(prefix.length), { ...session, id: id.slice(prefix.length) }];
+      }
+    }
+  };
+}

package/dist-pkg/bin/gorsee.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import "../cli/index.js"

package/dist-pkg/build/backends/experimental-rolldown.d.ts

@@ -0,0 +1,6 @@
+import type { ClientBuildBackend } from "../client-backend.js";
+export declare const EXPERIMENTAL_ROLLDOWN_BACKEND_NAME = "experimental-rolldown";
+export interface ExperimentalRolldownBackendOptions {
+    fallback: ClientBuildBackend;
+}
+export declare function createExperimentalRolldownClientBuildBackend(options: ExperimentalRolldownBackendOptions): ClientBuildBackend;

package/dist-pkg/build/backends/experimental-rolldown.js

@@ -0,0 +1,9 @@
+export const EXPERIMENTAL_ROLLDOWN_BACKEND_NAME = "experimental-rolldown";
+export function createExperimentalRolldownClientBuildBackend(options) {
+  return {
+    name: EXPERIMENTAL_ROLLDOWN_BACKEND_NAME,
+    async build(buildOptions) {
+      return options.fallback.build(buildOptions);
+    }
+  };
+}

package/dist-pkg/build/backends/register.d.ts

@@ -0,0 +1,7 @@
+import { type ClientBuildBackend } from "../client-backend.js";
+export interface RegisterBuiltInBuildBackendsOptions {
+    includeExperimentalRolldown?: boolean;
+    includeRolldown?: boolean;
+    fallbackBackend?: ClientBuildBackend;
+}
+export declare function registerBuiltInBuildBackends(options?: RegisterBuiltInBuildBackendsOptions): string[];

package/dist-pkg/build/backends/register.js

@@ -0,0 +1,24 @@
+import {
+  createBunClientBuildBackend,
+  registerClientBuildBackend
+} from "../client-backend.js";
+import {
+  createExperimentalRolldownClientBuildBackend,
+  EXPERIMENTAL_ROLLDOWN_BACKEND_NAME
+} from "./experimental-rolldown.js";
+import {
+  createRolldownClientBuildBackend,
+  ROLLDOWN_BACKEND_NAME
+} from "./rolldown.js";
+export function registerBuiltInBuildBackends(options = {}) {
+  const registered = [], fallbackBackend = options.fallbackBackend ?? createBunClientBuildBackend();
+  if (options.includeExperimentalRolldown) {
+    registerClientBuildBackend(createExperimentalRolldownClientBuildBackend({ fallback: fallbackBackend }));
+    registered.push(EXPERIMENTAL_ROLLDOWN_BACKEND_NAME);
+  }
+  if (options.includeRolldown) {
+    registerClientBuildBackend(createRolldownClientBuildBackend({ fallback: fallbackBackend }));
+    registered.push(ROLLDOWN_BACKEND_NAME);
+  }
+  return registered;
+}

package/dist-pkg/build/backends/rolldown.d.ts

@@ -0,0 +1,16 @@
+import type { ClientBuildBackend } from "../client-backend.js";
+export declare const ROLLDOWN_BACKEND_NAME = "rolldown";
+export declare const ROLLDOWN_PACKAGE = "rolldown";
+export interface RolldownBackendState {
+    backend: typeof ROLLDOWN_BACKEND_NAME;
+    packageName: typeof ROLLDOWN_PACKAGE;
+    implementation: "rolldown";
+    available: true;
+    fallbackBackend: string;
+    reason: null;
+}
+export interface RolldownBackendOptions {
+    fallback: ClientBuildBackend;
+}
+export declare function createRolldownClientBuildBackend(options: RolldownBackendOptions): ClientBuildBackend;
+export declare function getRolldownBackendState(options: RolldownBackendOptions): RolldownBackendState;

package/dist-pkg/build/backends/rolldown.js

@@ -0,0 +1,176 @@
+import { readdir, readFile, rename } from "node:fs/promises";
+import { dirname, extname, resolve, sep } from "node:path";
+import { build } from "rolldown";
+import ts from "typescript";
+import { normalizeClientBuildLog } from "../diagnostics.js";
+import { resolveBuildPluginsForTarget } from "../plugin.js";
+import {
+  collectCssModule,
+  renderCssModuleExports,
+  transformCssModuleSource
+} from "../css-modules.js";
+import {
+  applyRouteClientTransforms,
+  SERVER_ONLY_MODULES,
+  SERVER_STUB_MODULES
+} from "../route-client-transform.js";
+export const ROLLDOWN_BACKEND_NAME = "rolldown", ROLLDOWN_PACKAGE = "rolldown";
+const EMPTY_NAMESPACE = "\x00gorsee-empty:", STUB_NAMESPACE = "\x00gorsee-stub:", CSS_MODULE_NAMESPACE = "\x00gorsee-css-module:", CSS_MODULE_IMPORT_PREFIX = "gorsee:css-module:";
+export function createRolldownClientBuildBackend(options) {
+  return {
+    name: ROLLDOWN_BACKEND_NAME,
+    async build(buildOptions) {
+      try {
+        const namedInput = Object.fromEntries(buildOptions.entrypoints.map((entrypoint) => [
+          resolveRolldownEntryName(entrypoint),
+          resolve(entrypoint)
+        ]));
+        await build({
+          input: namedInput,
+          platform: "browser",
+          plugins: createRolldownPlugins(buildOptions),
+          output: {
+            dir: resolve(buildOptions.outdir),
+            format: "esm",
+            sourcemap: buildOptions.sourcemap,
+            minify: buildOptions.minify ? { compress: !0, mangle: !0 } : !1,
+            entryFileNames: "[name].js",
+            chunkFileNames: "chunks/[name].js"
+          }
+        });
+        await normalizeRolldownChunkPaths(buildOptions.outdir);
+        return {
+          success: !0,
+          logs: []
+        };
+      } catch (error) {
+        return {
+          success: !1,
+          logs: [extractRolldownDiagnostic(error)]
+        };
+      }
+    }
+  };
+}
+async function normalizeRolldownChunkPaths(outdir) {
+  const chunkDir = resolve(outdir, "chunks"), entries = await readdir(chunkDir, { withFileTypes: !0 }).catch(() => []);
+  for (const entry of entries) {
+    if (!entry.isFile())
+      continue;
+    if (!entry.name.endsWith(".js"))
+      continue;
+    const normalizedName = entry.name.replace(/\.[a-f0-9]{8}(?=\.js$)/, "");
+    if (normalizedName === entry.name)
+      continue;
+    await rename(resolve(chunkDir, entry.name), resolve(chunkDir, normalizedName));
+  }
+}
+export function getRolldownBackendState(options) {
+  return {
+    backend: ROLLDOWN_BACKEND_NAME,
+    packageName: ROLLDOWN_PACKAGE,
+    implementation: "rolldown",
+    available: !0,
+    fallbackBackend: options.fallback.name,
+    reason: null
+  };
+}
+function createRolldownPlugins(options) {
+  const cssModuleIds = new Map;
+  let cssModuleCounter = 0;
+  function registerCssModulePath(filePath) {
+    const id = String(cssModuleCounter++);
+    cssModuleIds.set(id, filePath);
+    return id;
+  }
+  function resolveCssModulePath(id) {
+    const filePath = cssModuleIds.get(id);
+    if (!filePath)
+      throw Error(`Unknown rolldown CSS module id: ${id}`);
+    return filePath;
+  }
+  function rewriteCssModuleImports(source, importer) {
+    return source.replace(/(["'])([^"']+\.module\.css)\1/g, (_match, quote, specifier) => {
+      const filePath = resolve(dirname(importer), specifier), id = registerCssModulePath(filePath);
+      return `${quote}${CSS_MODULE_IMPORT_PREFIX}${id}${quote}`;
+    });
+  }
+  return [
+    {
+      name: "gorsee-rolldown-resolve",
+      resolveId(source, importer) {
+        if (source.startsWith("gorsee:route:"))
+          return source.slice(13);
+        if (source.startsWith(CSS_MODULE_IMPORT_PREFIX))
+          return `${CSS_MODULE_NAMESPACE}${source.slice(CSS_MODULE_IMPORT_PREFIX.length)}`;
+        if (source === "react/jsx-runtime")
+          return options.frameworkResolve("gorsee/jsx-runtime") ?? source;
+        if (source === "react/jsx-dev-runtime")
+          return options.frameworkResolve("gorsee/jsx-dev-runtime") ?? source;
+        const frameworkImport = options.frameworkResolve(source);
+        if (frameworkImport)
+          return frameworkImport;
+        if (SERVER_ONLY_MODULES.includes(source))
+          return `${EMPTY_NAMESPACE}${source}`;
+        if (source in SERVER_STUB_MODULES)
+          return `${STUB_NAMESPACE}${source}`;
+        return null;
+      },
+      async load(id) {
+        if (id.startsWith(EMPTY_NAMESPACE))
+          return "export default {}";
+        if (id.startsWith(STUB_NAMESPACE))
+          return SERVER_STUB_MODULES[id.slice(STUB_NAMESPACE.length)] ?? "export default {}";
+        if (id.startsWith(CSS_MODULE_NAMESPACE)) {
+          const filePath = resolveCssModulePath(id.slice(CSS_MODULE_NAMESPACE.length)), source = await readFile(filePath, "utf8"), { css, classMap } = transformCssModuleSource(filePath, source);
+          collectCssModule(css);
+          return renderCssModuleExports(classMap);
+        }
+        if (isLoadableSourceModule(id)) {
+          const source = await readFile(id, "utf8"), rewritten = rewriteCssModuleImports(source, id);
+          if (/[/\\]routes[/\\].*\.[jt]sx?$/.test(id))
+            return transpileSourceModule(applyRouteClientTransforms(rewritten, id).source, id);
+          return transpileSourceModule(rewritten, id);
+        }
+        return null;
+      }
+    },
+    ...resolveBuildPluginsForTarget(options.plugins, "rolldown")
+  ];
+}
+function isLoadableSourceModule(id) {
+  return /\.(?:[cm]?[jt]sx?)$/.test(id) && !id.includes("/node_modules/");
+}
+function transpileSourceModule(source, filePath) {
+  const extension = extname(filePath), jsx = extension === ".tsx" || extension === ".jsx" ? ts.JsxEmit.ReactJSX : ts.JsxEmit.Preserve;
+  return ts.transpileModule(source, {
+    compilerOptions: {
+      module: ts.ModuleKind.ESNext,
+      target: ts.ScriptTarget.ES2022,
+      jsx,
+      jsxImportSource: "gorsee"
+    },
+    fileName: filePath
+  }).outputText;
+}
+function resolveRolldownEntryName(entrypoint) {
+  const normalized = resolve(entrypoint), marker = `${sep}.gorsee${sep}entries${sep}`, index = normalized.indexOf(marker);
+  if (index >= 0)
+    return normalized.slice(index + marker.length).replace(/\.[cm]?[jt]sx?$/, "");
+  return normalized.split(sep).at(-1)?.replace(/\.[cm]?[jt]sx?$/, "") ?? "entry";
+}
+function extractRolldownDiagnostic(error) {
+  const shape = error, message = typeof shape?.message === "string" ? shape.message : error instanceof Error ? error.message : String(error), file = typeof shape?.id === "string" ? shape.id : typeof shape?.filename === "string" ? shape.filename : typeof shape?.loc?.file === "string" ? shape.loc.file : void 0, detail = typeof shape?.frame === "string" ? shape.frame : shape?.cause instanceof Error ? shape.cause.message : void 0;
+  return normalizeClientBuildLog({
+    message,
+    file,
+    plugin: typeof shape?.plugin === "string" ? shape.plugin : void 0,
+    detail,
+    code: typeof shape?.code === "string" ? shape.code : void 0
+  }, {
+    backend: ROLLDOWN_BACKEND_NAME,
+    phase: "bundle",
+    severity: "error",
+    code: "ROLLDOWN_BUILD_FAILURE"
+  });
+}