npm - @bractjs/bractjs - Versions diffs - 0.1.0 - Mend

@bractjs/bractjs 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (85) hide show

package/LICENSE +21 -0
package/README.md +586 -0
package/bin/cli.ts +101 -0
package/package.json +58 -0
package/src/__tests__/fixtures/app/root.tsx +9 -0
package/src/__tests__/fixtures/app/routes/_index.tsx +20 -0
package/src/__tests__/integration.test.ts +66 -0
package/src/__tests__/loader.test.ts +89 -0
package/src/__tests__/matcher.test.ts +69 -0
package/src/__tests__/meta.test.ts +81 -0
package/src/__tests__/scanner.test.ts +58 -0
package/src/__tests__/session.test.ts +103 -0
package/src/build/bundler.ts +75 -0
package/src/build/defines.ts +16 -0
package/src/build/directives.ts +67 -0
package/src/build/env-plugin.ts +56 -0
package/src/build/hash.ts +56 -0
package/src/build/manifest.ts +60 -0
package/src/client/ClientRouter.tsx +122 -0
package/src/client/components/Await.tsx +26 -0
package/src/client/components/Form.tsx +67 -0
package/src/client/components/Image.tsx +79 -0
package/src/client/components/Link.tsx +42 -0
package/src/client/components/LiveReload.tsx +16 -0
package/src/client/components/Outlet.tsx +64 -0
package/src/client/components/Scripts.tsx +12 -0
package/src/client/entry.tsx +49 -0
package/src/client/form-utils.ts +12 -0
package/src/client/hooks/useActionData.ts +14 -0
package/src/client/hooks/useFetcher.ts +51 -0
package/src/client/hooks/useLoaderData.ts +14 -0
package/src/client/hooks/useNavigation.ts +12 -0
package/src/client/hooks/useParams.ts +14 -0
package/src/client/nav-utils.ts +35 -0
package/src/client/prefetch.ts +32 -0
package/src/client/route-cache.ts +20 -0
package/src/client/router.tsx +54 -0
package/src/client/types.ts +23 -0
package/src/codegen/route-codegen.ts +99 -0
package/src/dev/error-overlay.ts +33 -0
package/src/dev/hmr-client.ts +43 -0
package/src/dev/hmr-module-handler.ts +47 -0
package/src/dev/hmr-server.ts +51 -0
package/src/dev/rebuilder.ts +95 -0
package/src/dev/server.ts +38 -0
package/src/dev/watcher.ts +32 -0
package/src/image/cache.ts +75 -0
package/src/image/handler.ts +82 -0
package/src/image/optimizer.ts +76 -0
package/src/image/types.ts +27 -0
package/src/index.ts +51 -0
package/src/middleware/authGuard.ts +37 -0
package/src/middleware/cors.ts +36 -0
package/src/middleware/requestLogger.ts +15 -0
package/src/server/action-handler.ts +35 -0
package/src/server/action-registry.ts +41 -0
package/src/server/env.ts +29 -0
package/src/server/index.ts +8 -0
package/src/server/layout.ts +92 -0
package/src/server/loader.ts +80 -0
package/src/server/matcher.ts +99 -0
package/src/server/meta.ts +92 -0
package/src/server/middleware.ts +47 -0
package/src/server/render.ts +65 -0
package/src/server/request-handler.ts +142 -0
package/src/server/response.ts +17 -0
package/src/server/scanner.ts +68 -0
package/src/server/serve.ts +131 -0
package/src/server/session.ts +111 -0
package/src/server/static.ts +40 -0
package/src/shared/context.ts +37 -0
package/src/shared/deferred.ts +55 -0
package/src/shared/error-boundary.tsx +58 -0
package/src/shared/errors.ts +49 -0
package/src/shared/route-types.ts +51 -0
package/templates/new-app/app/root.tsx +20 -0
package/templates/new-app/app/routes/_index.tsx +31 -0
package/templates/new-app/app/routes/about.tsx +21 -0
package/templates/new-app/bractjs.config.ts +14 -0
package/templates/new-app/package.json +20 -0
package/types/config.d.ts +25 -0
package/types/index.d.ts +109 -0
package/types/middleware.d.ts +19 -0
package/types/route.d.ts +41 -0
package/types/session.d.ts +32 -0

