gorsee 0.2.4 → 0.2.6

package/dist-pkg/build/client-backend.d.ts

@@ -0,0 +1,31 @@
+import { type FrameworkBuildPlugin } from "./plugin.js";
+import { type ClientBuildLog } from "./diagnostics.js";
+export type ClientBuildPlugin = FrameworkBuildPlugin;
+export interface ClientBuildBackendOptions {
+    entrypoints: string[];
+    outdir: string;
+    minify: boolean;
+    sourcemap: boolean;
+    frameworkResolve(specifier: string): string | undefined;
+    plugins: ClientBuildPlugin[];
+}
+export interface ClientBuildBackendResult {
+    success: boolean;
+    logs: ClientBuildLog[];
+}
+export interface ClientBuildBackend {
+    name: string;
+    build(options: ClientBuildBackendOptions): Promise<ClientBuildBackendResult>;
+}
+export declare const GORSEE_BUILD_BACKEND_ENV = "GORSEE_BUILD_BACKEND";
+export declare function createBunClientBuildBackend(): ClientBuildBackend;
+export declare function getClientBuildBackend(): ClientBuildBackend;
+export declare function setClientBuildBackend(backend: ClientBuildBackend): void;
+export declare function resetClientBuildBackend(): void;
+export declare function registerClientBuildBackend(backend: ClientBuildBackend): void;
+export declare function unregisterClientBuildBackend(name: string): void;
+export declare function listClientBuildBackends(): string[];
+export declare function selectClientBuildBackend(name: string): ClientBuildBackend;
+export declare function resolveClientBuildBackendName(env?: NodeJS.ProcessEnv): string;
+export declare function configureClientBuildBackend(env?: NodeJS.ProcessEnv): ClientBuildBackend;
+export type { ClientBuildLog };

package/dist-pkg/build/client-backend.js

@@ -0,0 +1,97 @@
+import { createRolldownClientBuildBackend } from "./backends/rolldown.js";
+import { resolveBuildPluginsForTarget } from "./plugin.js";
+import { normalizeClientBuildLog } from "./diagnostics.js";
+export const GORSEE_BUILD_BACKEND_ENV = "GORSEE_BUILD_BACKEND";
+const internalBunFallback = createBunClientBuildBackend(), stableRolldownBackend = createRolldownClientBuildBackend({ fallback: internalBunFallback }), clientBuildBackends = new Map([
+  [internalBunFallback.name, internalBunFallback],
+  [stableRolldownBackend.name, stableRolldownBackend]
+]);
+export function createBunClientBuildBackend() {
+  return {
+    name: "bun",
+    async build(options) {
+      const result = await Bun.build({
+        entrypoints: options.entrypoints,
+        outdir: options.outdir,
+        target: "browser",
+        format: "esm",
+        minify: options.minify,
+        sourcemap: options.sourcemap ? "external" : "none",
+        splitting: !0,
+        jsx: {
+          runtime: "automatic",
+          importSource: "gorsee",
+          development: !0
+        },
+        plugins: [
+          {
+            name: "gorsee-client-resolve",
+            setup(build) {
+              build.onResolve({ filter: /^gorsee:route:/ }, (args) => ({
+                path: args.path.slice(13)
+              }));
+              build.onResolve({ filter: /^gorsee(\/.*)?$/ }, (args) => {
+                const mapped = options.frameworkResolve(args.path);
+                if (mapped)
+                  return { path: mapped };
+                return;
+              });
+            }
+          },
+          ...resolveBuildPluginsForTarget(options.plugins, "bun")
+        ]
+      });
+      return {
+        success: result.success,
+        logs: result.logs.map((log) => normalizeClientBuildLog({
+          message: log.message
+        }, {
+          backend: "bun",
+          phase: "bundle",
+          severity: "error",
+          code: "BUN_BUILD_FAILURE"
+        }))
+      };
+    }
+  };
+}
+let defaultClientBuildBackend = stableRolldownBackend;
+export function getClientBuildBackend() {
+  return defaultClientBuildBackend;
+}
+export function setClientBuildBackend(backend) {
+  clientBuildBackends.set(backend.name, backend);
+  defaultClientBuildBackend = backend;
+}
+export function resetClientBuildBackend() {
+  clientBuildBackends.clear();
+  clientBuildBackends.set(internalBunFallback.name, internalBunFallback);
+  clientBuildBackends.set(stableRolldownBackend.name, stableRolldownBackend);
+  defaultClientBuildBackend = stableRolldownBackend;
+}
+export function registerClientBuildBackend(backend) {
+  clientBuildBackends.set(backend.name, backend);
+}
+export function unregisterClientBuildBackend(name) {
+  if (name === stableRolldownBackend.name)
+    return;
+  clientBuildBackends.delete(name);
+  if (defaultClientBuildBackend.name === name)
+    defaultClientBuildBackend = stableRolldownBackend;
+}
+export function listClientBuildBackends() {
+  return [...clientBuildBackends.keys()].sort();
+}
+export function selectClientBuildBackend(name) {
+  const backend = clientBuildBackends.get(name);
+  if (!backend)
+    throw Error(`Unknown client build backend "${name}". Registered backends: ${listClientBuildBackends().join(", ")}`);
+  defaultClientBuildBackend = backend;
+  return backend;
+}
+export function resolveClientBuildBackendName(env = process.env) {
+  return env[GORSEE_BUILD_BACKEND_ENV]?.trim() || stableRolldownBackend.name;
+}
+export function configureClientBuildBackend(env = process.env) {
+  return selectClientBuildBackend(resolveClientBuildBackendName(env));
+}

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

