gorsee 0.2.3 → 0.2.5

package/dist-pkg/build/readiness.d.ts

@@ -0,0 +1,11 @@
+import { GORSEE_BUILD_BACKEND_ENV } from "./client-backend.js";
+export interface BuildBackendReadiness {
+    envVar: typeof GORSEE_BUILD_BACKEND_ENV;
+    stableDefault: "rolldown";
+    preferredCanary: "experimental-rolldown";
+    selected: string;
+    resolvedFromEnv: string;
+    registered: string[];
+    experimental: string[];
+}
+export declare function getBuildBackendReadiness(env?: NodeJS.ProcessEnv): BuildBackendReadiness;

package/dist-pkg/build/readiness.js

@@ -0,0 +1,18 @@
+import {
+  GORSEE_BUILD_BACKEND_ENV,
+  getClientBuildBackend,
+  listClientBuildBackends,
+  resolveClientBuildBackendName
+} from "./client-backend.js";
+export function getBuildBackendReadiness(env = process.env) {
+  const registered = listClientBuildBackends();
+  return {
+    envVar: GORSEE_BUILD_BACKEND_ENV,
+    stableDefault: "rolldown",
+    preferredCanary: "experimental-rolldown",
+    selected: getClientBuildBackend().name,
+    resolvedFromEnv: resolveClientBuildBackendName(env),
+    registered,
+    experimental: registered.filter((name) => name.startsWith("experimental-"))
+  };
+}

package/dist-pkg/build/route-client-transform.d.ts

@@ -0,0 +1,17 @@
+export declare const SERVER_ONLY_MODULES: readonly ["gorsee/db", "gorsee/log"];
+export declare const SERVER_STUB_MODULES: Record<string, string>;
+export interface RouteClientTransformResult {
+    source: string;
+    removedLoader: boolean;
+    removedServerImports: number;
+    transformedServerCalls: boolean;
+}
+export declare function stripRouteLoader(source: string): {
+    source: string;
+    removed: boolean;
+};
+export declare function stripServerOnlyImports(source: string): {
+    source: string;
+    removedCount: number;
+};
+export declare function applyRouteClientTransforms(source: string, filePath: string): RouteClientTransformResult;

package/dist-pkg/build/route-client-transform.js

@@ -0,0 +1,48 @@
+import { transformServerCalls } from "./rpc-transform.js";
+export const SERVER_ONLY_MODULES = ["gorsee/db", "gorsee/log"], SERVER_STUB_MODULES = {
+  "gorsee/server": `export function server(fn) { return fn; }
+export function middleware(fn) { return fn; }`
+};
+const SERVER_IMPORT_REGEXES = SERVER_ONLY_MODULES.map((mod) => new RegExp(`import\\s+.*?from\\s+["']${mod.replace("/", "\\/")}["'];?\\n?`, "g"));
+export function stripRouteLoader(source) {
+  for (const hookName of ["load", "loader"]) {
+    const loaderRe = new RegExp(`export\\s+(async\\s+)?function\\s+${hookName}\\s*\\([^)]*\\)\\s*(\\{)`, "g"), match = loaderRe.exec(source);
+    if (!match)
+      continue;
+    const start = match.index;
+    let braces = 1, index = loaderRe.lastIndex;
+    while (index < source.length && braces > 0) {
+      if (source[index] === "{")
+        braces++;
+      else if (source[index] === "}")
+        braces--;
+      index++;
+    }
+    return {
+      source: source.slice(0, start) + source.slice(index),
+      removed: !0
+    };
+  }
+  return { source, removed: !1 };
+}
+export function stripServerOnlyImports(source) {
+  let next = source, removedCount = 0;
+  for (const re of SERVER_IMPORT_REGEXES) {
+    re.lastIndex = 0;
+    const matches = [...next.matchAll(re)];
+    if (matches.length === 0)
+      continue;
+    removedCount += matches.length;
+    next = next.replace(re, "");
+  }
+  return { source: next, removedCount };
+}
+export function applyRouteClientTransforms(source, filePath) {
+  const loaderResult = stripRouteLoader(source), importResult = stripServerOnlyImports(loaderResult.source), rpcSource = transformServerCalls(importResult.source, filePath);
+  return {
+    source: rpcSource,
+    removedLoader: loaderResult.removed,
+    removedServerImports: importResult.removedCount,
+    transformedServerCalls: rpcSource !== importResult.source
+  };
+}

