@pylonsync/functions 0.11.6 → 0.12.0

package/src/runtime.ts

@@ -22,6 +22,7 @@ import type {
   EmailOptions,
   EmailSender,
   Files,
+  Shards,
   Stream,
   Scheduler,
   Llm,
@@ -46,6 +47,8 @@ import { normalizeAuthClaims } from "./auth";
 import { makeRequireMember } from "./member";
 import { isDevMode } from "./ssr-runtime";
 import { validateArgs } from "./validators";
+import { serverBundle } from "./server-bundle";
+import { fenceStdout } from "./stdout-fence";
 import { readdirSync } from "fs";
 import { join, basename } from "path";
 
@@ -111,61 +114,6 @@ function send(msg: Record<string, unknown>): void {
   }
 }
 
-/**
- * Redirect console.* from user code to stderr so handlers can't accidentally
- * emit a line that looks like a protocol frame and confuse the Rust reader.
- *
- * Before this guard, a handler calling `console.log('{"type":"return",...}')`
- * — either intentionally or by logging an object shaped that way — would be
- * parsed by the host as a real protocol message. Moving all console output
- * to stderr keeps stdout reserved for NDJSON protocol frames only.
- *
- * The original console methods are saved on the console object as
- * `__stdoutLog` etc. in case the runtime itself needs to write diagnostics
- * to stdout for some reason (it currently doesn't).
- */
-function fenceStdout(): void {
-  const toStderr = (prefix: string) => (...args: unknown[]) => {
-    const line = args
-      .map((a) => {
-        if (typeof a === "string") return a;
-        // Error: JSON.stringify yields `{}` because message/stack are
-        // non-enumerable. That made `console.error("x:", err)` log as `x: {}`,
-        // hiding the real failure from operators. Unwrap by hand.
-        if (a instanceof Error) {
-          const parts = [a.stack || `${a.name}: ${a.message}`];
-          const code = (a as { code?: unknown }).code;
-          if (code !== undefined) parts.push(`code=${String(code)}`);
-          const cause = (a as { cause?: unknown }).cause;
-          if (cause !== undefined) {
-            try {
-              parts.push(`cause=${cause instanceof Error ? cause.stack || cause.message : JSON.stringify(cause)}`);
-            } catch {
-              parts.push(`cause=${String(cause)}`);
-            }
-          }
-          return parts.join(" ");
-        }
-        try {
-          return JSON.stringify(a);
-        } catch {
-          return String(a);
-        }
-      })
-      .join(" ");
-    Bun.write(Bun.stderr, `${prefix}${line}\n`);
-  };
-  // Intentional: we want console.* for user handlers to go to stderr.
-  // Overwrite the globals before any user code is loaded.
-  const c = globalThis.console as unknown as Record<string, unknown>;
-  c.__stdoutLog = c.log;
-  c.log = toStderr("");
-  c.info = toStderr("");
-  c.warn = toStderr("[warn] ");
-  c.error = toStderr("[error] ");
-  c.debug = toStderr("[debug] ");
-}
-
 // ---------------------------------------------------------------------------
 // Single reader + dispatcher
 // ---------------------------------------------------------------------------
@@ -575,6 +523,21 @@ export function buildDbReader(callId: string, ssrRead = false): DbReader {
  * op_id) is correct here: concurrent calls queue settle-chained on the one
  * call_id, matching how ctx.runQuery behaves inside a function.
  */