@@ -0,0 +1,12 @@
+import { type ClientBuildBackend } from "./client-backend.js";
+import type { Route } from "../router/scanner.js";
+export interface BuildResult {
+    entryMap: Map<string, string>;
+    cssModules?: string;
+}
+export interface BuildOptions {
+    minify?: boolean;
+    sourcemap?: boolean;
+    backend?: ClientBuildBackend;
+}
+export declare function buildClientBundles(routes: Route[], cwd: string, options?: BuildOptions): Promise<BuildResult>;

package/dist-pkg/build/client.js

@@ -0,0 +1,93 @@
+import { join, relative } from "node:path";
+import { mkdir, rm } from "node:fs/promises";
+import { serverStripPlugin } from "./server-strip.js";
+import { cssModulesPlugin, getCollectedCSS, resetCollectedCSS } from "./css-modules.js";
+import { getClientBuildBackend } from "./client-backend.js";
+import { defineBuildPlugin } from "./plugin.js";
+import { formatClientBuildLog, normalizeClientBuildLog, summarizeClientBuildFailure } from "./diagnostics.js";
+import { resolveClientFrameworkImport } from "./framework-imports.js";
+function routeToEntryName(route, cwd) {
+  return relative(join(cwd, "routes"), route.filePath).replace(/\.(tsx?|jsx?)$/, "").replace(/[\[\]]/g, "_");
+}
+function generateEntryCode(route) {
+  const layoutImports = route.layoutPaths.map((layoutPath, index) => `import Layout${index} from "gorsee:route:${layoutPath}";`).join(`
+`), composeLayouts = route.layoutPaths.length > 0 ? `
+function composeComponentTree(props) {
+  let tree = () => Component(props);
+  ${route.layoutPaths.map((_, index) => index).reverse().map((index) => `if (typeof Layout${index} === "function") {
+    const inner = tree;
+    tree = () => Layout${index}({ ...props, data: undefined, children: inner });
+  }`).join(`
+  `)}
+  return tree();
+}
+` : `
+function composeComponentTree(props) {
+  return Component(props);
+}
+`;
+  return `
+import Component from "gorsee:route:${route.filePath}";
+${layoutImports}
+import { hydrate, initRouter } from "gorsee/runtime";
+${composeLayouts}
+export default composeComponentTree;
+
+if (!globalThis.__GORSEE_SUPPRESS_ENTRY_BOOTSTRAP__) {
+  globalThis.__GORSEE_ROUTE_SCRIPT__ = new URL(import.meta.url).pathname;
+  var container = document.getElementById("app");
+  var dataEl = document.getElementById("__GORSEE_DATA__");
+  var data = dataEl ? JSON.parse(dataEl.textContent) : {};
+  var params = window.__GORSEE_PARAMS__ || {};
+  hydrate(function() { return composeComponentTree({ data: data, params: params }); }, container);
+  initRouter();
+}
+`;
+}
+export async function buildClientBundles(routes, cwd, options) {
+  const outDir = join(cwd, ".gorsee", "client");
+  await rm(outDir, { recursive: !0, force: !0 });
+  await mkdir(outDir, { recursive: !0 });
+  const entryDir = join(cwd, ".gorsee", "entries");
+  await rm(entryDir, { recursive: !0, force: !0 });
+  await mkdir(entryDir, { recursive: !0 });
+  const entryMap = new Map, pageRoutes = routes.filter((r) => !r.filePath.includes("/api/"));
+  if (pageRoutes.length === 0)
+    return { entryMap };
+  resetCollectedCSS();
+  const entrypoints = [], backend = options?.backend ?? getClientBuildBackend();
+  for (const route of pageRoutes) {
+    const name = routeToEntryName(route, cwd), entryPath = join(entryDir, `${name}.ts`), code = generateEntryCode(route);
+    await Bun.write(entryPath, code);
+    entrypoints.push(entryPath);
+    entryMap.set(route.path, `${name}.js`);
+  }
+  const result = await backend.build({
+    entrypoints,
+    outdir: outDir,
+    minify: options?.minify ?? !1,
+    sourcemap: options?.sourcemap ?? !1,
+    frameworkResolve: resolveClientFrameworkImport,
+    plugins: [
+      defineBuildPlugin({ name: serverStripPlugin.name, bun: serverStripPlugin }),
+      defineBuildPlugin({ name: cssModulesPlugin.name, bun: cssModulesPlugin })
+    ]
+  });
+  if (!result.success) {
+    const diagnostics = (result.logs.length > 0 ? result.logs : [{
+      message: "backend reported unsuccessful result without diagnostics"
+    }]).map((log) => normalizeClientBuildLog(log, {
+      backend: backend.name,
+      phase: "bundle",
+      severity: "error",
+      code: "BUILD_BACKEND_FAILURE"
+    }));
+    for (const log of diagnostics)
+      console.error("[build]", formatClientBuildLog(log));
+    throw Error(summarizeClientBuildFailure(backend.name, diagnostics));
+  }
+  const cssModules = getCollectedCSS();
+  if (cssModules)
+    await Bun.write(join(outDir, "modules.css"), cssModules);
+  return { entryMap, cssModules };
+}