package/dist-pkg/build/route-metadata.d.ts

@@ -0,0 +1,6 @@
+import type { Route } from "../router/scanner.js";
+export interface RouteBuildMetadata {
+    hasLoader: boolean;
+    declaresPrerender: boolean;
+}
+export declare function inspectRouteBuildMetadata(route: Route): Promise<RouteBuildMetadata>;

package/dist-pkg/build/route-metadata.js

@@ -0,0 +1,8 @@
+import { inspectRouteFacts } from "../compiler/route-facts.js";
+export async function inspectRouteBuildMetadata(route) {
+  const facts = await inspectRouteFacts(route);
+  return {
+    hasLoader: facts.hasLoader,
+    declaresPrerender: facts.declaresPrerender
+  };
+}

package/dist-pkg/build/rpc-transform.d.ts

@@ -0,0 +1 @@
+export declare function transformServerCalls(source: string, filePath: string): string;

package/dist-pkg/build/rpc-transform.js

@@ -0,0 +1,44 @@
+import { hashRPC } from "../server/rpc-hash.js";
+import { RPC_CONTENT_TYPE, RPC_PROTOCOL_VERSION } from "../server/rpc-protocol.js";
+const DEVALUE_PARSE_MODULE = new URL("./devalue-parse.js", import.meta.url).pathname;
+function stripTypeAnnotations(args) {
+  return args.split(",").map((arg) => {
+    return arg.trim().replace(/\s*:\s*[^,=]+$/, "").replace(/\s*:\s*[^,=]+(?=\s*=)/, "");
+  }).join(", ");
+}
+export function transformServerCalls(source, filePath) {
+  const matches = [...source.matchAll(/\bserver\s*\(\s*(?=async\s|function\s)/g)];
+  if (matches.length === 0)
+    return source;
+  let result = source;
+  for (let i = matches.length - 1;i >= 0; i--) {
+    const match = matches[i], start = match.index, id = hashRPC(filePath, i);
+    let depth = 0, end = start;
+    for (let j = start;j < source.length; j++)
+      if (source[j] === "(")
+        depth++;
+      else if (source[j] === ")") {
+        depth--;
+        if (depth === 0) {
+          end = j + 1;
+          break;
+        }
+      }
+    const argsMatch = source.slice(start + match[0].length, end - 1).match(/^(async\s+)?(?:\(([^)]*)\)|(\w+))\s*=>/), rawArgs = argsMatch ? argsMatch[2] ?? argsMatch[3] ?? "" : "", args = rawArgs ? stripTypeAnnotations(rawArgs) : "...args", stub = `(async (${args}) => {
+  const res = await fetch("/api/_rpc/${id}", {
+    method: "POST",
+    headers: { "Content-Type": "${RPC_CONTENT_TYPE}", "Accept": "${RPC_CONTENT_TYPE}" },
+    body: JSON.stringify({ v: ${RPC_PROTOCOL_VERSION}, args: [${args}] })
+  });
+  if (!res.ok) throw new Error("RPC failed: " + res.status);
+  const payload = await res.json();
+  if (!payload || payload.ok !== true || payload.v !== ${RPC_PROTOCOL_VERSION} || payload.encoding !== "devalue") {
+    throw new Error("RPC protocol mismatch");
+  }
+  return __gorseeDevalParse(payload.data);
+})`;
+    result = result.slice(0, start) + stub + result.slice(end);
+  }
+  return `import { parse as __gorseeDevalParse } from "${DEVALUE_PARSE_MODULE}";
+` + result;
+}