+/** `ctx.shards` — shard tickets, signed host-side. */
+function buildShards(callId: string): Shards {
+  return {
+    async ticket(shardId, opts) {
+      return rpc(callId, {
+        type: "sign_shard_ticket",
+        shard: shardId,
+        subscriber_id: opts?.subscriberId,
+        claims: opts?.claims ?? {},
+        ttl_secs: opts?.ttlSecs,
+      }) as Promise<string>;
+    },
+  };
+}
+
 /** `ctx.files` — signed download URLs, minted host-side. */
 function buildFiles(callId: string): Files {
   return {
@@ -1192,6 +1155,7 @@ function buildActionCtx(
       return err;
     },
     files: buildFiles(callId),
+    shards: buildShards(callId),
     // Actions have no ctx.db; read membership via the built-in internal query.
     requireMember: makeRequireMember(auth.userId, (entity, filter) =>
       rpc(callId, {
@@ -1344,6 +1308,7 @@ async function handleCall(msg: CallMessage): Promise<void> {
           reader.query(entity, { ...filter, $limit: 1 }),
         ),
         files: buildFiles(msg.call_id),
+        shards: buildShards(msg.call_id),
       };
       break;
     }
@@ -1368,6 +1333,7 @@ async function handleCall(msg: CallMessage): Promise<void> {
           writer.query(entity, { ...filter, $limit: 1 }),
         ),
         files: buildFiles(msg.call_id),
+        shards: buildShards(msg.call_id),
       };
       break;
     }
@@ -1474,6 +1440,30 @@ function firstStackFrame(err: unknown): string {
 // Startup: scan functions dir, send ready, then start reader loop
 // ---------------------------------------------------------------------------
 
+/**
+ * The `.ts` / `.js` modules directly inside `dir`, each with its name (file
+ * name without extension) and a loader. A missing directory yields none: a
+ * pure-SSR app has no `functions/`, and most apps have no `workflows/`. The
+ * runner must still send `ready` and serve renders in that case.
+ */
+function listModuleFiles(
+  dir: string,
+): Array<{ name: string; file: string; load: () => Promise<any> }> {
+  let files: string[];
+  try {
+    files = readdirSync(dir).filter(
+      (f) => f.endsWith(".ts") || f.endsWith(".js"),
+    );
+  } catch {
+    return [];
+  }
+  return files.map((file) => ({
+    name: basename(file, file.endsWith(".ts") ? ".ts" : ".js"),
+    file,
+    load: () => import(join(dir, file)),
+  }));
+}
+
 async function main() {
   // Fence user `console.*` away from stdout BEFORE any user code is
   // imported — the import side-effects alone could print a stray line
@@ -1481,27 +1471,21 @@ async function main() {
   fenceStdout();
 
   const fnDir = process.argv[2] || "./functions";
+  const bundle = serverBundle();
 
-  let files: string[];
-  try {
-    files = readdirSync(fnDir).filter(
-      (f) => f.endsWith(".ts") || f.endsWith(".js")
-    );
-  } catch {
-    // No `functions/` directory. Legitimate for a pure-SSR app (file-based
-    // `app/**/page.tsx` routes + entity CRUD, no server functions) — the host
-    // still spawns this runner to execute SSR renders. Load zero functions and
-    // fall through so we send `ready` AND start the reader loop; returning here
-    // would leave the runner unable to serve renders (silent 404s).
-    files = [];
-  }
+  const fnSources = bundle
+    ? Object.keys(bundle.functions).map((name) => ({
+        name,
+        file: `${name} (bundled)`,
+        load: bundle.functions[name],
+      }))
+    : listModuleFiles(join(process.cwd(), fnDir));
 
   const { isAgentDefinition, AGENT_MARKER } = await import("./agent");
   let agentsPresent = false;
-  for (const file of files) {
-    const name = basename(file, file.endsWith(".ts") ? ".ts" : ".js");
+  for (const { name, file, load } of fnSources) {
     try {
-      const mod = await import(join(process.cwd(), fnDir, file));
+      const mod = await load();
       const def = mod.default as FnDefinition | undefined;
       // Runtime shape check — a misnamed/malformed export should
       // log + skip, not crash the loader. TS narrows `def.handler`
@@ -1547,18 +1531,16 @@ async function main() {
   );
   type WorkflowDefinition = import("./workflows").WorkflowDefinition;
   const workflowRegistry = new Map<string, WorkflowDefinition>();
-  const wfDir = join(process.cwd(), "workflows");
-  let wfFiles: string[] = [];
-  try {
-    wfFiles = readdirSync(wfDir).filter(
-      (f) => f.endsWith(".ts") || f.endsWith(".js"),
-    );
-  } catch {
-    // No workflows/ directory — the common case; declare nothing.
-  }
-  for (const file of wfFiles) {
+  const wfSources = bundle
+    ? Object.keys(bundle.workflows).map((name) => ({
+        name,
+        file: `${name} (bundled)`,
+        load: bundle.workflows[name],
+      }))
+    : listModuleFiles(join(process.cwd(), "workflows"));
+  for (const { file, load } of wfSources) {
     try {
-      const mod = await import(join(wfDir, file));
+      const mod = await load();
       const def = mod.default;
       if (isWorkflowDefinition(def)) {
         if (workflowRegistry.has(def.name)) {

package/src/server-bundle.test.ts

@@ -0,0 +1,89 @@
+// SSR module lookups in a production server bundle.
+//
+// An artifact has no app/ source files, so every lookup that checks the disk
+// in source mode (boundary walk, route-group dirs, layout chain, module
+// import) must answer from the bundle's module registry instead. These run
+// the lookups with a registry set and a cwd that holds no files, and expect
+// the same answers the source-mode tests get from a real tree.
+
+import { afterAll, afterEach, expect, test } from "bun:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { moduleKey, setServerBundle, type PylonServerBundle } from "./server-bundle";
+import { findBoundaryIn, importModule, moduleExistsIn } from "./ssr-runtime";
+
+const EMPTY_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "pylon-bundle-lookup-"));
+
+/** Set a registry with one loader per key. Returns the module namespaces the
+ *  loaders resolve to, and how many times each loader ran. */
+function withModules(keys: string[]): { ns: Record<string, any>; loads: Record<string, number> } {
+  const ns: Record<string, any> = {};
+  const loads: Record<string, number> = {};
+  const modules: PylonServerBundle["modules"] = {};
+  for (const k of keys) {
+    ns[k] = { default: () => k };
+    loads[k] = 0;
+    modules[k] = async () => {
+      loads[k] += 1;
+      return ns[k];
+    };
+  }
+  const bundle: PylonServerBundle = {
+    functions: {},
+    workflows: {},
+    modules,
+    react: null,
+    reactDomServer: null,
+    clientDir: "client",
+    ogAssets: { resvgWasm: "", interRegular: "", interSemiBold: "" },
+  };
+  setServerBundle(bundle);
+  return { ns, loads };
+}
+
+afterEach(() => {
+  delete (globalThis as any).__PYLON_SERVER_BUNDLE__;
+});
+afterAll(() => fs.rmSync(EMPTY_DIR, { recursive: true, force: true }));
+
+test("moduleKey normalizes separators, a leading ./, and extensions", () => {
+  expect(moduleKey(".\\app\\blog\\page.tsx")).toBe("app/blog/page");
+  expect(moduleKey("app/page")).toBe("app/page");
+});
+
+test("moduleExistsIn answers from the registry, not the disk", () => {
+  withModules(["app/layout", "app/blog/page"]);
+  expect(moduleExistsIn(fs, path, EMPTY_DIR, "app", "layout")).toBe(true);
+  expect(moduleExistsIn(fs, path, EMPTY_DIR, "app/blog", "page")).toBe(true);
+  expect(moduleExistsIn(fs, path, EMPTY_DIR, "app/blog", "layout")).toBe(false);
+});
+
+test("the boundary walk finds the nearest boundary, through route groups", () => {
+  withModules([
+    "app/not-found",
+    "app/(shop)/cart/not-found",
+    "app/(shop)/cart/items/page",
+    "app/(marketing)/error",
+    "app/blog/page",
+  ]);
+  expect(findBoundaryIn(fs, path, EMPTY_DIR, "app/(shop)/cart/items/page", "not-found")).toBe(
+    "app/(shop)/cart/not-found",
+  );
+  expect(findBoundaryIn(fs, path, EMPTY_DIR, "app/blog/page", "not-found")).toBe("app/not-found");
+  // A group directly under app/ answers for "/" too.
+  expect(findBoundaryIn(fs, path, EMPTY_DIR, "app/blog/page", "error")).toBe(
+    "app/(marketing)/error",
+  );
+  expect(findBoundaryIn(fs, path, EMPTY_DIR, "app/blog/page", "loading")).toBeNull();
+});
+
+test("importModule loads the bundled module on demand and names a missing one", async () => {
+  const { ns, loads } = withModules(["app/page", "app/layout"]);
+  expect(await importModule(EMPTY_DIR, "app/page")).toBe(ns["app/page"]);
+  // Lookups by key never evaluate a module; only an import does.
+  expect(moduleExistsIn(fs, path, EMPTY_DIR, "app", "layout")).toBe(true);
+  expect(loads).toEqual({ "app/page": 1, "app/layout": 0 });
+  await expect(importModule(EMPTY_DIR, "app/missing")).rejects.toThrow("not in the server bundle");
+});

package/src/server-bundle.ts

@@ -0,0 +1,63 @@
+// The module registry of a production server bundle (`pylon build`).
+//
+// In source mode the runner imports app code by path at run time: function
+// files from `functions/`, workflows from `workflows/`, and page / layout /
+// boundary modules from `app/`. It also resolves `react` from the app's
+// `node_modules`. A production bundle has none of those files. Its generated
+// entry puts a loader for every module in this registry and then starts the
+// runtime. Every loader in this package asks the registry first.
+//
+// The registry holds loaders, not modules, so each module is evaluated when
+// it is first needed, as in source mode: the runtime loads each function
+// with its own try/catch at boot, and a page loads on its first render. A
+// module that throws at the top level fails alone.
+//
+// The entry sets the registry before it imports the runtime, whose top-level
+// `main()` reads it.
+
+/** Loads one bundled module and returns its namespace. */
+export type ModuleLoader = () => Promise<any>;
+
+export interface PylonServerBundle {
+  /** Function name (file name without extension) → module loader. */
+  functions: Record<string, ModuleLoader>;
+  /** Workflow file name (without extension) → module loader. */
+  workflows: Record<string, ModuleLoader>;
+  /** Project-relative, extension-less, "/"-separated module path
+   *  (`app/blog/page`) → module loader. Holds every module under the app
+   *  dir that the SSR runtime can import: pages, layouts, boundaries,
+   *  loading states, route handlers, OG image modules, metadata routes. */
+  modules: Record<string, ModuleLoader>;
+  /** The app's React and React DOM server, as bundled with the pages, so SSR
+   *  renders with the same React instance the page modules import. */
+  react: any;
+  reactDomServer: any;
+  /** Client bundle directory, relative to the artifact root. */
+  clientDir: string;
+  /** Absolute paths of the files the OG image renderer reads at run time.
+   *  In source mode it finds them next to its own source file and in
+   *  `node_modules`; the bundle copies them next to the server output. */
+  ogAssets: {
+    resvgWasm: string;
+    interRegular: string;
+    interSemiBold: string;
+  };
+}
+
+const KEY = "__PYLON_SERVER_BUNDLE__";
+
+export function serverBundle(): PylonServerBundle | null {
+  return ((globalThis as any)[KEY] as PylonServerBundle | undefined) ?? null;
+}
+
+export function setServerBundle(bundle: PylonServerBundle): void {
+  (globalThis as any)[KEY] = bundle;
+}
+
+/** Normalize a module path to the registry key form. */
+export function moduleKey(relPath: string): string {
+  return relPath
+    .replace(/\\/g, "/")
+    .replace(/^\.\//, "")
+    .replace(/\.(tsx?|jsx?)$/, "");
+}

package/src/ssr-client-bundler.ts

@@ -34,6 +34,14 @@
 //   - CSS chunking. No CSS support in SSR yet.
 
 import { buildFonts, readManifestFonts, type ManifestFonts } from "./ssr-fonts";
+import {
+  applyClientCompat,
+  resolveClientCompat,
+  transformCss,
+  type ClientCompat,
+  type ManifestBuildConfig,
+} from "./build-compat";
+import { serverBundle } from "./server-bundle";
 
 type Send = (msg: Record<string, unknown>) => void;
 
@@ -88,7 +96,7 @@ declare const Bun: {
     target?: "browser" | "bun" | "node";
     format?: "esm" | "iife";
     minify?: boolean;
-    sourcemap?: "none" | "inline" | "external";
+    sourcemap?: "none" | "inline" | "external" | "linked";
     define?: Record<string, string>;
     external?: string[];
     splitting?: boolean;
@@ -1149,8 +1157,12 @@ function slugForComponent(component: string): string {
 export interface PylonBundleManifest {
   /** Build identity — bumps every successful build. */
   build_id: string;
-  /** Output root, relative to cwd (always `.pylon/client-build`). */
+  /** Output root, relative to cwd: `.pylon/client-build`, or `client` in a
+   *  `pylon build` artifact. */
   outdir: string;
+  /** core-js polyfill bundle (relative to outdir), loaded before any route
+   *  entry. Present when `build.polyfill` is set and the targets need one. */
+  polyfills?: string;
   /** Public URL prefix the Rust host serves chunks under. */
   public_prefix: string;
   /** routeComponentPath → file + imports for that route. */
@@ -1208,7 +1220,7 @@ async function _prebuiltBundle(): Promise<BuildOutput | null> {
   const pathMod: any = await import("node:path");
   const fs = fsMod.default ?? fsMod;
   const path = pathMod.default ?? pathMod;
-  const outdir = path.join(process.cwd(), ".pylon", "client-build");
+  const outdir = path.join(process.cwd(), clientBuildDir());
   const manifestPath = path.join(outdir, "manifest.json");
   if (!fs.existsSync(manifestPath)) return null;
 
@@ -1269,6 +1281,48 @@ export async function buildClientBundle(
   return _inflightBuild;
 }
 
+/** Default client bundle directory, relative to the project root. */
+export const CLIENT_BUILD_DIR = ".pylon/client-build";
+
+/** The client bundle directory, relative to cwd. A production server bundle
+ *  names its own; source mode uses `CLIENT_BUILD_DIR`. */
+export function clientBuildDir(): string {
+  return serverBundle()?.clientDir ?? CLIENT_BUILD_DIR;
+}
+
+export interface ClientBuildOptions {
+  /** Absolute output directory. Default: `<cwd>/.pylon/client-build`. */
+  outdir?: string;
+  /** The manifest's `outdir` value. Default: `outdir` relative to cwd. A
+   *  `pylon build` artifact sets `client`, its path at run time. */
+  manifestOutdir?: string;
+  /** The `build` block to apply. Default: read from `pylon.manifest.json`,
+   *  except in dev (`NODE_ENV=development`), which applies none. `null`
+   *  applies none. */
+  buildConfig?: ManifestBuildConfig | null;
+  /** Fail on a CSS or font build error instead of shipping without it. */
+  strict?: boolean;
+  /** The app manifest (fonts, build settings). Default
+   *  `<cwd>/pylon.manifest.json`. */
+  manifestPath?: string;
+}
+
+/** The `build` block of `<cwd>/pylon.manifest.json`, if any. */
+export function readManifestBuildConfig(
+  fs: any,
+  path: any,
+  cwd: string,
+): ManifestBuildConfig | undefined {
+  const manifestPath = path.join(cwd, "pylon.manifest.json");
+  if (!fs.existsSync(manifestPath)) return undefined;
+  try {
+    const m = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    return m && typeof m.build === "object" && m.build !== null ? m.build : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 async function _doBuild(appDirRel: string): Promise<BuildOutput> {
   // node:* are available in Bun, but `globalThis.require` is
   // not defined in ESM. Use dynamic import; Bun fast-paths these.
@@ -1300,6 +1354,7 @@ export async function buildTailwind(
   cwd: string,
   outdir: string,
   appDirRel: string,
+  cssTargets?: string[],
 ): Promise<string | null> {
   const globalsPath = path.join(cwd, appDirRel, "globals.css");
   if (!fs.existsSync(globalsPath)) return null;
@@ -1360,7 +1415,13 @@ export async function buildTailwind(
     throw new Error(`tailwindcss build failed (exit ${exitCode}): ${err}`);
   }
 
-  const out = fs.readFileSync(tmpPath, "utf8");
+  let out = fs.readFileSync(tmpPath, "utf8");
+  if (cssTargets && cssTargets.length > 0) {
+    // Hash the TRANSFORMED output (below), so a CSS target change changes
+    // the file name.
+    out = await transformCss(cwd, out, "globals.css", cssTargets);
+    fs.writeFileSync(tmpPath, out, "utf8");
+  }
   let hash = 0;
   for (let i = 0; i < out.length; i++) {
     hash = (hash * 31 + out.charCodeAt(i)) >>> 0;
@@ -1400,7 +1461,20 @@ export async function _doBuildInner(
   path: any,
   cwd: string,
   appDirRel: string,
+  opts: ClientBuildOptions = {},
 ): Promise<BuildOutput> {
+  // Production settings from the manifest's `build` block. Dev builds skip
+  // them: lowering and polyfills cost build time and change nothing a modern
+  // dev browser needs.
+  const buildConfig =
+    opts.buildConfig !== undefined
+      ? opts.buildConfig
+      : process.env.NODE_ENV === "development"
+        ? undefined
+        : readManifestBuildConfig(fs, path, cwd);
+  const compat = resolveClientCompat(buildConfig ?? undefined);
+  const manifestFile = opts.manifestPath ?? path.join(cwd, "pylon.manifest.json");
+  const sourcemap = buildConfig?.sourcemap === true;
   const routes = discoverRoutes(fs, path, cwd, appDirRel);
     if (routes.length === 0) {
       throw new Error(
@@ -1423,7 +1497,7 @@ export async function _doBuildInner(
         }
       }
     }
-    const outdir = path.join(stageDir, "client-build");
+    const outdir = opts.outdir ?? path.join(cwd, CLIENT_BUILD_DIR);
     try {
       fs.rmSync(outdir, { recursive: true, force: true });
     } catch {
@@ -1522,7 +1596,7 @@ export async function _doBuildInner(
       target: "browser",
       format: "esm",
       minify: true,
-      sourcemap: "none",
+      sourcemap: sourcemap ? "linked" : "none",
       splitting: true,
       // The browser has no `process`. React, next-themes, sonner, and most
       // npm UI deps reference `process.env.NODE_ENV` (and migrated Next code
@@ -1574,7 +1648,35 @@ export async function _doBuildInner(
     // Manifest paths are URL paths under `public_prefix` ("/"-separated). The
     // runtime's /_pylon/build/ handler rejects any request with a backslash.
     const toUrlPath = (p: string) => p.replace(/\\/g, "/");
-    const outdirRel = toUrlPath(path.relative(cwd, outdir));
+    const outdirRel =
+      opts.manifestOutdir ?? toUrlPath(path.relative(cwd, outdir));
+
+    // Browser compatibility pass (build.target): lowers syntax, collects
+    // polyfills, and renames the .js outputs. Later steps read the renamed
+    // paths.
+    let outputs: Array<{ path: string; kind: string }> = result.outputs.map(
+      (o) => ({ path: o.path, kind: o.kind }),
+    );
+    let polyfills: string | undefined;
+    if (compat && compat.jsTargets.length > 0) {
+      const jsFiles = outputs
+        .filter((o) => o.path.endsWith(".js"))
+        .map((o) => toUrlPath(path.relative(outdir, o.path)));
+      const res = await applyClientCompat({ fs, path, cwd, outdir, jsFiles, compat });
+      if (res.unsupported.length > 0) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          `[pylon build] build.target includes browsers that cannot run the Pylon client runtime ` +
+            `(it needs ES modules and dynamic import()): ${res.unsupported.join(", ")}`,
+        );
+      }
+      outputs = outputs.map((o) => {
+        const rel = toUrlPath(path.relative(outdir, o.path));
+        const next = res.renamed.get(rel);
+        return next ? { ...o, path: path.join(outdir, next) } : o;
+      });
+      polyfills = res.polyfills;
+    }
     const entriesByStem = new Map<
       string,
       { absPath: string; relPath: string }
@@ -1583,7 +1685,7 @@ export async function _doBuildInner(
       string,
       { absPath: string; relPath: string }
     >();
-    for (const o of result.outputs) {
+    for (const o of outputs) {
       const absPath: string = o.path;
       const relPath = toUrlPath(path.relative(outdir, absPath));
       const base = path.basename(absPath);
@@ -1608,7 +1710,7 @@ export async function _doBuildInner(
     // the binary next to the entries AND into chunks/ so the runtime URL
     // resolves from either an entry or a split chunk.
     try {
-      const referencesLoroWasm = result.outputs.some((o) => {
+      const referencesLoroWasm = outputs.some((o) => {
         if (!o.path.endsWith(".js")) return false;
         try {
           return fs.readFileSync(o.path, "utf8").includes("loro_wasm_bg.wasm");
@@ -1682,6 +1784,7 @@ export async function _doBuildInner(
       outdir: outdirRel,
       public_prefix: "/_pylon/build/",
       routes: {},
+      ...(polyfills ? { polyfills } : {}),
     };
     for (const r of routes) {
       const slug = slugForComponent(r.component);
@@ -1735,7 +1838,7 @@ export async function _doBuildInner(
     // pylon.manifest.json from cwd. It's generated output — commonly
     // gitignored — so when it's absent the bundle still builds but
     // silently loses those features. Say so, loudly, instead.
-    if (!fs.existsSync(path.join(cwd, "pylon.manifest.json"))) {
+    if (!fs.existsSync(manifestFile)) {
       // eslint-disable-next-line no-console
       console.warn(
         "[pylon ssr] pylon.manifest.json not found — building the client " +
@@ -1750,7 +1853,14 @@ export async function _doBuildInner(
     // array so SSR head injection emits `<link rel="stylesheet">`.
     let stylesRel: string | null = null;
     try {
-      const styles = await buildTailwind(fs, path, cwd, outdir, appDirRel);
+      const styles = await buildTailwind(
+        fs,
+        path,
+        cwd,
+        outdir,
+        appDirRel,
+        compat?.cssTargets,
+      );
       if (styles) {
         stylesRel = styles;
         for (const r of Object.values(manifest.routes)) {
@@ -1769,6 +1879,7 @@ export async function _doBuildInner(
         /\u001b\[[0-9;]*m/g,
         "",
       );
+      if (opts.strict) throw new Error(`CSS build failed: ${cssMsg}`);
       manifest.css_error = cssMsg;
       // eslint-disable-next-line no-console
       console.warn(`[pylon ssr] tailwind compile failed: ${cssMsg}`);
@@ -1782,12 +1893,13 @@ export async function _doBuildInner(
     // the prebuilt artifact. A fetch/parse failure degrades to a variable-only
     // entry — it never kills the build.
     try {
-      const declaredFonts = readManifestFonts(fs, path, cwd);
+      const declaredFonts = readManifestFonts(fs, path, cwd, manifestFile);
       if (declaredFonts.length > 0) {
         const builtFonts = await buildFonts(fs, path, cwd, outdir, declaredFonts);
         if (builtFonts) manifest.fonts = builtFonts;
       }
     } catch (fErr: any) {
+      if (opts.strict) throw new Error(`font build failed: ${fErr?.message ?? fErr}`);
       // eslint-disable-next-line no-console
       console.warn(`[pylon ssr] font build failed: ${fErr?.message ?? fErr}`);
     }
@@ -1863,7 +1975,7 @@ export async function getManifest(): Promise<PylonBundleManifest> {
   const fs = fsMod.default ?? fsMod;
   const path = pathMod.default ?? pathMod;
   const cwd = process.cwd();
-  const manifestPath = path.join(cwd, ".pylon", "client-build", "manifest.json");
+  const manifestPath = path.join(cwd, clientBuildDir(), "manifest.json");
 
   if (fs.existsSync(manifestPath)) {
     const stat = fs.statSync(manifestPath);

package/src/ssr-fonts.ts

@@ -621,8 +621,8 @@ export function readManifestFonts(
   fs: any,
   path: any,
   cwd: string,
+  manifestPath: string = path.join(cwd, "pylon.manifest.json"),
 ): ManifestFontInput[] {
-  const manifestPath = path.join(cwd, "pylon.manifest.json");
   if (!fs.existsSync(manifestPath)) return [];
   try {
     const m = JSON.parse(fs.readFileSync(manifestPath, "utf8"));