package/dist-pkg/build/css-modules.d.ts

@@ -0,0 +1,10 @@
+import type { BunPlugin } from "bun";
+export declare function transformCssModuleSource(filePath: string, source: string): {
+    css: string;
+    classMap: Record<string, string>;
+};
+export declare function getCollectedCSS(): string;
+export declare function resetCollectedCSS(): void;
+export declare function collectCssModule(css: string): void;
+export declare function renderCssModuleExports(classMap: Record<string, string>): string;
+export declare const cssModulesPlugin: BunPlugin;

package/dist-pkg/build/css-modules.js

@@ -0,0 +1,51 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { basename, join, dirname } from "node:path";
+function hashClassName(filePath, className) {
+  const hash = createHash("md5").update(filePath + className).digest("hex").slice(0, 5);
+  return `${basename(filePath, ".module.css")}_${className}_${hash}`;
+}
+export function transformCssModuleSource(filePath, source) {
+  const classMap = {};
+  return { css: source.replace(/\.([a-zA-Z_][\w-]*)/g, (match, className) => {
+    if (match.startsWith("::") || match.startsWith(":."))
+      return match;
+    const scoped = hashClassName(filePath, className);
+    classMap[className] = scoped;
+    return `.${scoped}`;
+  }), classMap };
+}
+const collectedCSS = [];
+export function getCollectedCSS() {
+  return collectedCSS.join(`
+`);
+}
+export function resetCollectedCSS() {
+  collectedCSS.length = 0;
+}
+export function collectCssModule(css) {
+  collectedCSS.push(css);
+}
+export function renderCssModuleExports(classMap) {
+  return `export default {
+${Object.entries(classMap).map(([k, v]) => `  "${k}": "${v}"`).join(`,
+`)}
+};`;
+}
+export const cssModulesPlugin = {
+  name: "gorsee-css-modules",
+  setup(build) {
+    build.onResolve({ filter: /\.module\.css$/ }, (args) => ({
+      path: join(dirname(args.importer), args.path),
+      namespace: "css-module"
+    }));
+    build.onLoad({ filter: /.*/, namespace: "css-module" }, async (args) => {
+      const source = await readFile(args.path, "utf-8"), { css, classMap } = transformCssModuleSource(args.path, source);
+      collectCssModule(css);
+      return {
+        contents: renderCssModuleExports(classMap),
+        loader: "js"
+      };
+    });
+  }
+};