package/package.json ADDED Viewed

@@ -0,0 +1,58 @@
+{
+  "name": "@bractjs/bractjs",
+  "version": "0.1.0",
+  "description": "Production-grade SSR framework for Bun + React 19. File-based routing, streaming SSR, server actions, typed routes.",
+  "license": "MIT",
+  "homepage": "https://github.com/bractjs/bractjs#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bractjs/bractjs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bractjs/bractjs/issues"
+  },
+  "keywords": [
+    "bun",
+    "react",
+    "react19",
+    "ssr",
+    "framework",
+    "routing",
+    "server-actions",
+    "streaming",
+    "typescript",
+    "full-stack"
+  ],
+  "files": [
+    "src",
+    "bin",
+    "types",
+    "templates"
+  ],
+  "bin": {
+    "bractjs": "./bin/cli.ts"
+  },
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "dev": "bun run src/dev/server.ts",
+    "build": "bun run src/build/bundler.ts",
+    "test": "bun test"
+  },
+  "peerDependencies": {
+    "react": "^19",
+    "react-dom": "^19"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "react": "^19",
+    "react-dom": "^19"
+  }
+}

package/src/__tests__/fixtures/app/root.tsx ADDED Viewed

@@ -0,0 +1,9 @@
+// Minimal root component for integration tests.
+export default function Root() {
+  return (
+    <html>
+      <head></head>
+      <body></body>
+    </html>
+  );
+}

package/src/__tests__/fixtures/app/routes/_index.tsx ADDED Viewed

@@ -0,0 +1,20 @@
+import type { ActionArgs } from "../../../../shared/route-types.ts";
+// Loader returns data that will appear in __BRACTJS_DATA__
+export function loader() {
+  return { message: "hello from bractjs" };
+}
+// Meta returns a title descriptor
+export function meta() {
+  return [{ title: "BractJS Test Home" }];
+}
+// Action echoes the submitted form field
+export async function action({ formData }: ActionArgs) {
+  return { submitted: true, name: formData.get("name") };
+}
+export default function IndexPage() {
+  return <p>Index page content</p>;
+}

package/src/__tests__/integration.test.ts ADDED Viewed

@@ -0,0 +1,66 @@
+import { test, expect, beforeAll, afterAll } from "bun:test";
+import { resolve } from "node:path";
+import { createServer } from "../server/serve.ts";
+const PORT = 3999;
+const BASE = `http://localhost:${PORT}`;
+const FIXTURE_APP = resolve(import.meta.dir, "fixtures/app");
+let handle: ReturnType<typeof createServer>;
+beforeAll(() => {
+  handle = createServer({
+    port: PORT,
+    appDir: FIXTURE_APP,
+    manifest: { clientEntry: "/build/client/client.js", routes: {} },
+  });
+});
+afterAll(() => {
+  handle.stop();
+});
+test("GET / returns 200 HTML", async () => {
+  const res = await fetch(`${BASE}/`);
+  expect(res.status).toBe(200);
+  expect(res.headers.get("content-type")).toContain("text/html");
+});
+test("GET /_data?path=/ returns JSON with route key", async () => {
+  const res = await fetch(`${BASE}/_data?path=/`);
+  expect(res.status).toBe(200);
+  const data = (await res.json()) as Record<string, unknown>;
+  expect(data).toHaveProperty("route");
+  expect(data).toHaveProperty("params");
+});
+test("POST / runs action and returns 200 HTML", async () => {
+  const form = new FormData();
+  form.set("name", "bract");
+  const res = await fetch(`${BASE}/`, { method: "POST", body: form });
+  expect(res.status).toBe(200);
+  expect(res.headers.get("content-type")).toContain("text/html");
+});
+test("GET /nonexistent returns 404", async () => {
+  const res = await fetch(`${BASE}/nonexistent`);
+  expect(res.status).toBe(404);
+});
+test("HTML includes window.__BRACTJS_DATA__", async () => {
+  const res = await fetch(`${BASE}/`);
+  const html = await res.text();
+  expect(html).toContain("__BRACTJS_DATA__");
+});
+test("HTML includes loader data from route", async () => {
+  const res = await fetch(`${BASE}/`);
+  const html = await res.text();
+  expect(html).toContain("hello from bractjs");
+});
+test("HTML includes <title> from meta()", async () => {
+  const res = await fetch(`${BASE}/`);
+  const html = await res.text();
+  expect(html).toContain("BractJS Test Home");
+});

