@gmickel/gno 1.36.1 → 1.37.1

package/src/serve/spa-bundle-source.ts

@@ -1,12 +1,17 @@
 import type { HTMLBundle, Server } from "bun";
 
-// node:fs/promises — no Bun equivalent for removing a Unix socket pathname.
+// node:fs/promises — no Bun equivalent for unlink of private sockets.
 import { unlink } from "node:fs/promises";
 // node:os — no Bun equivalent for the platform temporary directory.
 import { tmpdir } from "node:os";
-// node:path — no Bun equivalent for joining the socket path.
+// node:path — no Bun path utils.
 import { join } from "node:path";
 
+import {
+  getProductionSpaAssets,
+  type ProductionSpaAssets,
+} from "./spa-production";
+
 type BunServer = Server<unknown>;
 
 export type SpaBundleSource = {
@@ -17,33 +22,109 @@ export type SpaBundleSource = {
 
 const notFound = (): Response => new Response("Not Found", { status: 404 });
 
+const isEnoent = (error: unknown): boolean =>
+  Boolean(
+    error &&
+    typeof error === "object" &&
+    "code" in error &&
+    error.code === "ENOENT"
+  );
+
 /**
- * Host Bun's headerless HTMLBundle surface outside the public listener.
+ * Host Bun's headerless HTML / asset surface outside the public listener.
  *
  * Unix hosts use a private Unix-domain socket, so the raw bundle and generated
  * assets have no TCP origin at all. Windows falls back to an ephemeral
  * loopback listener plus an unguessable entry path. The public server proxies
  * the bytes and applies its normal security envelope before browser delivery.
+ *
+ * Production (`isDev === false`) serves the split SPA snapshot embedded from
+ * `assets/spa-production.json.gz`. Source and compiled executables share that
+ * path so first listen does not wait on `Bun.build`. Compiled binaries also
+ * cannot call `Bun.build` on `/$bunfs` (ENOENT on the virtual root).
+ * Development keeps the live HTMLBundle so HMR still works. Refresh the
+ * snapshot with `bun scripts/build-spa-production.ts`.
  */
-export function createSpaBundleSource(
+export async function createSpaBundleSource(
   bundle: HTMLBundle,
   isDev: boolean
-): SpaBundleSource {
+): Promise<SpaBundleSource> {
   const nonce = crypto.randomUUID().replaceAll("-", "");
   const entryPath = `/__gno_spa_${nonce}`;
+
+  if (isDev) {
+    return hostPrivateSource({
+      entryPath,
+      isDev: true,
+      nonce,
+      routes: { [entryPath]: bundle },
+    });
+  }
+
+  return createSplitProductionSource(entryPath, nonce);
+}
+
+async function createSplitProductionSource(
+  entryPath: string,
+  nonce: string
+): Promise<SpaBundleSource> {
+  const assets = await getProductionSpaAssets();
+  return hostProductionAssets(assets, entryPath, nonce);
+}
+
+async function hostProductionAssets(
+  assets: ProductionSpaAssets,
+  entryPath: string,
+  nonce: string
+): Promise<SpaBundleSource> {
+  const resolve = (pathname: string): Response => {
+    if (pathname === entryPath) {
+      return new Response(assets.html, {
+        headers: { "Content-Type": "text/html;charset=utf-8" },
+      });
+    }
+    const file = assets.files[pathname];
+    if (!file) {
+      return notFound();
+    }
+    return new Response(file.text, {
+      headers: { "Content-Type": file.type },
+    });
+  };
+
+  return hostPrivateSource({
+    entryPath,
+    fetchAsset: resolve,
+    isDev: false,
+    nonce,
+  });
+}
+
+async function hostPrivateSource(options: {
+  entryPath: string;
+  fetchAsset?: (pathname: string) => Response;
+  isDev: boolean;
+  nonce: string;
+  routes?: Record<string, HTMLBundle>;
+}): Promise<SpaBundleSource> {
   let server: BunServer;
   let fetchPrivate: (request: Request) => Promise<Response>;
   let socketPath: string | null = null;
-
-  const routes = { [entryPath]: bundle };
-  const fallback = { fetch: notFound };
+  const fallback = {
+    fetch: (request: Request): Response => {
+      if (!options.fetchAsset) {
+        return notFound();
+      }
+      return options.fetchAsset(new URL(request.url).pathname);
+    },
+  };
 
   if (process.platform === "win32") {
     server = Bun.serve({
+      development: options.isDev,
       hostname: "127.0.0.1",
       port: 0,
-      development: isDev,
-      routes,
+      routes: options.routes,
       ...fallback,
     });
     const origin = `http://127.0.0.1:${server.port}`;
@@ -54,11 +135,11 @@ export function createSpaBundleSource(
       });
     };
   } else {
-    socketPath = join(tmpdir(), `gno-spa-${nonce.slice(0, 20)}.sock`);
+    socketPath = join(tmpdir(), `gno-spa-${options.nonce.slice(0, 20)}.sock`);
     server = Bun.serve({
+      development: options.isDev,
+      routes: options.routes,
       unix: socketPath,
-      development: isDev,
-      routes,
       ...fallback,
     });
     fetchPrivate = async (request): Promise<Response> => {
@@ -72,9 +153,7 @@ export function createSpaBundleSource(
 
   let closed = false;
   return {
-    entryPath,
-    fetch: fetchPrivate,
-    async close(): Promise<void> {
+    close: async (): Promise<void> => {
       if (closed) {
         return;
       }
@@ -84,16 +163,13 @@ export function createSpaBundleSource(
         try {
           await unlink(socketPath);
         } catch (error) {
-          if (
-            !error ||
-            typeof error !== "object" ||
-            !("code" in error) ||
-            error.code !== "ENOENT"
-          ) {
+          if (!isEnoent(error)) {
             throw error;
           }
         }
       }
     },
+    entryPath: options.entryPath,
+    fetch: fetchPrivate,
   };
 }

package/src/serve/spa-production-build.ts

@@ -0,0 +1,176 @@
+// node:fs/promises — no Bun equivalent for mkdir/rm of the temporary SPA
+// outdir, or for recursive directory listing.
+import { mkdir, readdir, rm } from "node:fs/promises";
+// node:os — no Bun equivalent for the platform temporary directory.
+import { tmpdir } from "node:os";
+// node:path — no Bun path utils.
+import { basename, join, relative } from "node:path";
+
+export const ROOT_MOUNT_MARKER = 'getElementById("root")';
+
+export type ProductionSpaFile = {
+  text: string;
+  type: string;
+};
+
+export type ProductionSpaAssets = {
+  files: Record<string, ProductionSpaFile>;
+  html: string;
+  sourceHash: string;
+};
+
+const productionSpaPublicDir = (): string => join(import.meta.dir, "public");
+
+export const productionSpaEntryPath = (): string =>
+  join(productionSpaPublicDir(), "index.html");
+
+/**
+ * SHA-256 hex of every file under `src/serve/public/`, in sorted relative-path
+ * order. Used to detect a stale `assets/spa-production.json.gz` without
+ * comparing Bun.build output (minified symbols and chunk hashes differ
+ * across Bun binaries).
+ */
+export const computeSpaSourceHash = async (): Promise<string> => {
+  const publicDir = productionSpaPublicDir();
+  const entries = await readdir(publicDir, {
+    recursive: true,
+    withFileTypes: true,
+  });
+  const relativePaths: string[] = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+    relativePaths.push(
+      relative(publicDir, join(entry.parentPath, entry.name)).replaceAll(
+        "\\",
+        "/"
+      )
+    );
+  }
+  relativePaths.sort();
+
+  const hasher = new Bun.CryptoHasher("sha256");
+  for (const relativePath of relativePaths) {
+    const bytes = await Bun.file(join(publicDir, relativePath)).bytes();
+    hasher.update(relativePath);
+    hasher.update("\0");
+    hasher.update(String(bytes.byteLength));
+    hasher.update("\0");
+    hasher.update(bytes);
+  }
+  return hasher.digest("hex");
+};
+
+const SCRIPT_TAG_RE = /<script\b[^>]*\bsrc="[^"]+"[^>]*><\/script>/iu;
+const BASE_TAG_RE = /<base\b[^>]*>/iu;
+const CROSSORIGIN_ATTR_RE = /\s+crossorigin(?:=(?:"[^"]*"|'[^']*'))?/gu;
+
+const contentTypeFor = (path: string): string => {
+  if (path.endsWith(".css")) {
+    return "text/css;charset=utf-8";
+  }
+  if (path.endsWith(".js")) {
+    return "text/javascript;charset=utf-8";
+  }
+  if (path.endsWith(".map")) {
+    return "application/json";
+  }
+  return "application/octet-stream";
+};
+
+export const isStandaloneExecutable = (): boolean =>
+  import.meta.path.includes("/$bunfs/") ||
+  import.meta.path.includes("\\$bunfs\\");
+
+export const isBunfsPath = (path: string): boolean =>
+  path.includes("/$bunfs/") || path.includes("\\$bunfs\\");
+
+const rewriteProductionHtml = (html: string, jsEntryPath: string): string => {
+  const script = `<script type="module" src="/${basename(jsEntryPath)}"></script>`;
+  let next = html.replace(BASE_TAG_RE, "");
+  if (SCRIPT_TAG_RE.test(next)) {
+    next = next.replace(SCRIPT_TAG_RE, script);
+  } else {
+    throw new Error("Production SPA HTML is missing a module script tag");
+  }
+  return next.replace(CROSSORIGIN_ATTR_RE, "");
+};
+
+export const buildProductionSpaAssets = async (
+  entryPath: string = productionSpaEntryPath()
+): Promise<ProductionSpaAssets> => {
+  if (isBunfsPath(entryPath)) {
+    throw new Error(
+      `Cannot Bun.build a production SPA from bunfs (${entryPath})`
+    );
+  }
+
+  const outdir = join(
+    tmpdir(),
+    `gno-spa-build-${crypto.randomUUID().replaceAll("-", "").slice(0, 20)}`
+  );
+  await mkdir(outdir, { recursive: true });
+
+  let result: Awaited<ReturnType<typeof Bun.build>>;
+  try {
+    result = await Bun.build({
+      entrypoints: [entryPath],
+      minify: true,
+      outdir,
+      publicPath: "/",
+      splitting: true,
+      target: "browser",
+    });
+  } catch (error) {
+    await rm(outdir, { recursive: true, force: true });
+    throw error;
+  }
+
+  if (!result.success) {
+    await rm(outdir, { recursive: true, force: true });
+    throw new Error("Production SPA split build failed");
+  }
+
+  try {
+    const htmlArtifact = result.outputs.find((output) =>
+      output.path.endsWith(".html")
+    );
+    const jsEntry = result.outputs.find(
+      (output) => output.kind === "entry-point" && output.path.endsWith(".js")
+    );
+    if (!htmlArtifact || !jsEntry) {
+      throw new Error(
+        "Production SPA split build did not emit HTML and JS entry"
+      );
+    }
+
+    const jsEntryText = await jsEntry.text();
+    if (!jsEntryText.includes(ROOT_MOUNT_MARKER)) {
+      throw new Error(
+        "Production SPA JS entry does not mount #root; HTML would leave the shell blank"
+      );
+    }
+
+    const html = rewriteProductionHtml(await htmlArtifact.text(), jsEntry.path);
+    const files: Record<string, ProductionSpaFile> = {};
+    for (const output of result.outputs) {
+      if (output.path.endsWith(".html")) {
+        continue;
+      }
+      const publicPath = `/${basename(output.path)}`;
+      files[publicPath] = {
+        text: await output.text(),
+        type: contentTypeFor(output.path),
+      };
+    }
+
+    return {
+      files,
+      html,
+      sourceHash: await computeSpaSourceHash(),
+    };
+  } finally {
+    await rm(outdir, { recursive: true, force: true });
+  }
+};

package/src/serve/spa-production.ts

@@ -0,0 +1,43 @@
+import productionSpaGzip from "../../assets/spa-production.json.gz" with { type: "file" };
+import {
+  ROOT_MOUNT_MARKER,
+  type ProductionSpaAssets,
+} from "./spa-production-build";
+
+export {
+  buildProductionSpaAssets,
+  isBunfsPath,
+  isStandaloneExecutable,
+  productionSpaEntryPath,
+  ROOT_MOUNT_MARKER,
+  type ProductionSpaAssets,
+  type ProductionSpaFile,
+} from "./spa-production-build";
+
+export const loadEmbeddedProductionSpa =
+  async (): Promise<ProductionSpaAssets> => {
+    const compressed = await Bun.file(productionSpaGzip).arrayBuffer();
+    const json = new TextDecoder().decode(
+      Bun.gunzipSync(new Uint8Array(compressed))
+    );
+    const assets = JSON.parse(json) as ProductionSpaAssets;
+    const firstJsPath = assets.html.match(/src="(\/[^"]+\.js)"/u)?.[1];
+    const firstJs = firstJsPath ? assets.files[firstJsPath] : undefined;
+    if (!firstJs?.text.includes(ROOT_MOUNT_MARKER)) {
+      throw new Error(
+        "Embedded production SPA is missing the #root mount entry"
+      );
+    }
+    return assets;
+  };
+
+export const getProductionSpaAssets =
+  async (): Promise<ProductionSpaAssets> => {
+    // Source and compiled serve both load the committed snapshot. Rebuilding
+    // with Bun.build on every `gno serve` blocked first listen on Windows
+    // Bun 1.3.11 long enough for the watcher smoke (10s) to miss readiness.
+    // Refresh the snapshot with `bun scripts/build-spa-production.ts`.
+    // `--dev` keeps the live HTMLBundle. Tests that need a live rebuild call
+    // `buildProductionSpaAssets` directly.
+    return loadEmbeddedProductionSpa();
+  };

package/src/types/file-assets.d.ts

@@ -0,0 +1,4 @@
+declare module "*.json.gz" {
+  const path: string;
+  export default path;
+}

package/browser-extension/artifacts/gno-browser-clipper-v1.36.1.zip.sha256

@@ -1 +0,0 @@
-8ece31111978af50978a899662a7bd14eddcc90f2c90f6b0f04b67b3b602d980  gno-browser-clipper-v1.36.1.zip