package/dist-pkg/build/devalue-parse.d.ts

@@ -0,0 +1 @@
+export { parse } from "devalue";

package/dist-pkg/build/devalue-parse.js

@@ -0,0 +1 @@
+export { parse } from "devalue";

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

@@ -0,0 +1,20 @@
+export type ClientBuildDiagnosticSeverity = "info" | "warn" | "error";
+export type ClientBuildDiagnosticPhase = "resolve" | "load" | "transform" | "bundle" | "emit";
+export interface ClientBuildLog {
+    message: string;
+    backend?: string;
+    phase?: ClientBuildDiagnosticPhase;
+    severity?: ClientBuildDiagnosticSeverity;
+    code?: string;
+    file?: string;
+    plugin?: string;
+    detail?: string;
+}
+export declare function normalizeClientBuildLog(log: ClientBuildLog, defaults: {
+    backend: string;
+    phase?: ClientBuildDiagnosticPhase;
+    severity?: ClientBuildDiagnosticSeverity;
+    code?: string;
+}): ClientBuildLog;
+export declare function formatClientBuildLog(log: ClientBuildLog): string;
+export declare function summarizeClientBuildFailure(backend: string, logs: ClientBuildLog[]): string;

package/dist-pkg/build/diagnostics.js

@@ -0,0 +1,35 @@
+export function normalizeClientBuildLog(log, defaults) {
+  return {
+    ...log,
+    backend: log.backend ?? defaults.backend,
+    phase: log.phase ?? defaults.phase ?? "bundle",
+    severity: log.severity ?? defaults.severity ?? "error",
+    code: log.code ?? defaults.code ?? "BUILD_BACKEND_FAILURE"
+  };
+}
+export function formatClientBuildLog(log) {
+  const parts = [
+    `backend=${log.backend ?? "unknown"}`,
+    `phase=${log.phase ?? "bundle"}`,
+    `severity=${log.severity ?? "error"}`
+  ];
+  if (log.code)
+    parts.push(`code=${log.code}`);
+  if (log.file)
+    parts.push(`file=${log.file}`);
+  if (log.plugin)
+    parts.push(`plugin=${log.plugin}`);
+  let line = `[${parts.join(" ")}] ${log.message}`;
+  if (log.detail)
+    line += ` | ${log.detail}`;
+  return line;
+}
+export function summarizeClientBuildFailure(backend, logs) {
+  const primary = logs[0];
+  if (!primary)
+    return `Client build failed in backend "${backend}" without diagnostics`;
+  const formatted = formatClientBuildLog(primary);
+  if (logs.length === 1)
+    return `Client build failed: ${formatted}`;
+  return `Client build failed: ${formatted} (${logs.length - 1} more diagnostic(s))`;
+}

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

@@ -0,0 +1,7 @@
+import type { ClientBuildBackendOptions } from "./client-backend.js";
+export interface ClientBuildParityFixture {
+    name: string;
+    options: ClientBuildBackendOptions;
+}
+export declare function createClientBuildFixtures(rootDir?: string): ClientBuildParityFixture[];
+export declare const CLIENT_BUILD_FIXTURES: ClientBuildParityFixture[];

package/dist-pkg/build/fixtures.js

@@ -0,0 +1,60 @@
+export function createClientBuildFixtures(rootDir = ".tmp-build-backend-parity") {
+  return [
+    {
+      name: "plain-entry",
+      options: {
+        entrypoints: [`${rootDir}/plain-entry.ts`],
+        outdir: `${rootDir}/dist-plain`,
+        minify: !1,
+        sourcemap: !1,
+        frameworkResolve() {
+          return;
+        },
+        plugins: []
+      }
+    },
+    {
+      name: "minified-entry",
+      options: {
+        entrypoints: [`${rootDir}/minified-entry.ts`],
+        outdir: `${rootDir}/dist-minified`,
+        minify: !0,
+        sourcemap: !1,
+        frameworkResolve() {
+          return;
+        },
+        plugins: []
+      }
+    },
+    {
+      name: "multi-entry",
+      options: {
+        entrypoints: [
+          `${rootDir}/multi-a.ts`,
+          `${rootDir}/multi-b.ts`
+        ],
+        outdir: `${rootDir}/dist-multi`,
+        minify: !1,
+        sourcemap: !1,
+        frameworkResolve() {
+          return;
+        },
+        plugins: []
+      }
+    },
+    {
+      name: "sourcemap-entry",
+      options: {
+        entrypoints: [`${rootDir}/sourcemap-entry.ts`],
+        outdir: `${rootDir}/dist-sourcemap`,
+        minify: !1,
+        sourcemap: !0,
+        frameworkResolve() {
+          return;
+        },
+        plugins: []
+      }
+    }
+  ];
+}
+export const CLIENT_BUILD_FIXTURES = createClientBuildFixtures();

