@pylonsync/functions 0.3.294 → 0.3.295

package/dist/ssr-client-bundler.d.ts

@@ -58,6 +58,14 @@ export interface BuildOutput {
  * from `getManifest` (in-process SSR path).
  */
 export declare function buildClientBundle(appDirRel?: string): Promise<BuildOutput>;
+/**
+ * Compile `app/globals.css` through Tailwind v4 (`@tailwindcss/cli`)
+ * if both are present. Returns the relative output path (under
+ * outdir) when produced, else null. Skipped silently when the
+ * project hasn't opted in to Tailwind — we don't want every SSR
+ * project to need Tailwind installed.
+ */
+export declare function buildTailwind(fs: any, path: any, cwd: string, outdir: string, appDirRel: string): Promise<string | null>;
 /**
  * Return the bundle manifest. If a fresh manifest exists on disk,
  * use it (caching parse output across requests). Otherwise build

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pylonsync/functions",
-  "version": "0.3.294",
+  "version": "0.3.295",
   "description": "TypeScript function runtime for pylon — defines server-side queries, mutations, and actions.",
   "type": "module",
   "main": "src/index.ts",

package/src/ssr-client-bundler.test.ts

@@ -23,6 +23,7 @@ import * as os from "node:os";
 
 import {
   buildClientBundle,
+  buildTailwind,
   type PylonBundleManifest,
 } from "./ssr-client-bundler";
 import { nearestBoundaryComponent } from "./ssr-client-boundary";
@@ -379,3 +380,53 @@ describe("client boundary is wired into the build", () => {
     expect(allShared).toContain("getDerivedStateFromError");
   });
 });
+
+describe("Tailwind compile is concurrency-safe", () => {
+  // Regression: `pylon dev` warms the SSR bundle in one runner process while the
+  // first requests drive their own rebuild in another. Both compiled Tailwind to
+  // a SHARED temp file (`.styles.build.css`); whichever renamed it first won, and
+  // the other's `renameSync` ENOENT'd → the compile threw → the route shipped
+  // with no `css` → the page rendered UNSTYLED. Reproduced ~25% of cold boots
+  // under concurrent load. The fix gives each compile a process-unique temp path
+  // and publishes (rename) before pruning others. Drive several compiles at once
+  // against one outdir and prove they all succeed.
+  test("concurrent compiles against one outdir all produce the stylesheet", async () => {
+    const root = makeFixture(
+      { "page.tsx": PAGE_BODY("Home") },
+      { "layout.tsx": LAYOUT_BODY },
+    );
+    tempDir = root; // registers it for afterEach cleanup
+    // Opt into Tailwind: a real globals.css the CLI can compile. `@tailwindcss/cli`
+    // + `tailwindcss` resolve through the fixture's node_modules symlink (it points
+    // at examples/ssr-hello/node_modules, which declares both).
+    fs.writeFileSync(
+      path.join(root, "app", "globals.css"),
+      '@import "tailwindcss";\n@source "../app/**/*.{tsx,ts,jsx,js}";\n',
+      "utf8",
+    );
+    originalCwd = process.cwd();
+    process.chdir(root);
+
+    const outdir = path.join(root, ".pylon", "client-build");
+    fs.mkdirSync(outdir, { recursive: true });
+
+    // Old code: at least one of these rejects with the rename ENOENT.
+    const results = await Promise.all(
+      Array.from({ length: 4 }, () =>
+        buildTailwind(fs, path, root, outdir, "app"),
+      ),
+    );
+
+    for (const name of results) {
+      expect(name).toMatch(/^styles-[a-z0-9]+\.css$/);
+      expect(fs.existsSync(path.join(outdir, name as string))).toBe(true);
+    }
+    // Deterministic output → identical hash → one published asset, no leftover
+    // temp files stranded in the outdir.
+    expect(new Set(results).size).toBe(1);
+    const stranded = (fs.readdirSync(outdir) as string[]).filter((f) =>
+      f.startsWith(".styles.build."),
+    );
+    expect(stranded).toEqual([]);
+  }, 20_000);
+});