package/src/__tests__/loader.test.ts ADDED Viewed

@@ -0,0 +1,89 @@
+import { test, expect, describe } from "bun:test";
+import { safeRun, runLoaders, buildLoaderArgs } from "../server/loader.ts";
+import { HttpError } from "../shared/errors.ts";
+import type { LoaderArgs } from "../shared/route-types.ts";
+import type { LayoutChain } from "../server/layout.ts";
+import type { RouteModule } from "../shared/route-types.ts";
+const stubArgs: LoaderArgs = {
+  request: new Request("http://localhost/"),
+  params: {},
+  context: {},
+};
+const emptyModule: RouteModule = {};
+describe("safeRun", () => {
+  test("returns null when fn is undefined", async () => {
+    const result = await safeRun(undefined, stubArgs);
+    expect(result).toBeNull();
+  });
+  test("returns loader data on success", async () => {
+    const result = await safeRun(async () => ({ name: "bract" }), stubArgs);
+    expect(result).toEqual({ name: "bract" });
+  });
+  test("wraps non-redirect errors in __error", async () => {
+    const result = await safeRun(async () => { throw new Error("boom"); }, stubArgs);
+    expect(result).toMatchObject({ __error: expect.any(Error) });
+  });
+  test("re-throws HttpError (does not wrap)", async () => {
+    const fn = async () => { throw new HttpError(403, "Forbidden"); };
+    await expect(safeRun(fn, stubArgs)).rejects.toBeInstanceOf(HttpError);
+  });
+  test("re-throws redirect Response", async () => {
+    const fn = async () => { throw new Response(null, { status: 302, headers: { Location: "/" } }); };
+    await expect(safeRun(fn, stubArgs)).rejects.toBeInstanceOf(Response);
+  });
+});
+describe("runLoaders", () => {
+  test("runs all loaders in parallel and returns results", async () => {
+    const chain: LayoutChain = {
+      root: { ...emptyModule, loader: async () => ({ root: true }) },
+      layouts: [{ ...emptyModule, loader: async () => ({ layout: true }) }],
+      route: { ...emptyModule, loader: async () => ({ route: true }) },
+    };
+    const results = await runLoaders(chain, stubArgs);
+    expect(results.root).toEqual({ root: true });
+    expect(results.layouts[0]).toEqual({ layout: true });
+    expect(results.route).toEqual({ route: true });
+  });
+  test("returns null for modules without loaders", async () => {
+    const chain: LayoutChain = {
+      root: emptyModule,
+      layouts: [],
+      route: emptyModule,
+    };
+    const results = await runLoaders(chain, stubArgs);
+    expect(results.root).toBeNull();
+    expect(results.route).toBeNull();
+  });
+  test("isolates errors — one loader failure doesn't prevent others", async () => {
+    const chain: LayoutChain = {
+      root: { ...emptyModule, loader: async () => { throw new Error("root fail"); } },
+      layouts: [],
+      route: { ...emptyModule, loader: async () => ({ ok: true }) },
+    };
+    const results = await runLoaders(chain, stubArgs);
+    expect(results.root).toMatchObject({ __error: expect.any(Error) });
+    expect(results.route).toEqual({ ok: true });
+  });
+});
+describe("buildLoaderArgs", () => {
+  test("assembles args from request, params, context", () => {
+    const req = new Request("http://localhost/blog/42");
+    const params = { id: "42" };
+    const context = { user: null };
+    const args = buildLoaderArgs(req, params, context);
+    expect(args.request).toBe(req);
+    expect(args.params).toBe(params);
+    expect(args.context).toBe(context);
+  });
+});

package/src/__tests__/matcher.test.ts ADDED Viewed