package/dist-pkg/build/framework-imports.d.ts

@@ -0,0 +1,4 @@
+export declare const FRAMEWORK_IMPORT_MAP: Record<string, string>;
+export declare const CLIENT_FRAMEWORK_IMPORT_MAP: Record<string, string>;
+export declare function resolveFrameworkImport(specifier: string): string | undefined;
+export declare function resolveClientFrameworkImport(specifier: string): string | undefined;

package/dist-pkg/build/framework-imports.js

@@ -0,0 +1,58 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+const FRAMEWORK_ROOT = resolve(import.meta.dir, "..");
+function resolveFrameworkModule(stem) {
+  const tsPath = resolve(FRAMEWORK_ROOT, `${stem}.ts`);
+  if (existsSync(tsPath))
+    return tsPath;
+  const jsPath = resolve(FRAMEWORK_ROOT, `${stem}.js`);
+  if (existsSync(jsPath))
+    return jsPath;
+  return tsPath;
+}
+const CLIENT_JSX_RUNTIME = resolveFrameworkModule("jsx-runtime-client"), SERVER_JSX_RUNTIME = resolveFrameworkModule("jsx-runtime");
+export const FRAMEWORK_IMPORT_MAP = {
+  gorsee: resolveFrameworkModule("index"),
+  "gorsee/compat": resolveFrameworkModule("compat"),
+  "gorsee/client": resolveFrameworkModule("client"),
+  "gorsee/reactive": resolveFrameworkModule("reactive/index"),
+  "gorsee/server": resolveFrameworkModule("server-entry"),
+  "gorsee/types": resolveFrameworkModule("types/index"),
+  "gorsee/db": resolveFrameworkModule("db/index"),
+  "gorsee/router": resolveFrameworkModule("router/index"),
+  "gorsee/log": resolveFrameworkModule("log/index"),
+  "gorsee/unsafe": resolveFrameworkModule("unsafe/index"),
+  "gorsee/runtime": resolveFrameworkModule("runtime/index"),
+  "gorsee/security": resolveFrameworkModule("security/index"),
+  "gorsee/ai": resolveFrameworkModule("ai/index"),
+  "gorsee/jsx-runtime": SERVER_JSX_RUNTIME,
+  "gorsee/jsx-dev-runtime": SERVER_JSX_RUNTIME,
+  "gorsee/testing": resolveFrameworkModule("testing/index"),
+  "gorsee/i18n": resolveFrameworkModule("i18n/index"),
+  "gorsee/content": resolveFrameworkModule("content/index"),
+  "gorsee/env": resolveFrameworkModule("env/index"),
+  "gorsee/auth": resolveFrameworkModule("auth/index"),
+  "gorsee/forms": resolveFrameworkModule("forms/index"),
+  "gorsee/routes": resolveFrameworkModule("routes/index"),
+  "gorsee/cli/cmd-create": resolveFrameworkModule("cli/cmd-create"),
+  "gorsee/plugins": resolveFrameworkModule("plugins/index"),
+  "gorsee/plugins/drizzle": resolveFrameworkModule("plugins/drizzle"),
+  "gorsee/plugins/prisma": resolveFrameworkModule("plugins/prisma"),
+  "gorsee/plugins/tailwind": resolveFrameworkModule("plugins/tailwind"),
+  "gorsee/plugins/lucia": resolveFrameworkModule("plugins/lucia"),
+  "gorsee/plugins/s3": resolveFrameworkModule("plugins/s3"),
+  "gorsee/plugins/resend": resolveFrameworkModule("plugins/resend"),
+  "gorsee/plugins/stripe": resolveFrameworkModule("plugins/stripe"),
+  "gorsee/deploy": resolveFrameworkModule("deploy/index")
+}, CLIENT_FRAMEWORK_IMPORT_MAP = {
+  ...FRAMEWORK_IMPORT_MAP,
+  gorsee: resolveFrameworkModule("index-client"),
+  "gorsee/jsx-runtime": CLIENT_JSX_RUNTIME,
+  "gorsee/jsx-dev-runtime": CLIENT_JSX_RUNTIME
+};
+export function resolveFrameworkImport(specifier) {
+  return FRAMEWORK_IMPORT_MAP[specifier];
+}
+export function resolveClientFrameworkImport(specifier) {
+  return CLIENT_FRAMEWORK_IMPORT_MAP[specifier];
+}

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