package/src/ssr-client-bundler.ts

@@ -868,6 +868,13 @@ async function _doBuild(appDirRel: string): Promise<BuildOutput> {
   return _doBuildInner(fs, path, cwd, appDirRel);
 }
 
+// Monotonic per-process counter for the Tailwind temp filename. `pylon dev`
+// warms the SSR bundle in one runner process while incoming requests can drive
+// their own rebuild in another, so two `buildTailwind` calls may run against the
+// same outdir at once. Combined with the pid it gives every compile a unique
+// temp path, so concurrent builds never rename each other's file away.
+let _styleBuildSeq = 0;
+
 /**
  * Compile `app/globals.css` through Tailwind v4 (`@tailwindcss/cli`)
  * if both are present. Returns the relative output path (under
@@ -875,7 +882,10 @@ async function _doBuild(appDirRel: string): Promise<BuildOutput> {
  * project hasn't opted in to Tailwind — we don't want every SSR
  * project to need Tailwind installed.
  */
-async function buildTailwind(
+// Exported for the concurrency regression test (ssr-client-bundler.test.ts):
+// it drives several compiles at once against one outdir to prove they no longer
+// race on a shared temp file.
+export async function buildTailwind(
   fs: any,
   path: any,
   cwd: string,
@@ -915,7 +925,15 @@ async function buildTailwind(
   //
   // Spawn the CLI. Bun is already running; reuse it as the interpreter so the
   // user doesn't need node on PATH.
-  const tmpPath = path.join(outdir, ".styles.build.css");
+  // PROCESS-UNIQUE temp file. A shared name (`.styles.build.css`) let a
+  // concurrent build rename the file out from under this one — its `renameSync`
+  // then ENOENT'd, the compile threw, the route shipped with no `css`, and the
+  // page rendered UNSTYLED. Worst under cold-boot traffic (a warm build racing
+  // the first requests), which is exactly when it must not happen.
+  const tmpPath = path.join(
+    outdir,
+    `.styles.build.${process.pid}.${_styleBuildSeq++}.css`,
+  );
   const proc = (Bun as any).spawn({
     cmd: [process.execPath, cliPath, "-i", globalsPath, "-o", tmpPath, "--minify"],
     cwd,
@@ -925,6 +943,11 @@ async function buildTailwind(
   const exitCode = await proc.exited;
   if (exitCode !== 0) {
     const err = await new Response(proc.stderr).text();
+    try {
+      fs.rmSync(tmpPath, { force: true });
+    } catch {
+      /* nothing to clean up */
+    }
     throw new Error(`tailwindcss build failed (exit ${exitCode}): ${err}`);
   }
 
@@ -942,19 +965,22 @@ async function buildTailwind(
   const stylesName = `styles-${hash.toString(36).padStart(8, "0")}.css`;
   const outPath = path.join(outdir, stylesName);
 
-  // Drop previous styles-*.css so the outdir doesn't accumulate stale builds
-  // (the filename now changes on every class change), then move the freshly
-  // compiled file into place.
+  // Publish our freshly-compiled CSS FIRST (rename replaces atomically on
+  // POSIX, so the asset is never momentarily absent), THEN prune OTHER stale
+  // styles-*.css. The old order pruned before renaming, so a concurrent build
+  // could delete the file we were about to publish; pruning our own name could
+  // delete a concurrent winner's identical output. Excluding `stylesName` keeps
+  // both safe while still clearing builds from earlier class changes.
+  fs.renameSync(tmpPath, outPath);
   try {
     for (const f of fs.readdirSync(outdir) as string[]) {
-      if (f.startsWith("styles-") && f.endsWith(".css")) {
+      if (f.startsWith("styles-") && f.endsWith(".css") && f !== stylesName) {
         fs.rmSync(path.join(outdir, f), { force: true });
       }
     }
   } catch {
     /* outdir may not be listable on the first build — ignore */
   }
-  fs.renameSync(tmpPath, outPath);
   return stylesName;
 }