@@ -0,0 +1,69 @@
+import { test, expect, describe } from "bun:test";
+import { buildTrie, matchRoute } from "../server/matcher.ts";
+import type { RouteFile } from "../server/scanner.ts";
+import { pathToSegments } from "../server/scanner.ts";
+function makeRoute(pattern: string): RouteFile {
+  return { filePath: `routes/${pattern}.tsx`, urlPattern: pattern, segments: pathToSegments(pattern) };
+}
+describe("matchRoute", () => {
+  test("matches exact static route /about", () => {
+    const trie = buildTrie([makeRoute("about")]);
+    const result = matchRoute("/about", trie);
+    expect(result).not.toBeNull();
+    expect(result?.routeFile.urlPattern).toBe("about");
+    expect(result?.params).toEqual({});
+  });
+  test("matches index route /", () => {
+    const trie = buildTrie([makeRoute("")]);
+    const result = matchRoute("/", trie);
+    expect(result).not.toBeNull();
+    expect(result?.params).toEqual({});
+  });
+  test("matches /blog/42 with params.id = '42'", () => {
+    const trie = buildTrie([makeRoute("blog/[id]")]);
+    const result = matchRoute("/blog/42", trie);
+    expect(result).not.toBeNull();
+    expect(result?.params).toEqual({ id: "42" });
+  });
+  test("prefers static /blog/new over dynamic /blog/[id]", () => {
+    const trie = buildTrie([makeRoute("blog/[id]"), makeRoute("blog/new")]);
+    const result = matchRoute("/blog/new", trie);
+    expect(result?.routeFile.urlPattern).toBe("blog/new");
+  });
+  test("matches /docs/a/b/c as catch-all with slug = 'a/b/c'", () => {
+    const trie = buildTrie([makeRoute("docs/[...slug]")]);
+    const result = matchRoute("/docs/a/b/c", trie);
+    expect(result).not.toBeNull();
+    expect(result?.params.slug).toBe("a/b/c");
+  });
+  test("returns null for unmatched pathname", () => {
+    const trie = buildTrie([makeRoute("about")]);
+    expect(matchRoute("/missing", trie)).toBeNull();
+  });
+  test("returns null for empty trie", () => {
+    const trie = buildTrie([]);
+    expect(matchRoute("/anything", trie)).toBeNull();
+  });
+  test("matches nested static /blog/posts/featured", () => {
+    const trie = buildTrie([makeRoute("blog/posts/featured")]);
+    const result = matchRoute("/blog/posts/featured", trie);
+    expect(result).not.toBeNull();
+  });
+  test("param does not match when static exists at same depth", () => {
+    const trie = buildTrie([makeRoute("users/profile"), makeRoute("users/[id]")]);
+    const r1 = matchRoute("/users/profile", trie);
+    expect(r1?.routeFile.urlPattern).toBe("users/profile");
+    const r2 = matchRoute("/users/123", trie);
+    expect(r2?.params.id).toBe("123");
+  });
+});

package/src/__tests__/meta.test.ts ADDED Viewed