package/dist-pkg/build/server-bundle.d.ts

@@ -0,0 +1,4 @@
+export interface ServerBundleSurface {
+    serverEntries: string[];
+}
+export declare function buildServerArtifacts(cwd: string, distDir: string): Promise<ServerBundleSurface>;

package/dist-pkg/build/server-bundle.js

@@ -0,0 +1,261 @@
+import { existsSync } from "node:fs";
+import { basename, join, relative, resolve } from "node:path";
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import ts from "typescript";
+const FRAMEWORK_ROOT = resolve(import.meta.dir, "..");
+function resolveFrameworkModule(stem) {
+  const tsPath = join(FRAMEWORK_ROOT, `${stem}.ts`);
+  if (existsSync(tsPath))
+    return tsPath;
+  const jsPath = join(FRAMEWORK_ROOT, `${stem}.js`);
+  if (existsSync(jsPath))
+    return jsPath;
+  return tsPath;
+}
+export async function buildServerArtifacts(cwd, distDir) {
+  const entryDir = join(cwd, ".gorsee", "server"), compiledAppDir = join(distDir, "server", "app"), runtimePathOverrides = {
+    routesDir: join(compiledAppDir, "routes"),
+    sharedDir: join(compiledAppDir, "shared"),
+    middlewareDir: join(compiledAppDir, "middleware"),
+    appConfigFile: join(compiledAppDir, "app.config.js")
+  };
+  await rm(entryDir, { recursive: !0, force: !0 });
+  await mkdir(entryDir, { recursive: !0 });
+  await compileServerAppForNode(cwd, compiledAppDir);
+  const prodEntry = join(entryDir, "prod-entry.ts"), prodNodeEntry = join(entryDir, "prod-node-entry.ts"), serverHandlerEntry = join(entryDir, "server-handler-entry.ts"), serverHandlerNodeEntry = join(entryDir, "server-handler-node-entry.ts"), workerEntry = join(entryDir, "worker-entry.ts");
+  await writeFile(prodEntry, createProdEntrySource(cwd, runtimePathOverrides), "utf-8");
+  await writeFile(prodNodeEntry, createProdNodeEntrySource(cwd, runtimePathOverrides), "utf-8");
+  await writeFile(serverHandlerEntry, createServerHandlerEntrySource(cwd, runtimePathOverrides), "utf-8");
+  await writeFile(serverHandlerNodeEntry, createServerHandlerNodeEntrySource(cwd, runtimePathOverrides), "utf-8");
+  await writeFile(workerEntry, createWorkerEntrySource(serverHandlerEntry), "utf-8");
+  await bundleServerEntry(prodEntry, join(distDir, "prod.js"));
+  await bundleServerEntry(prodNodeEntry, join(distDir, "prod-node.js"), "node");
+  await bundleServerEntry(serverHandlerEntry, join(distDir, "server-handler.js"));
+  await bundleServerEntry(serverHandlerNodeEntry, join(distDir, "server-handler-node.js"), "node");
+  await bundleServerEntry(workerEntry, join(distDir, "worker.js"));
+  return {
+    serverEntries: ["prod.js", "prod-node.js", "server-handler.js", "server-handler-node.js", "worker.js"]
+  };
+}
+async function bundleServerEntry(entrypoint, outfile, target = "bun") {
+  const outdir = join(dirnameOf(outfile), ".server-bundle");
+  await rm(outdir, { recursive: !0, force: !0 });
+  await mkdir(outdir, { recursive: !0 });
+  const result = await Bun.build({
+    entrypoints: [entrypoint],
+    outdir,
+    target,
+    format: "esm",
+    minify: !1,
+    sourcemap: "none",
+    naming: "[name].js"
+  });
+  if (!result.success) {
+    const message = result.logs.map((log) => log.message).join(`
+`);
+    throw Error(message || `Server build failed for ${outfile}`);
+  }
+  const expectedName = `${basename(entrypoint).replace(/\.[^.]+$/, "")}.js`;
+  await rename(join(outdir, expectedName), outfile);
+  await rm(outdir, { recursive: !0, force: !0 });
+}
+function createProdEntrySource(cwd, pathOverrides) {
+  const prodModule = JSON.stringify(resolveFrameworkModule("prod")), projectCwd = JSON.stringify(cwd), serializedOverrides = JSON.stringify(pathOverrides, null, 2);
+  return `import {
+  createProductionFetchHandler as createBundledProductionFetchHandler,
+  startProductionServer as startBundledProductionServer,
+} from ${prodModule}
+
+const PROJECT_CWD = ${projectCwd}
+const PATH_OVERRIDES = ${serializedOverrides}
+
+export function createProductionFetchHandler(options = {}) {
+  return createBundledProductionFetchHandler({
+    cwd: PROJECT_CWD,
+    pathOverrides: PATH_OVERRIDES,
+    ...options,
+  })
+}
+
+export function startProductionServer(options = {}) {
+  return startBundledProductionServer({
+    cwd: PROJECT_CWD,
+    pathOverrides: PATH_OVERRIDES,
+    ...options,
+  })
+}
+`;
+}
+function createProdNodeEntrySource(cwd, pathOverrides) {
+  const prodModule = JSON.stringify(resolveFrameworkModule("prod")), projectCwd = JSON.stringify(cwd), serializedOverrides = JSON.stringify(pathOverrides, null, 2);
+  return `import {
+  createProductionFetchHandler as createBundledProductionFetchHandler,
+  startNodeProductionServer as startBundledNodeProductionServer,
+} from ${prodModule}
+
+const PROJECT_CWD = ${projectCwd}
+const PATH_OVERRIDES = ${serializedOverrides}
+
+export function createProductionFetchHandler(options = {}) {
+  return createBundledProductionFetchHandler({
+    cwd: PROJECT_CWD,
+    pathOverrides: PATH_OVERRIDES,
+    ...options,
+  })
+}
+
+export function startNodeProductionServer(options = {}) {
+  return startBundledNodeProductionServer({
+    cwd: PROJECT_CWD,
+    pathOverrides: PATH_OVERRIDES,
+    ...options,
+  })
+}
+`;
+}
+function createServerHandlerEntrySource(cwd, pathOverrides) {
+  const prodModule = JSON.stringify(resolveFrameworkModule("prod")), projectCwd = JSON.stringify(cwd), serializedOverrides = JSON.stringify(pathOverrides, null, 2);
+  return `import { createProductionFetchHandler } from ${prodModule}
+
+const PROJECT_CWD = ${projectCwd}
+const PATH_OVERRIDES = ${serializedOverrides}
+
+let cachedFetchHandlerPromise
+
+async function getFetchHandler(options = {}) {
+  if (!cachedFetchHandlerPromise) {
+    cachedFetchHandlerPromise = createProductionFetchHandler({
+      cwd: PROJECT_CWD,
+      pathOverrides: PATH_OVERRIDES,
+      ...options,
+    })
+  }
+
+  return cachedFetchHandlerPromise
+}
+
+export async function handleRequest(request, runtimeContext = {}, options = {}) {
+  const handler = await getFetchHandler(options)
+  const server = typeof runtimeContext?.requestIP === "function"
+    ? { requestIP: (input) => runtimeContext.requestIP(input) }
+    : undefined
+  return handler(request, server)
+}
+`;
+}
+function createServerHandlerNodeEntrySource(cwd, pathOverrides) {
+  const prodModule = JSON.stringify(resolveFrameworkModule("prod")), projectCwd = JSON.stringify(cwd), serializedOverrides = JSON.stringify(pathOverrides, null, 2);
+  return `import { createProductionFetchHandler } from ${prodModule}
+
+const PROJECT_CWD = ${projectCwd}
+const PATH_OVERRIDES = ${serializedOverrides}
+
+let cachedFetchHandlerPromise
+
+async function getFetchHandler(options = {}) {
+  if (!cachedFetchHandlerPromise) {
+    cachedFetchHandlerPromise = createProductionFetchHandler({
+      cwd: PROJECT_CWD,
+      pathOverrides: PATH_OVERRIDES,
+      ...options,
+    })
+  }
+
+  return cachedFetchHandlerPromise
+}
+
+export async function handleRequest(request, runtimeContext = {}, options = {}) {
+  const handler = await getFetchHandler(options)
+  const server = typeof runtimeContext?.requestIP === "function"
+    ? { requestIP: (input) => runtimeContext.requestIP(input) }
+    : undefined
+  return handler(request, server)
+}
+`;
+}
+function createWorkerEntrySource(serverHandlerEntry) {
+  return `import { handleRequest } from ${JSON.stringify(serverHandlerEntry)}
+
+export default {
+  async fetch(request, env, ctx) {
+    void ctx
+    return handleRequest(request, env)
+  },
+}
+`;
+}
+function dirnameOf(path) {
+  const index = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  return index >= 0 ? path.slice(0, index) : ".";
+}
+function replaceExtension(path, extension) {
+  return path.replace(/\.[^.]+$/, extension);
+}
+const SERVER_APP_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs"]), SERVER_APP_IGNORED_DIRS = new Set([".git", ".gorsee", "dist", "node_modules", "public"]);
+async function compileServerAppForNode(cwd, outdir) {
+  await rm(outdir, { recursive: !0, force: !0 });
+  await mkdir(outdir, { recursive: !0 });
+  const entrypoints = await collectServerAppEntrypoints(cwd);
+  if (entrypoints.length === 0)
+    return;
+  for (const entrypoint of entrypoints) {
+    const rel = relative(cwd, entrypoint), source = await readFile(entrypoint, "utf-8"), rewritten = rewriteServerRuntimeSpecifiers(source, entrypoint), targetPath = join(outdir, replaceExtension(rel, ".js"));
+    await mkdir(dirnameOf(targetPath), { recursive: !0 });
+    await writeFile(targetPath, transpileServerRuntimeSource(entrypoint, rewritten), "utf-8");
+  }
+}
+async function collectServerAppEntrypoints(root, dir = root) {
+  const entries = await readdir(dir, { withFileTypes: !0 }).catch(() => []), files = [];
+  for (const entry of entries) {
+    if (SERVER_APP_IGNORED_DIRS.has(entry.name))
+      continue;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectServerAppEntrypoints(root, fullPath));
+      continue;
+    }
+    const extIndex = entry.name.lastIndexOf("."), ext = extIndex >= 0 ? entry.name.slice(extIndex) : "";
+    if (!SERVER_APP_EXTENSIONS.has(ext))
+      continue;
+    const rel = relative(root, fullPath);
+    if (rel.startsWith("tests/") || rel.startsWith("examples/") || rel.startsWith("benchmarks/"))
+      continue;
+    files.push(fullPath);
+  }
+  return files.sort((left, right) => left.localeCompare(right));
+}
+function transpileServerRuntimeSource(path, source) {
+  if (path.endsWith(".tsx") || path.endsWith(".ts"))
+    return ts.transpileModule(source, {
+      fileName: path,
+      compilerOptions: {
+        module: ts.ModuleKind.ESNext,
+        target: ts.ScriptTarget.ES2022,
+        jsx: path.endsWith(".tsx") ? ts.JsxEmit.ReactJSX : void 0,
+        jsxImportSource: path.endsWith(".tsx") ? "gorsee" : void 0
+      }
+    }).outputText;
+  return source;
+}
+function rewriteServerRuntimeSpecifiers(source, filePath) {
+  return source.replace(/((?:from\s*|import\s*\()\s*["'])(\.\.?\/[^"']+?)(["'])/g, (full, prefix, specifier, suffix) => {
+    const rewritten = resolveServerRuntimeSpecifier(filePath, specifier);
+    return `${prefix}${rewritten}${suffix}`;
+  });
+}
+function resolveServerRuntimeSpecifier(filePath, specifier) {
+  if (!specifier.startsWith("."))
+    return specifier;
+  if (/\.(?:css|json|svg|png|jpg|jpeg|gif|webp|woff2?)$/.test(specifier))
+    return specifier;
+  if (/\.(?:[cm]?js|jsx|[cm]?ts|tsx)$/.test(specifier))
+    return specifier.replace(/\.(?:[cm]?js|jsx|[cm]?ts|tsx)$/, ".js");
+  const resolvedBase = resolve(dirnameOf(filePath), specifier);
+  for (const ext of [".ts", ".tsx", ".js", ".jsx", ".mjs"])
+    if (existsSync(`${resolvedBase}${ext}`))
+      return `${specifier}.js`;
+  for (const ext of [".ts", ".tsx", ".js", ".jsx", ".mjs"])
+    if (existsSync(join(resolvedBase, `index${ext}`)))
+      return `${specifier}/index.js`;
+  return specifier;
+}

package/dist-pkg/build/server-strip.d.ts

@@ -0,0 +1,2 @@
+import type { BunPlugin } from "bun";
+export declare const serverStripPlugin: BunPlugin;

package/dist-pkg/build/server-strip.js

@@ -0,0 +1,32 @@
+import {
+  SERVER_ONLY_MODULES,
+  SERVER_STUB_MODULES,
+  applyRouteClientTransforms
+} from "./route-client-transform.js";
+export const serverStripPlugin = {
+  name: "gorsee-server-strip",
+  setup(build) {
+    for (const mod of SERVER_ONLY_MODULES)
+      build.onResolve({ filter: new RegExp(`^${mod.replace("/", "\\/")}$`) }, () => ({
+        path: mod,
+        namespace: "gorsee-empty"
+      }));
+    build.onLoad({ filter: /.*/, namespace: "gorsee-empty" }, () => ({
+      contents: "export default {}",
+      loader: "js"
+    }));
+    for (const mod of Object.keys(SERVER_STUB_MODULES))
+      build.onResolve({ filter: new RegExp(`^${mod.replace("/", "\\/")}$`) }, () => ({
+        path: mod,
+        namespace: "gorsee-stub"
+      }));
+    build.onLoad({ filter: /.*/, namespace: "gorsee-stub" }, (args) => ({
+      contents: SERVER_STUB_MODULES[args.path] ?? "export default {}",
+      loader: "js"
+    }));
+    build.onLoad({ filter: /routes\/.*\.tsx?$/ }, async (args) => {
+      const source = await Bun.file(args.path).text();
+      return { contents: applyRouteClientTransforms(source, args.path).source, loader: args.path.endsWith(".tsx") ? "tsx" : "ts" };
+    });
+  }
+};

package/dist-pkg/build/ssg.d.ts

@@ -0,0 +1,12 @@
+import { type HTMLWrapOptions } from "../server/html-shell.js";
+export interface SSGResult {
+    pages: Map<string, string>;
+    errors: string[];
+}
+interface SSGOptions {
+    routesDir: string;
+    outDir: string;
+    wrapHTML?: (body: string, options?: HTMLWrapOptions) => string;
+}
+export declare function generateStaticPages(options: SSGOptions): Promise<SSGResult>;
+export {};

package/dist-pkg/build/ssg.js

@@ -0,0 +1,36 @@
+import { createRouter } from "../router/scanner.js";
+import { createContext } from "../server/middleware.js";
+import { renderPageDocument, resolvePageRoute } from "../server/page-render.js";
+import { wrapHTML } from "../server/html-shell.js";
+import { join } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+export async function generateStaticPages(options) {
+  const { routesDir, outDir, wrapHTML } = options, routes = await createRouter(routesDir), pages = new Map, errors = [];
+  for (const route of routes) {
+    if (route.isDynamic)
+      continue;
+    try {
+      const mod = await import(route.filePath);
+      if (!mod.prerender)
+        continue;
+      const fakeRequest = new Request(`http://localhost${route.path}`), ctx = createContext(fakeRequest, {}), resolved = await resolvePageRoute(mod, { route, params: {} }, ctx);
+      if (!resolved)
+        continue;
+      const rendered = renderPageDocument(resolved.pageComponent, ctx, {}, resolved.loaderData), html = (wrapHTML ?? defaultWrapHTML)(rendered.html, {
+        title: rendered.title,
+        loaderData: resolved.loaderData,
+        headElements: rendered.headElements,
+        cssFiles: resolved.cssFiles
+      }), outPath = route.path === "/" ? join(outDir, "index.html") : join(outDir, route.path, "index.html");
+      await mkdir(join(outPath, ".."), { recursive: !0 });
+      await writeFile(outPath, html);
+      pages.set(route.path, outPath);
+    } catch (err) {
+      errors.push(`${route.path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { pages, errors };
+}
+function defaultWrapHTML(body, options = {}) {
+  return wrapHTML(body, void 0, options);
+}

package/dist-pkg/cli/bun-plugin.d.ts

@@ -0,0 +1,2 @@
+import { resolveFrameworkImport as resolveFrameworkImportImpl } from "../build/framework-imports.js";
+export declare const resolveFrameworkImport: typeof resolveFrameworkImportImpl;

package/dist-pkg/cli/bun-plugin.js

@@ -0,0 +1,14 @@
+import { plugin } from "bun";
+import { resolveFrameworkImport as resolveFrameworkImportImpl } from "../build/framework-imports.js";
+export const resolveFrameworkImport = resolveFrameworkImportImpl;
+plugin({
+  name: "gorsee-resolve",
+  setup(build) {
+    build.onResolve({ filter: /^gorsee(\/.*)?$/ }, (args) => {
+      const mapped = resolveFrameworkImport(args.path);
+      if (mapped)
+        return { path: mapped };
+      return;
+    });
+  }
+});

package/dist-pkg/cli/canonical-import-rewrite.d.ts

@@ -0,0 +1,18 @@
+export interface CanonicalRewriteResult {
+    changed: boolean;
+    source: string;
+}
+export interface CanonicalRewriteReport {
+    changedFiles: string[];
+}
+export interface LoaderRewriteResult {
+    changed: boolean;
+    source: string;
+}
+export interface LoaderRewriteReport {
+    changedFiles: string[];
+}
+export declare function rewriteCanonicalImports(source: string): CanonicalRewriteResult;
+export declare function rewriteCanonicalImportsInProject(cwd: string): Promise<CanonicalRewriteReport>;
+export declare function rewriteLegacyLoaders(source: string): LoaderRewriteResult;
+export declare function rewriteLegacyLoadersInProject(cwd: string): Promise<LoaderRewriteReport>;

package/dist-pkg/cli/canonical-import-rewrite.js

@@ -0,0 +1,94 @@
+import { readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { CLIENT_SCOPED_IMPORTS, SERVER_SCOPED_IMPORTS } from "./canonical-imports.js";
+const IMPORT_RE = /import\s*\{([\s\S]*?)\}\s*from\s*(["'])(gorsee\/(?:server|client))\2/g;
+export function rewriteCanonicalImports(source) {
+  let changed = !1;
+  const rewritten = source.replace(IMPORT_RE, (statement, bindings, _quote, specifier) => {
+    const scopedMap = specifier === "gorsee/server" ? SERVER_SCOPED_IMPORTS : CLIENT_SCOPED_IMPORTS, parsed = parseBindings(bindings), kept = [], moved = new Map;
+    for (const binding of parsed) {
+      const target = scopedMap.get(binding.importedName);
+      if (!target) {
+        kept.push(binding.raw);
+        continue;
+      }
+      const bucket = moved.get(target) ?? [];
+      bucket.push(binding.raw);
+      moved.set(target, bucket);
+    }
+    if (moved.size === 0)
+      return statement;
+    changed = !0;
+    const rewrittenImports = [];
+    if (kept.length > 0)
+      rewrittenImports.push(renderImport(specifier, kept));
+    for (const target of [...moved.keys()].sort())
+      rewrittenImports.push(renderImport(target, moved.get(target) ?? []));
+    return rewrittenImports.join(`
+`);
+  });
+  return { changed, source: rewritten };
+}
+export async function rewriteCanonicalImportsInProject(cwd) {
+  const sourceFiles = [
+    ...await getAllSourceFiles(cwd, "routes"),
+    ...await getAllSourceFiles(cwd, "shared"),
+    ...await getAllSourceFiles(cwd, "middleware")
+  ], changedFiles = [];
+  for (const file of sourceFiles) {
+    const source = await readFile(file, "utf-8"), rewritten = rewriteCanonicalImports(source);
+    if (!rewritten.changed || rewritten.source === source)
+      continue;
+    await writeFile(file, rewritten.source, "utf-8");
+    changedFiles.push(relative(cwd, file));
+  }
+  changedFiles.sort();
+  return { changedFiles };
+}
+export function rewriteLegacyLoaders(source) {
+  const rewritten = source.replace(/\bexport\s+async\s+function\s+loader\b/g, "export async function load").replace(/\bexport\s+function\s+loader\b/g, "export function load").replace(/\bexport\s+const\s+loader\b/g, "export const load");
+  return { changed: rewritten !== source, source: rewritten };
+}
+export async function rewriteLegacyLoadersInProject(cwd) {
+  const sourceFiles = [
+    ...await getAllSourceFiles(cwd, "routes"),
+    ...await getAllSourceFiles(cwd, "shared"),
+    ...await getAllSourceFiles(cwd, "middleware")
+  ], changedFiles = [];
+  for (const file of sourceFiles) {
+    const source = await readFile(file, "utf-8"), rewritten = rewriteLegacyLoaders(source);
+    if (!rewritten.changed || rewritten.source === source)
+      continue;
+    await writeFile(file, rewritten.source, "utf-8");
+    changedFiles.push(relative(cwd, file));
+  }
+  changedFiles.sort();
+  return { changedFiles };
+}
+async function getAllSourceFiles(cwd, dir) {
+  const path = join(cwd, dir);
+  try {
+    const entries = await readdir(path), files = [];
+    for (const entry of entries) {
+      if (entry === "node_modules" || entry === "dist" || entry === ".git")
+        continue;
+      const fullPath = join(path, entry);
+      if ((await stat(fullPath)).isDirectory())
+        files.push(...await getAllSourceFiles(cwd, relative(cwd, fullPath)));
+      else if (entry.endsWith(".ts") || entry.endsWith(".tsx"))
+        files.push(fullPath);
+    }
+    return files;
+  } catch {
+    return [];
+  }
+}
+function renderImport(specifier, bindings) {
+  return `import { ${bindings.join(", ")} } from "${specifier}"`;
+}
+function parseBindings(bindings) {
+  return bindings.split(",").map((entry) => entry.trim()).filter(Boolean).map((raw) => {
+    const importedName = (raw.startsWith("type ") ? raw.slice(5).trim() : raw).split(/\s+as\s+/)[0].trim();
+    return { raw, importedName };
+  });
+}

package/dist-pkg/cli/canonical-imports.d.ts

@@ -0,0 +1,8 @@
+import type { ModuleImportFact } from "../compiler/module-analysis.js";
+export declare const SERVER_SCOPED_IMPORTS: Map<string, string>;
+export declare const CLIENT_SCOPED_IMPORTS: Map<string, string>;
+export interface CanonicalImportDrift {
+    source: "gorsee/server" | "gorsee/client";
+    replacements: Map<string, string>;
+}
+export declare function collectCanonicalImportDrift(imports: ModuleImportFact[]): CanonicalImportDrift[];