@pylonsync/functions 0.3.278 → 0.3.280

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pylonsync/functions",
-  "version": "0.3.278",
+  "version": "0.3.280",
   "description": "TypeScript function runtime for pylon — defines server-side queries, mutations, and actions.",
   "type": "module",
   "main": "src/index.ts",
@@ -10,7 +10,8 @@
       "types": "./src/index.ts",
       "default": "./src/index.ts"
     },
-    "./runtime": "./src/runtime.ts"
+    "./runtime": "./src/runtime.ts",
+    "./client-bundler": "./src/ssr-client-bundler.ts"
   },
   "bin": {
     "pylon-functions-runtime": "src/runtime.ts"

package/src/ssr-client-bundler.ts

@@ -742,6 +742,48 @@ export interface BuildOutput {
  */
 let _inflightBuild: Promise<BuildOutput> | null = null;
 
+/**
+ * If a complete prebuilt client-build is present on disk (Pylon Cloud: shipped
+ * in the artifact by the builder, marked with `.prebuilt` written last), return
+ * its manifest + outdir so callers skip the rebuild entirely. Returns null when
+ * there's no prebuilt bundle (dev, or a deploy that didn't pre-build) — callers
+ * then build normally.
+ */
+async function _prebuiltBundle(): Promise<BuildOutput | null> {
+  const fsMod: any = await import("node:fs");
+  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 manifestPath = path.join(outdir, "manifest.json");
+  if (!fs.existsSync(manifestPath)) return null;
+
+  // Reuse a prebuilt bundle when it's explicitly marked (`.prebuilt`) OR when
+  // its manifest already targets an ABSOLUTE (CDN) `public_prefix`. The builder
+  // bakes an absolute prefix only when it pre-built for the CDN, and it
+  // published the hashed assets under THOSE exact hashes — so the runtime must
+  // serve this exact manifest verbatim (a local rebuild emits different hashes
+  // that would 404 on the CDN). The manifest is a regular file that always
+  // ships with the build; keying on it (not just the `.prebuilt` dotfile, which
+  // can be dropped in transit) makes reuse robust. A same-origin
+  // `/_pylon/build/` manifest is a normal dev/local build → don't short-circuit
+  // (let dev hot-rebuild).
+  const marker = path.join(outdir, ".prebuilt");
+  if (fs.existsSync(marker)) return { manifestPath, outdir };
+  try {
+    const m = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    if (
+      typeof m.public_prefix === "string" &&
+      /^https?:\/\//i.test(m.public_prefix)
+    ) {
+      return { manifestPath, outdir };
+    }
+  } catch {
+    /* unreadable/partial manifest → fall through and rebuild */
+  }
+  return null;
+}
+
 /**
  * Run the bundler in-process and return the manifest path + outdir.
  * Used from `handleBundleClient` (protocol RPC path from Rust) AND
@@ -750,6 +792,18 @@ let _inflightBuild: Promise<BuildOutput> | null = null;
 export async function buildClientBundle(
   appDirRel: string = "app",
 ): Promise<BuildOutput> {
+  // Prebuilt bundle (Pylon Cloud): the builder already produced a complete,
+  // content-hashed client-build with `public_prefix` baked to the CDN, shipped
+  // it in the artifact, and published the hashed assets to the CDN. Reuse it
+  // verbatim instead of rebuilding on the app machine — rebuilding would (a)
+  // burn cold-start CPU on every machine on every boot and (b) risk emitting a
+  // manifest whose hashes don't match the assets already on the CDN. The
+  // `.prebuilt` marker is written LAST by the builder, so a torn/partial copy
+  // is never mistaken for complete. Dev never writes the marker, so local
+  // hot-rebuild is unaffected.
+  const prebuilt = await _prebuiltBundle();
+  if (prebuilt) return prebuilt;
+
   if (_inflightBuild) return _inflightBuild;
   _inflightBuild = (async () => {
     try {
@@ -1212,3 +1266,28 @@ function makeBuildId(): string {
   _buildCounter += 1;
   return `${process.pid.toString(36)}-${Date.now().toString(36)}-${_buildCounter}`;
 }
+
+/**
+ * Base URL/path prepended to every SSR-emitted asset reference (the entry
+ * `<script type="module">`, `<link rel="stylesheet">`, and `modulepreload`s)
+ * and to client-side chunk loads — baked into the bundle manifest as
+ * `public_prefix`.
+ *
+ * Defaults to `/_pylon/build/`, which the Rust host serves from the build's
+ * local `outdir`. That keeps dev and any deploy that doesn't opt in unchanged.
+ *
+ * Set `PYLON_PUBLIC_PREFIX` to an ABSOLUTE base (a CDN / object-storage URL for
+ * this build's content-hashed assets, e.g. `https://assets.pyln.dev/<build>/`)
+ * to serve assets off the app machines entirely. This is what makes hashed
+ * assets survive an artifact prune and resolve IDENTICALLY across every Fly
+ * machine: the entry filename SSR emits becomes an absolute URL that always
+ * exists, instead of a machine-local path a prune/rollover can 404 (the bug
+ * where a stale machine emitted `client-entry-…-<oldhash>.js` after that file
+ * was pruned, breaking hydration). A trailing slash is enforced so
+ * `${prefix}${file}` always joins correctly.
+ */
+function resolvePublicPrefix(): string {
+  const raw = (process.env.PYLON_PUBLIC_PREFIX ?? "").trim();
+  if (!raw) return "/_pylon/build/";
+  return raw.endsWith("/") ? raw : `${raw}/`;
+}

package/src/ssr-runtime.ts

@@ -1018,7 +1018,12 @@ export function buildHydrationTail(args: {
     .replace(/\u2029/g, "\\u2029");
   let tail = `<script id="__PYLON_DATA__" type="application/json">${json}</script>`;
   if (args.manifestRoute) {
-    tail += `<script type="module" src="${args.publicPrefix}${args.manifestRoute.file}"></script>`;
+    // A cross-origin CDN module (`public_prefix` is an absolute http(s) URL) is
+    // fetched in CORS mode; `crossorigin` makes the matching modulepreload
+    // reusable (no double fetch) and surfaces load errors. No-op for the
+    // same-origin `/_pylon/build/` default.
+    const co = /^https?:\/\//i.test(args.publicPrefix) ? " crossorigin" : "";
+    tail += `<script type="module"${co} src="${args.publicPrefix}${args.manifestRoute.file}"></script>`;
   } else {
     tail += `<script>console.warn(${JSON.stringify(`[pylon ssr] hydration disabled: ${args.manifestErr}`)})</script>`;
   }
@@ -1117,11 +1122,12 @@ async function renderBoundaryToClient(
     }
   }
   if (manifestRoute) {
+    const co = /^https?:\/\//i.test(publicPrefix) ? " crossorigin" : "";
     for (const css of manifestRoute.css) {
       headBlob += `<link rel="stylesheet" href="${publicPrefix}${css}">`;
     }
     for (const chunk of manifestRoute.imports) {
-      headBlob += `<link rel="modulepreload" href="${publicPrefix}${chunk}">`;
+      headBlob += `<link rel="modulepreload"${co} href="${publicPrefix}${chunk}">`;
     }
   } else {
     // No per-boundary entry → fall back to the global stylesheet union so the
@@ -1884,11 +1890,12 @@ export async function handleRenderRoute(
     // (it needs the inline __PYLON_DATA__ to have been parsed first).
     let headBlob = "";
     if (preloadManifestRoute) {
+      const co = /^https?:\/\//i.test(preloadPublicPrefix) ? " crossorigin" : "";
       for (const css of preloadManifestRoute.css) {
         headBlob += `<link rel="stylesheet" href="${preloadPublicPrefix}${css}">`;
       }
       for (const chunk of preloadManifestRoute.imports) {
-        headBlob += `<link rel="modulepreload" href="${preloadPublicPrefix}${chunk}">`;
+        headBlob += `<link rel="modulepreload"${co} href="${preloadPublicPrefix}${chunk}">`;
       }
     } else {
       // No per-route client entry. This is the unmatched-URL not-found