@@ -0,0 +1,81 @@
+import { test, expect, describe } from "bun:test";
+import { mergeMeta, renderMetaTags } from "../server/meta.ts";
+import type { MetaDescriptor } from "../shared/route-types.ts";
+describe("mergeMeta", () => {
+  test("keeps single descriptors unchanged", () => {
+    const input: MetaDescriptor[] = [
+      { title: "Home" },
+      { name: "description", content: "A site" },
+    ];
+    const result = mergeMeta(input);
+    expect(result.some((d) => "title" in d && (d as { title: string }).title === "Home")).toBe(true);
+    expect(result.some((d) => "name" in d && (d as { name: string }).name === "description")).toBe(true);
+  });
+  test("last title wins (dedup)", () => {
+    const input: MetaDescriptor[] = [
+      { title: "First" },
+      { title: "Last" },
+    ];
+    const result = mergeMeta(input);
+    const titles = result.filter((d) => "title" in d);
+    expect(titles.length).toBe(1);
+    expect((titles[0] as { title: string }).title).toBe("Last");
+  });
+  test("last name descriptor wins for same name key", () => {
+    const input: MetaDescriptor[] = [
+      { name: "description", content: "old" },
+      { name: "description", content: "new" },
+    ];
+    const result = mergeMeta(input);
+    const descs = result.filter((d) => "name" in d && (d as { name: string }).name === "description");
+    expect(descs.length).toBe(1);
+    expect((descs[0] as { content: string }).content).toBe("new");
+  });
+  test("last property descriptor wins for same property key", () => {
+    const input: MetaDescriptor[] = [
+      { property: "og:title", content: "old" },
+      { property: "og:title", content: "new" },
+    ];
+    const result = mergeMeta(input);
+    const og = result.filter((d) => "property" in d);
+    expect(og.length).toBe(1);
+    expect((og[0] as { content: string }).content).toBe("new");
+  });
+  test("returns empty array for empty input", () => {
+    expect(mergeMeta([])).toEqual([]);
+  });
+});
+describe("renderMetaTags", () => {
+  test("renders <title> tag", () => {
+    const html = renderMetaTags([{ title: "Hello" }]);
+    expect(html).toContain("<title>Hello</title>");
+  });
+  test("renders <meta name> tag", () => {
+    const html = renderMetaTags([{ name: "description", content: "A desc" }]);
+    expect(html).toContain('name="description"');
+    expect(html).toContain('content="A desc"');
+  });
+  test("renders <meta property> tag", () => {
+    const html = renderMetaTags([{ property: "og:title", content: "OG" }]);
+    expect(html).toContain('property="og:title"');
+    expect(html).toContain('content="OG"');
+  });
+  test("escapes HTML in title", () => {
+    const html = renderMetaTags([{ title: "<script>alert(1)</script>" }]);
+    expect(html).not.toContain("<script>");
+    expect(html).toContain("&lt;script&gt;");
+  });
+  test("returns empty string for empty input", () => {
+    expect(renderMetaTags([])).toBe("");
+  });
+});

package/src/__tests__/scanner.test.ts ADDED Viewed

@@ -0,0 +1,58 @@
+import { test, expect, describe } from "bun:test";
+import { filePathToPattern, pathToSegments } from "../server/scanner.ts";
+describe("filePathToPattern", () => {
+  test("_index maps to empty pattern (root index)", () => {
+    expect(filePathToPattern("routes/_index.tsx")).toBe("");
+  });
+  test("about.tsx → 'about'", () => {
+    expect(filePathToPattern("routes/about.tsx")).toBe("about");
+  });
+  test("[id].tsx → '[id]'", () => {
+    expect(filePathToPattern("routes/blog/[id].tsx")).toBe("blog/[id]");
+  });
+  test("[...slug].tsx → 'docs/[...slug]'", () => {
+    expect(filePathToPattern("routes/docs/[...slug].tsx")).toBe("docs/[...slug]");
+  });
+  test("nested _index → parent pattern", () => {
+    expect(filePathToPattern("routes/blog/_index.tsx")).toBe("blog");
+  });
+  test("strips .ts extension too", () => {
+    expect(filePathToPattern("routes/api/data.ts")).toBe("api/data");
+  });
+});
+describe("pathToSegments", () => {
+  test("empty pattern → empty segments", () => {
+    expect(pathToSegments("")).toEqual([]);
+  });
+  test("static segment", () => {
+    expect(pathToSegments("about")).toEqual(["about"]);
+  });
+  test("[id] → param segment", () => {
+    expect(pathToSegments("blog/[id]")).toEqual(["blog", { param: "id" }]);
+  });
+  test("[...slug] → catchAll segment", () => {
+    expect(pathToSegments("docs/[...slug]")).toEqual(["docs", { catchAll: "slug" }]);
+  });
+  test("nested static path", () => {
+    expect(pathToSegments("a/b/c")).toEqual(["a", "b", "c"]);
+  });
+  test("mixed static and param", () => {
+    expect(pathToSegments("users/[id]/posts")).toEqual([
+      "users",
+      { param: "id" },
+      "posts",
+    ]);
+  });
+});

package/src/__tests__/session.test.ts ADDED Viewed