@@ -0,0 +1 @@
+export declare function initializeBuildBackends(env?: NodeJS.ProcessEnv): import("./client-backend.js").ClientBuildBackend;

package/dist-pkg/build/init.js

@@ -0,0 +1,6 @@
+import { registerBuiltInBuildBackends } from "./backends/register.js";
+import { configureClientBuildBackend } from "./client-backend.js";
+export function initializeBuildBackends(env = process.env) {
+  registerBuiltInBuildBackends({ includeExperimentalRolldown: !0, includeRolldown: !0 });
+  return configureClientBuildBackend(env);
+}

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

@@ -0,0 +1,3 @@
+import type { Route } from "../router/scanner.js";
+import { type BuildManifest } from "../server/manifest.js";
+export declare function createBuildManifest(routes: Route[], entryMap: Map<string, string>, hashMap: Map<string, string>, prerenderedPaths?: Iterable<string>): Promise<BuildManifest>;

package/dist-pkg/build/manifest.js

@@ -0,0 +1,23 @@
+import { inspectRouteBuildMetadata } from "./route-metadata.js";
+import { BUILD_MANIFEST_SCHEMA_VERSION } from "../server/manifest.js";
+export async function createBuildManifest(routes, entryMap, hashMap, prerenderedPaths = []) {
+  const prerendered = new Set(prerenderedPaths), manifest = {
+    schemaVersion: BUILD_MANIFEST_SCHEMA_VERSION,
+    routes: {},
+    chunks: [],
+    prerendered: [...prerendered],
+    buildTime: new Date().toISOString()
+  };
+  for (const route of routes) {
+    const metadata = await inspectRouteBuildMetadata(route), jsRel = entryMap.get(route.path);
+    manifest.routes[route.path] = {
+      js: jsRel ? hashMap.get(jsRel) : void 0,
+      hasLoader: metadata.hasLoader,
+      prerendered: prerendered.has(route.path) || void 0
+    };
+  }
+  for (const hashed of hashMap.values())
+    if (hashed.includes("chunk-"))
+      manifest.chunks.push(hashed);
+  return manifest;
+}

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

@@ -0,0 +1,32 @@
+import type { ClientBuildBackend, ClientBuildBackendOptions, ClientBuildBackendResult } from "./client-backend.js";
+export interface ClientBuildOutputSurface {
+    files: string[];
+    jsFiles: string[];
+    sourcemaps: string[];
+}
+export interface ClientBuildBackendParityReport {
+    leftBackend: string;
+    rightBackend: string;
+    matches: boolean;
+    outputMatches: boolean;
+    left: Pick<ClientBuildBackendResult, "success" | "logs">;
+    right: Pick<ClientBuildBackendResult, "success" | "logs">;
+    leftOutput: ClientBuildOutputSurface;
+    rightOutput: ClientBuildOutputSurface;
+}
+export declare function compareClientBuildBackends(leftBackend: ClientBuildBackend, rightBackend: ClientBuildBackend, options: ClientBuildBackendOptions): Promise<ClientBuildBackendParityReport>;
+export interface BuildArtifactRouteSurface {
+    path: string;
+    hasLoader: boolean;
+    prerendered: boolean;
+    hasClientBundle: boolean;
+}
+export interface BuildArtifactSurface {
+    routes: BuildArtifactRouteSurface[];
+    prerendered: string[];
+    chunkCount: number;
+    cssArtifacts: string[];
+    staticPages: string[];
+    serverEntries: string[];
+}
+export declare function readBuildArtifactSurface(distDir: string): Promise<BuildArtifactSurface>;

package/dist-pkg/build/parity.js

