@teyik0/furin 0.1.0-alpha.3

package/src/adapter/bun.ts

@@ -0,0 +1,119 @@
+import { existsSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { buildClient } from "../build/client.ts";
+import { generateCompileEntry } from "../build/compile-entry.ts";
+import { generateServerRoutesEntry } from "../build/server-routes-entry.ts";
+import {
+  buildTargetManifest,
+  copyDirRecursive,
+  ensureDir,
+  toPosixPath,
+  writeTargetManifest,
+} from "../build/shared.ts";
+import type { BuildAppOptions, TargetBuildManifest } from "../build/types.ts";
+import type { BuildTarget } from "../config.ts";
+import type { ResolvedRoute } from "../router.ts";
+
+export async function buildBunTarget(
+  routes: ResolvedRoute[],
+  rootDir: string,
+  buildRoot: string,
+  rootPath: string,
+  serverEntry: string | null,
+  options: BuildAppOptions
+): Promise<TargetBuildManifest> {
+  if (options.compile && !serverEntry) {
+    throw new Error(
+      `[furin] \`compile: "${options.compile}"\` requires a server entry point. ` +
+        "Create src/server.ts or set `serverEntry` in your furin.config.ts."
+    );
+  }
+
+  const target = "bun" satisfies BuildTarget;
+  const targetManifest = buildTargetManifest(rootDir, buildRoot, target, serverEntry);
+  const targetDir = resolve(rootDir, targetManifest.targetDir);
+
+  rmSync(targetDir, { force: true, recursive: true });
+  ensureDir(targetDir);
+
+  await buildClient(routes, {
+    outDir: targetDir,
+    rootLayout: rootPath,
+    plugins: options.plugins,
+  });
+
+  const routeManifest = routes.map((r) => ({ pattern: r.pattern, path: r.path, mode: r.mode }));
+  const publicDir = existsSync(join(rootDir, "public")) ? join(rootDir, "public") : undefined;
+  const targetPublicDir = publicDir ? join(targetDir, "public") : undefined;
+
+  if (publicDir && targetPublicDir && options.compile !== "embed") {
+    copyDirRecursive(publicDir, targetPublicDir);
+  }
+
+  if (options.compile && serverEntry) {
+    const clientDir = join(targetDir, "client");
+    const outfile = join(targetDir, "server");
+
+    const entryPath = generateCompileEntry({
+      rootPath,
+      routes: routeManifest,
+      serverEntry,
+      outDir: targetDir,
+      embed: options.compile === "embed" ? { clientDir } : undefined,
+      publicDir,
+    });
+
+    await Bun.build({
+      entrypoints: [entryPath],
+      compile: { outfile },
+      minify: true,
+      sourcemap: "linked",
+      plugins: options.plugins,
+    });
+    console.log(`[furin] Server binary: ${outfile}`);
+
+    targetManifest.serverPath = toPosixPath(join(targetManifest.targetDir, "server"));
+
+    // Embed mode: assets are in the binary — clean up client dir too.
+    if (options.compile === "embed") {
+      rmSync(clientDir, { force: true, recursive: true });
+    }
+  } else if (serverEntry) {
+    // Disk mode: generate server.ts then bundle it into self-contained server.js
+    const entryPath = generateServerRoutesEntry({
+      rootPath,
+      routes: routeManifest,
+      serverEntry,
+      outDir: targetDir,
+    });
+
+    await Bun.build({
+      entrypoints: [entryPath],
+      outdir: targetDir,
+      target: "bun",
+      minify: true,
+      sourcemap: "linked",
+      plugins: options.plugins,
+    });
+    console.log(
+      `[furin] Server bundle: ${toPosixPath(join(targetManifest.targetDir, "server.js"))}`
+    );
+
+    targetManifest.serverPath = toPosixPath(join(targetManifest.targetDir, "server.js"));
+  }
+
+  // Clean up build intermediates — no longer needed once the bundle/binary is built.
+  for (const file of [
+    "_compile-entry.ts",
+    "_compile-entry.js.map",
+    "server.ts", // disk mode intermediate
+    "_hydrate.tsx",
+    "index.html",
+  ]) {
+    rmSync(join(targetDir, file), { force: true });
+  }
+
+  writeTargetManifest(targetDir, targetManifest);
+
+  return targetManifest;
+}

package/src/build/client.ts

@@ -0,0 +1,110 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { transformForClient } from "../plugin/transform-client";
+import { generateIndexHtml } from "../render/shell";
+import type { ResolvedRoute } from "../router";
+import { generateHydrateEntry } from "./hydrate";
+import { CLIENT_MODULE_PATH, LINK_MODULE_PATH } from "./shared";
+import type { BunBuildAliasConfig, BuildClientOptions } from "./types";
+
+const TS_FILE_FILTER = /\.(tsx|ts)$/;
+const REACT_IMPORT_RE = /import\s+React\b/;
+
+/**
+ * Builds the production client bundle via Bun.build() using the generated
+ * index.html as the HTML entrypoint. Bun produces:
+ *   <outDir>/client/index.html  — processed template with hashed chunk paths
+ *   <outDir>/client/chunk-*.js  — code-split bundles
+ *   <outDir>/client/styles.css  — CSS (if imported)
+ *
+ * The output index.html is NOT served to browsers directly. The server reads
+ * it as an SSR template, injects the pre-rendered React HTML into
+ * <!--ssr-outlet-->, and sends the complete page.
+ */
+export async function buildClient(
+  routes: ResolvedRoute[],
+  { outDir, rootLayout, plugins }: BuildClientOptions
+): Promise<void> {
+  const clientDir = join(outDir, "client");
+
+  if (!existsSync(outDir)) {
+    mkdirSync(outDir, { recursive: true });
+  }
+  if (!existsSync(clientDir)) {
+    mkdirSync(clientDir, { recursive: true });
+  }
+
+  const hydrateCode = generateHydrateEntry(routes, rootLayout);
+  const hydratePath = join(outDir, "_hydrate.tsx");
+  writeFileSync(hydratePath, hydrateCode);
+
+  const indexHtml = generateIndexHtml();
+  const indexPath = join(outDir, "index.html");
+  writeFileSync(indexPath, indexHtml);
+
+  console.log("[furin] Building production client bundle…");
+
+  const transformPlugin: Bun.BunPlugin = {
+    name: "furin-transform-client",
+    setup(build) {
+      build.onLoad({ filter: TS_FILE_FILTER }, async (args) => {
+        const { path } = args;
+        if (path.includes("node_modules")) {
+          return undefined;
+        }
+
+        const code = await Bun.file(path).text();
+        try {
+          const result = transformForClient(code, path);
+          let transformed = result.code;
+
+          if (transformed.includes("React.createElement") && !REACT_IMPORT_RE.test(transformed)) {
+            transformed = `import React from "react";\n${transformed}`;
+          }
+
+          transformed = transformed
+            .replaceAll(`"@teyik0/furin/client"`, JSON.stringify(CLIENT_MODULE_PATH))
+            .replaceAll(`'furin/client'`, JSON.stringify(CLIENT_MODULE_PATH))
+            .replaceAll(`"@teyik0/furin/link"`, JSON.stringify(LINK_MODULE_PATH))
+            .replaceAll(`'furin/link'`, JSON.stringify(LINK_MODULE_PATH));
+
+          return {
+            contents: transformed,
+            loader: path.endsWith(".tsx") ? "tsx" : "ts",
+          };
+        } catch (error) {
+          console.error(`[furin] Transform error for ${path}:`, error);
+          return undefined;
+        }
+      });
+    },
+  };
+
+  const clientBuildConfig: BunBuildAliasConfig = {
+    entrypoints: [indexPath],
+    outdir: clientDir,
+    target: "browser",
+    format: "esm",
+    splitting: true,
+    minify: true,
+    sourcemap: "linked",
+    // Absolute public path so SSR template asset URLs resolve on any route
+    publicPath: "/_client/",
+    // User plugins run before the internal transform so they pre-process files first
+    plugins: plugins ? [...plugins, transformPlugin] :  [transformPlugin],
+    alias: {
+      "@teyik0/furin/client": CLIENT_MODULE_PATH,
+      "@teyik0/furin/link": LINK_MODULE_PATH,
+    },
+    define: {
+      "process.env.NODE_ENV": JSON.stringify("production"),
+    },
+  };
+
+  const result = await Bun.build(clientBuildConfig);
+  for (const output of result.outputs) {
+    console.log(`[furin]   ${output.path} (${(output.size / 1024).toFixed(1)} KB)`);
+  }
+
+  console.log("[furin] Production client build complete");
+}

package/src/build/compile-entry.ts

@@ -0,0 +1,99 @@
+import { existsSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { buildEntrySource } from "./entry-template";
+import { collectFilesRecursive, ensureDir, toPosixPath } from "./shared";
+
+export interface CompileEntryOptions {
+  outDir: string;
+  rootPath: string;
+  routes: Array<{ mode: "ssr" | "ssg" | "isr"; path: string; pattern: string }>;
+  serverEntry: string;
+  embed?: { clientDir: string };
+  publicDir?: string;
+}
+
+/**
+ * Generates a single `_compile-entry.ts` that:
+ * 1. Statically imports every page module so Bun bundles them into the binary
+ * 2. Optionally embeds client assets via `with { type: "file" }` (embed mode)
+ * 3. Sets production mode and registers everything in a single CompileContext
+ * 4. Dynamically imports server.ts to boot the app
+ */
+export function generateCompileEntry(options: CompileEntryOptions): string {
+  const { outDir, rootPath, routes, serverEntry, embed, publicDir } = options;
+  ensureDir(outDir);
+
+  // Build embedded asset imports if embed mode
+  const assetImports: string[] = [];
+  let embeddedBlock: string[] = [];
+  if (embed) {
+    if (!existsSync(embed.clientDir)) {
+      throw new Error(`[furin] Client directory not found: ${embed.clientDir}. Run the client build first.`);
+    }
+    const clientFiles = collectFilesRecursive(embed.clientDir);
+    const assetEntries: string[] = [];
+    let templateVarName: string | null = null;
+
+    let assetIndex = 0;
+    for (const file of clientFiles) {
+      const varName = `_asset${assetIndex++}`;
+      const relPath = toPosixPath(relative(outDir, file));
+      const importPath = relPath.startsWith(".") ? relPath : `./${relPath}`;
+
+      assetImports.push(
+        `import ${varName} from ${JSON.stringify(importPath)} with { type: "file" };`
+      );
+
+      const clientRelativePath = toPosixPath(relative(embed.clientDir, file));
+      if (clientRelativePath === "index.html") {
+        templateVarName = varName;
+      } else {
+        assetEntries.push(`      ${JSON.stringify(`/_client/${clientRelativePath}`)}: ${varName},`);
+      }
+    }
+
+    if (templateVarName === null) {
+      throw new Error(
+        `[furin] Embed mode requires a client index.html at ${join(embed.clientDir, "index.html")}. Run the client build first.`
+      );
+    }
+
+    if (publicDir && existsSync(publicDir)) {
+      const publicFiles = collectFilesRecursive(publicDir);
+      for (const file of publicFiles) {
+        const varName = `_asset${assetIndex++}`;
+        const relPath = toPosixPath(relative(outDir, file));
+        const importPath = relPath.startsWith(".") ? relPath : `./${relPath}`;
+
+        assetImports.push(
+          `import ${varName} from ${JSON.stringify(importPath)} with { type: "file" };`
+        );
+
+        const publicRelativePath = toPosixPath(relative(publicDir, file));
+        assetEntries.push(`      ${JSON.stringify(`/public/${publicRelativePath}`)}: ${varName},`);
+      }
+    }
+
+    embeddedBlock = [
+      "  embedded: {",
+      `    template: ${templateVarName},`,
+      "    assets: {",
+      ...assetEntries,
+      "    },",
+      "  },",
+    ];
+  }
+
+  const source = buildEntrySource({
+    headerComment: "// Auto-generated by furin compile — do not edit",
+    rootPath,
+    routes,
+    serverEntry,
+    extraImports: assetImports,
+    extraContext: embeddedBlock,
+  });
+
+  const entryPath = join(outDir, "_compile-entry.ts");
+  writeFileSync(entryPath, source);
+  return entryPath;
+}

package/src/build/entry-template.ts

@@ -0,0 +1,62 @@
+import { resolve } from "node:path";
+
+const INTERNAL_MODULE_PATH = resolve(import.meta.dir, "../internal.ts").replace(/\\/g, "/");
+const RUNTIME_ENV_MODULE_PATH = resolve(import.meta.dir, "../runtime-env.ts").replace(/\\/g, "/");
+
+export interface EntryTemplateOptions {
+  headerComment: string;
+  rootPath: string;
+  routes: Array<{ mode: "ssr" | "ssg" | "isr"; path: string; pattern: string }>;
+  serverEntry: string;
+  extraImports?: string[];
+  extraContext?: string[];
+}
+
+export function buildEntrySource(options: EntryTemplateOptions): string {
+  const { headerComment, rootPath, routes, serverEntry, extraImports = [], extraContext = [] } =
+    options;
+
+  const allModulePaths = [rootPath, ...routes.map((r) => r.path)];
+  const moduleImports: string[] = [];
+  const moduleEntries: string[] = [];
+
+  for (let i = 0; i < allModulePaths.length; i++) {
+    const absPath = (allModulePaths[i] as string).replace(/\\/g, "/");
+    const varName = `_mod${i}`;
+    moduleImports.push(`import * as ${varName} from ${JSON.stringify(absPath)};`);
+    moduleEntries.push(`  ${JSON.stringify(absPath)}: ${varName},`);
+  }
+
+  const routeEntries = routes.map(
+    (r) =>
+      `    { pattern: ${JSON.stringify(r.pattern)}, path: ${JSON.stringify(r.path.replace(/\\/g, "/"))}, mode: ${JSON.stringify(r.mode)} },`
+  );
+
+  const lines = [
+    headerComment,
+    `import { __setCompileContext } from ${JSON.stringify(INTERNAL_MODULE_PATH)};`,
+    `import { __setDevMode } from ${JSON.stringify(RUNTIME_ENV_MODULE_PATH)};`,
+    ...moduleImports,
+    ...(extraImports.length > 0 ? ["", ...extraImports] : []),
+    "",
+    "// Force production mode — Bun may inline process.env.NODE_ENV at bundle time.",
+    "__setDevMode(false);",
+    'process.env.NODE_ENV = "production";',
+    "",
+    "__setCompileContext({",
+    `  rootPath: ${JSON.stringify(rootPath.replace(/\\/g, "/"))},`,
+    "  modules: {",
+    ...moduleEntries,
+    "  },",
+    "  routes: [",
+    ...routeEntries,
+    "  ],",
+    ...extraContext,
+    "});",
+    "",
+    `await import(${JSON.stringify(serverEntry.replace(/\\/g, "/"))});`,
+    "",
+  ];
+
+  return lines.join("\n");
+}

package/src/build/hydrate.ts

@@ -0,0 +1,106 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { generateIndexHtml } from "../render/shell";
+import type { ResolvedRoute } from "../router";
+import { writeRouteTypes } from "./route-types";
+import type { BuildClientOptions } from "./types";
+
+/**
+ * Generates the client hydration entry.
+ *
+ * Renders into <div id="root"> (the SSR outlet element) and retains the React
+ * root across hot reloads via import.meta.hot.data.root so React Fast Refresh
+ * applies in-place instead of remounting.
+ *
+ * @param routes - Resolved routes to include in the hydration manifest.
+ * @param rootLayout - Absolute path to the root layout module.
+ */
+export function generateHydrateEntry(routes: ResolvedRoute[], rootLayout: string): string {
+  const routeEntries: string[] = [];
+
+  for (const route of routes) {
+    const resolvedPage = route.path.replace(/\\/g, "/");
+    const regexPattern = route.pattern.replace(/:[^/]+/g, "([^/]+)").replace(/\*/g, "(.*)");
+
+    routeEntries.push(
+      ` { pattern: "${route.pattern}", regex: new RegExp("^${regexPattern}$"), load: () => import("${resolvedPage}") }`
+    );
+  }
+
+  return `import { hydrateRoot, createRoot } from "react-dom/client";
+import { createElement } from "react";
+import { RouterProvider } from "@teyik0/furin/link";
+import { route as root } from "${rootLayout.replace(/\\/g, "/")}";
+
+const routes = [
+${routeEntries.join(",\n")}
+];
+
+const pathname = window.location.pathname;
+const _match = routes.find((r) => r.regex.test(pathname));
+
+// Eagerly load only the current page module for initial hydration.
+// All other pages are loaded on demand when the user navigates to them.
+if (_match) {
+  const _mod = await _match.load();
+  const match = { ..._match, component: _mod.default.component, pageRoute: _mod.default._route };
+
+  const dataEl = document.getElementById("__FURIN_DATA__");
+  const loaderData = dataEl ? JSON.parse(dataEl.textContent || "{}") : {};
+  const rootEl = document.getElementById("root") as HTMLElement;
+
+  const app = createElement(RouterProvider, {
+    routes,
+    root,
+    initialMatch: match,
+    initialData: loaderData,
+  } as any);
+
+  if (import.meta.hot) {
+    // Retain React root across hot reloads so Fast Refresh applies in-place.
+    const hotRoot = (import.meta.hot.data.root ??= rootEl.innerHTML.trim()
+      ? hydrateRoot(rootEl, app)
+      : createRoot(rootEl));
+    hotRoot.render(app);
+  } else if (rootEl.innerHTML.trim()) {
+    hydrateRoot(rootEl, app);
+  } else {
+    createRoot(rootEl).render(app);
+  }
+} else {
+  console.error("[furin] No matching route for", pathname);
+}
+`;
+}
+
+/**
+ * Writes _hydrate.tsx + index.html to outDir for dev (Bun HMR) mode.
+ *
+ * Only rewrites a file when its content has actually changed so Bun's --hot
+ * watcher does not trigger a spurious reload on every server restart.
+ */
+export function writeDevFiles(routes: ResolvedRoute[], {outDir, rootLayout}: BuildClientOptions): void {
+  if (!existsSync(outDir)) {
+    mkdirSync(outDir, { recursive: true });
+  }
+
+  const hydrateCode = generateHydrateEntry(routes, rootLayout);
+  const hydratePath = join(outDir, "_hydrate.tsx");
+  const existingHydrate = existsSync(hydratePath) ? readFileSync(hydratePath, "utf8") : "";
+  if (hydrateCode !== existingHydrate) {
+    writeFileSync(hydratePath, hydrateCode);
+  }
+
+  const indexHtml = generateIndexHtml();
+  const indexPath = join(outDir, "index.html");
+  const existingIndex = existsSync(indexPath) ? readFileSync(indexPath, "utf8") : "";
+  if (indexHtml !== existingIndex) {
+    writeFileSync(indexPath, indexHtml);
+  }
+
+  writeRouteTypes(routes, outDir);
+
+  console.log(
+    "[furin] Dev files written (.furin/_hydrate.tsx + .furin/index.html + .furin/routes.d.ts)"
+  );
+}

package/src/build/index.ts

@@ -0,0 +1,120 @@
+import { existsSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import { buildBunTarget } from "../adapter/bun";
+import { BUILD_TARGETS, type BuildTarget } from "../config";
+import { scanPages } from "../router";
+import { scanFurinInstances } from "./scan-server";
+import {
+  ensureDir,
+  toBuildRouteManifestEntry,
+  toPosixPath,
+} from "./shared";
+import type {
+  BuildAppOptions,
+  BuildAppResult,
+  BuildManifest,
+} from "./types";
+
+export type {
+  BuildAppOptions,
+  BuildAppResult,
+  BuildClientOptions,
+  BuildManifest,
+  BuildRouteManifestEntry,
+  TargetBuildManifest,
+} from "./types";
+export { buildClient } from "./client";
+export { writeDevFiles } from "./hydrate";
+export { patternToTypeString, schemaToTypeString, writeRouteTypes } from "./route-types";
+
+const IMPLEMENTED_TARGETS = ["bun"] as const satisfies BuildTarget[];
+export const BUILD_OUTPUT_DIR = ".furin/build";
+
+function resolvePagesDirFromServer(serverEntry: string | null, rootDir: string): string | null {
+  if (!serverEntry) return null;
+  const detected = scanFurinInstances(serverEntry);
+  if (detected.length === 0) return null;
+  // Use the first detected pagesDir relative to rootDir
+  return resolve(rootDir, detected[0] as string);
+}
+
+export async function buildApp(options: BuildAppOptions): Promise<BuildAppResult> {
+  const rootDir = resolve(options.rootDir ?? process.cwd());
+  const buildRoot = join(rootDir, BUILD_OUTPUT_DIR);
+  const serverEntry = (() => {
+    if (options.serverEntry) {
+      const resolved = resolve(rootDir, options.serverEntry);
+      if (existsSync(resolved)) return resolved;
+    }
+    const serverEntry = resolve(rootDir, "src/server.ts");
+    if (!existsSync(serverEntry)) {
+      throw new Error("[furin] Entrypoint server.ts not found");
+    }
+    return serverEntry
+  })();
+
+  // Priority: explicit config > auto-detected from server entry > default
+  const rawPagesDir =
+    options.pagesDir ?? resolvePagesDirFromServer(serverEntry, rootDir) ?? "src/pages";
+  const pagesDir = resolve(rootDir, rawPagesDir);
+
+  const requestedTargets =
+    options.target === "all"
+      ? [...IMPLEMENTED_TARGETS]
+      : [options.target].map((target) => {
+          if (!(BUILD_TARGETS as readonly string[]).includes(target)) {
+            throw new Error(`[furin] Unsupported build target "${target}"`);
+          }
+          return target as BuildTarget;
+        });
+
+  const { root, routes } = await scanPages(pagesDir);
+  if (!root) {
+    throw new Error(
+      "[furin] No root layout found. Create a root.tsx in your pages directory with a layout component."
+    );
+  }
+
+  ensureDir(buildRoot);
+
+  const manifest: BuildManifest = {
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    rootDir: toPosixPath(rootDir),
+    pagesDir: toPosixPath(relative(rootDir, pagesDir)),
+    rootPath: toPosixPath(relative(rootDir, root.path)),
+    serverEntry: serverEntry ? toPosixPath(relative(rootDir, serverEntry)) : null,
+    routes: routes.map((route) => toBuildRouteManifestEntry(route, rootDir)),
+    targets: {},
+  };
+
+  for (const target of requestedTargets) {
+    switch (target) {
+      case "bun":
+        manifest.targets.bun = await buildBunTarget(
+          routes,
+          rootDir,
+          buildRoot,
+          root.path,
+          serverEntry,
+          options
+        );
+        break;
+      case "node":
+      case "vercel":
+      case "cloudflare":
+        throw new Error(
+          `[furin] \`--target ${target}\` is planned but not implemented yet in this branch.`
+        );
+      default:
+        throw new Error(`[furin] Unsupported build target "${target}"`);
+    }
+  }
+
+  writeFileSync(join(buildRoot, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`)
+
+  return {
+    manifest,
+    targets: manifest.targets,
+  };
+}