@@ -0,0 +1,103 @@
+import { test, expect, describe } from "bun:test";
+import { createCookieSession } from "../server/session.ts";
+const sessionStorage = createCookieSession({
+  name: "__test",
+  secrets: ["secret-one", "secret-two"],
+  secure: false,
+  sameSite: "Lax",
+});
+describe("createCookieSession — getSession", () => {
+  test("returns empty session for null cookie", async () => {
+    const s = await sessionStorage.getSession(null);
+    expect(s.get("user")).toBeUndefined();
+    expect(s.has("user")).toBe(false);
+  });
+  test("returns empty session for empty string cookie", async () => {
+    const s = await sessionStorage.getSession("");
+    expect(s.has("anything")).toBe(false);
+  });
+  test("returns empty session for missing cookie name", async () => {
+    const s = await sessionStorage.getSession("other=value");
+    expect(s.has("x")).toBe(false);
+  });
+  test("returns empty session for tampered signature", async () => {
+    const s1 = await sessionStorage.getSession(null);
+    s1.set("user", { id: 1 });
+    const cookie = await sessionStorage.commitSession(s1);
+    // Tamper: replace last char of cookie value
+    const tampered = cookie.replace(/=([^;]+)/, (_, val) => `=${val.slice(0, -1)}X`);
+    const s2 = await sessionStorage.getSession(tampered);
+    expect(s2.has("user")).toBe(false);
+  });
+});
+describe("createCookieSession — commitSession + roundtrip", () => {
+  test("round-trips session data through cookie", async () => {
+    const s1 = await sessionStorage.getSession(null);
+    s1.set("userId", 42);
+    s1.set("role", "admin");
+    const cookieHeader = await sessionStorage.commitSession(s1);
+    // Extract just the Set-Cookie value (first segment before ";")
+    const cookieValue = cookieHeader.split(";")[0];
+    const s2 = await sessionStorage.getSession(cookieValue);
+    expect(s2.get("userId")).toBe(42);
+    expect(s2.get("role")).toBe("admin");
+  });
+  test("includes HttpOnly in Set-Cookie string", async () => {
+    const s = await sessionStorage.getSession(null);
+    const cookie = await sessionStorage.commitSession(s);
+    expect(cookie).toContain("HttpOnly");
+  });
+  test("includes SameSite=Lax in Set-Cookie string", async () => {
+    const s = await sessionStorage.getSession(null);
+    const cookie = await sessionStorage.commitSession(s);
+    expect(cookie).toContain("SameSite=Lax");
+  });
+  test("includes Max-Age when opts.maxAge provided", async () => {
+    const s = await sessionStorage.getSession(null);
+    const cookie = await sessionStorage.commitSession(s, { maxAge: 3600 });
+    expect(cookie).toContain("Max-Age=3600");
+  });
+  test("secret rotation: old secret still verifies", async () => {
+    const oldStorage = createCookieSession({
+      name: "__test",
+      secrets: ["secret-two"], // only the old secret
+      secure: false,
+    });
+    const s1 = await oldStorage.getSession(null);
+    s1.set("x", "y");
+    const cookie = await oldStorage.commitSession(s1);
+    // New storage has new secret first, old secret second (rotation)
+    const newStorage = createCookieSession({
+      name: "__test",
+      secrets: ["secret-one", "secret-two"],
+      secure: false,
+    });
+    const cookieValue = cookie.split(";")[0];
+    const s2 = await newStorage.getSession(cookieValue);
+    expect(s2.get("x")).toBe("y");
+  });
+});
+describe("Session methods", () => {
+  test("set / get / has / delete", async () => {
+    const s = await sessionStorage.getSession(null);
+    s.set("key", "value");
+    expect(s.has("key")).toBe(true);
+    expect(s.get("key")).toBe("value");
+    s.delete("key");
+    expect(s.has("key")).toBe(false);
+    expect(s.get("key")).toBeUndefined();
+  });
+});

package/src/build/bundler.ts ADDED Viewed