@@ -0,0 +1,71 @@
+import { readdir, rm } from "node:fs/promises";
+import { basename, dirname, join, relative } from "node:path";
+import { loadBuildManifest } from "../server/manifest.js";
+export async function compareClientBuildBackends(leftBackend, rightBackend, options) {
+  const leftOptions = createBackendParityOptions(options, leftBackend.name), rightOptions = createBackendParityOptions(options, rightBackend.name);
+  await Promise.all([
+    rm(leftOptions.outdir, { recursive: !0, force: !0 }),
+    rm(rightOptions.outdir, { recursive: !0, force: !0 })
+  ]);
+  const left = await leftBackend.build(leftOptions), right = await rightBackend.build(rightOptions), leftShape = { success: left.success, logs: left.logs }, rightShape = { success: right.success, logs: right.logs }, leftOutput = await readClientBuildOutputSurface(leftOptions.outdir), rightOutput = await readClientBuildOutputSurface(rightOptions.outdir), outputMatches = JSON.stringify(leftOutput) === JSON.stringify(rightOutput);
+  return {
+    leftBackend: leftBackend.name,
+    rightBackend: rightBackend.name,
+    matches: JSON.stringify(leftShape) === JSON.stringify(rightShape) && outputMatches,
+    outputMatches,
+    left: leftShape,
+    right: rightShape,
+    leftOutput,
+    rightOutput
+  };
+}
+export async function readBuildArtifactSurface(distDir) {
+  const manifest = await loadBuildManifest(distDir), staticDir = join(distDir, "static"), clientDir = join(distDir, "client"), staticFiles = await listFiles(staticDir, staticDir), clientFiles = await listFiles(clientDir, clientDir), distFiles = await listFiles(distDir, distDir);
+  return {
+    routes: normalizeManifestRoutes(manifest),
+    prerendered: [...manifest.prerendered].sort(),
+    chunkCount: manifest.chunks.length,
+    cssArtifacts: clientFiles.filter((file) => file.endsWith(".css")).sort(),
+    staticPages: staticFiles.filter((file) => file.endsWith(".html")).sort(),
+    serverEntries: distFiles.filter((file) => file === "prod.js" || file === "prod-node.js" || file === "server-handler.js" || file === "server-handler-node.js" || file === "worker.js").sort()
+  };
+}
+function normalizeManifestRoutes(manifest) {
+  return Object.entries(manifest.routes).map(([path, route]) => ({
+    path,
+    hasLoader: route.hasLoader,
+    prerendered: route.prerendered === !0,
+    hasClientBundle: typeof route.js === "string" && route.js.length > 0
+  })).sort((left, right) => left.path.localeCompare(right.path));
+}
+async function listFiles(root, baseDir) {
+  try {
+    const entries = await readdir(root, { withFileTypes: !0 }), files = [];
+    for (const entry of entries) {
+      const full = join(root, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...await listFiles(full, baseDir));
+        continue;
+      }
+      files.push(relative(baseDir, full));
+    }
+    return files;
+  } catch {
+    return [];
+  }
+}
+function createBackendParityOptions(options, backendName) {
+  const outdirBase = basename(options.outdir), outdirParent = dirname(options.outdir);
+  return {
+    ...options,
+    outdir: join(outdirParent, `${outdirBase}-${backendName}`)
+  };
+}
+async function readClientBuildOutputSurface(outdir) {
+  const files = (await listFiles(outdir, outdir)).sort();
+  return {
+    files,
+    jsFiles: files.filter((file) => file.endsWith(".js")),
+    sourcemaps: files.filter((file) => file.endsWith(".map"))
+  };
+}

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

@@ -0,0 +1,11 @@
+import type { BunPlugin } from "bun";
+import type { Plugin as RolldownPlugin } from "rolldown";
+export type BuildRuntimeTarget = "bun" | "rolldown";
+export interface FrameworkBuildPlugin {
+    name: string;
+    bun?: BunPlugin;
+    rolldown?: RolldownPlugin;
+}
+export declare function defineBuildPlugin(plugin: FrameworkBuildPlugin): FrameworkBuildPlugin;
+export declare function resolveBuildPluginsForTarget(plugins: FrameworkBuildPlugin[], target: "bun"): BunPlugin[];
+export declare function resolveBuildPluginsForTarget(plugins: FrameworkBuildPlugin[], target: "rolldown"): RolldownPlugin[];

package/dist-pkg/build/plugin.js

@@ -0,0 +1,8 @@
+export function defineBuildPlugin(plugin) {
+  return plugin;
+}
+export function resolveBuildPluginsForTarget(plugins, target) {
+  if (target === "bun")
+    return plugins.map((plugin) => plugin.bun).filter((plugin) => Boolean(plugin));
+  return plugins.map((plugin) => plugin.rolldown).filter((plugin) => Boolean(plugin));
+}