@@ -0,0 +1,75 @@
+import { join } from "node:path";
+import { rename } from "node:fs/promises";
+import type { BractJSConfig } from "../server/serve.ts";
+import { scanRoutes } from "../server/scanner.ts";
+import { contentHash } from "./hash.ts";
+import { generateManifest, writeManifest } from "./manifest.ts";
+import { serverOnlyPlugin, clientEnvPlugin } from "./env-plugin.ts";
+import { buildDefines } from "./defines.ts";
+import { writeRouteTypes } from "../codegen/route-codegen.ts";
+import { useClientStubPlugin, useServerProxyPlugin } from "./directives.ts";
+export async function runBuild(config: BractJSConfig): Promise<void> {
+  const appDir = config.appDir ?? "./app";
+  // ── 0. Codegen — typed routes ───────────────────────────────────────────
+  await writeRouteTypes(appDir);
+  const routes = await scanRoutes(appDir);
+  const routeFilePaths = routes.map((r) => r.filePath);
+  const rootFilePath = join(appDir, "root.tsx");
+  // ── 1. Server bundle ────────────────────────────────────────────────────
+  const serverResult = await Bun.build({
+    entrypoints: ["src/server/index.ts"],
+    target: "bun",
+    outdir: "build/server",
+    sourcemap: config.sourcemap ?? "external",
+    plugins: [useClientStubPlugin],
+  });
+  if (!serverResult.success) throw new AggregateError(serverResult.logs, "Server build failed");
+  // ── 2. Client bundle (code-split) ───────────────────────────────────────
+  const clientResult = await Bun.build({
+    entrypoints: ["src/client/entry.tsx", rootFilePath, ...routeFilePaths],
+    target: "browser",
+    splitting: true,
+    outdir: "build/client",
+    // No publicPath: relative chunk refs work correctly when files are served
+    // at URLs matching their outdir structure (e.g. /build/client/chunk-xxx.js).
+    minify: config.minify ?? true,
+    sourcemap: config.sourcemap ?? "external",
+    define: buildDefines(config),
+    plugins: [serverOnlyPlugin, useServerProxyPlugin, clientEnvPlugin(config.clientEnv ?? [], Bun.env as Record<string, string>)],
+  });
+  if (!clientResult.success) throw new AggregateError(clientResult.logs, "Client build failed");
+  // ── 3. Hash + rename output files ──────────────────────────────────────
+  const routeChunks = new Map<string, string>();
+  let clientEntry = "";
+  let rootChunk: string | undefined;
+  for (const artifact of clientResult.outputs) {
+    if (artifact.kind !== "chunk" && artifact.kind !== "entry-point") continue;
+    const hash = await contentHash(artifact.path);
+    const ext = artifact.path.slice(artifact.path.lastIndexOf("."));
+    const base = artifact.path.slice(0, artifact.path.lastIndexOf("."));
+    const hashedPath = `${base}.${hash}${ext}`;
+    await rename(artifact.path, hashedPath);
+    const publicPath = "/" + hashedPath.replace(/^build\//, "build/");
+    if (artifact.kind === "entry-point" && artifact.path.includes("entry")) {
+      clientEntry = publicPath;
+    } else if (artifact.kind === "entry-point" && artifact.path.includes("root")) {
+      rootChunk = publicPath;
+    } else {
+      // Map route file path back to URL pattern
+      const matched = routes.find((r) => artifact.path.includes(r.filePath.replace("./", "")));
+      if (matched) routeChunks.set(matched.urlPattern, publicPath);
+    }
+  }
+  // ── 4. Write manifest ──────────────────────────────────────────────────
+  const manifest = generateManifest({ clientEntry, rootChunk, routeChunks });
+  await writeManifest(manifest, "build");
+  console.log("[bract] build complete →", Object.keys(manifest.routes).length, "routes");
+}

package/src/build/defines.ts ADDED Viewed

@@ -0,0 +1,16 @@
+import type { BractJSConfig } from "../server/serve.ts";
+/**
+ * Builds the `define` map passed to Bun.build() for the client bundle.
+ * Always injects process.env.NODE_ENV = "production".
+ * For each key in config.clientEnv, injects process.env.KEY = value from Bun.env.
+ */
+export function buildDefines(config: Pick<BractJSConfig, "clientEnv">): Record<string, string> {
+  const defines: Record<string, string> = {
+    "process.env.NODE_ENV": JSON.stringify("production"),
+  };
+  for (const key of config.clientEnv ?? []) {
+    defines[`process.env.${key}`] = JSON.stringify(Bun.env[key] ?? "");
+  }
+  return defines;
+}