@fluixi/start 0.1.0-alpha.73 → 0.1.0-alpha.75

package/dist/adapters/entry.cjs

@@ -0,0 +1,122 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/entry.ts
+var entry_exports = {};
+__export(entry_exports, {
+  cloudflareEntry: () => cloudflareEntry,
+  netlifyEntry: () => netlifyEntry,
+  vercelEntry: () => vercelEntry
+});
+module.exports = __toCommonJS(entry_exports);
+function preamble({ serverEntry, middleware, template, ssr, mountId, routeAssets }) {
+  return [
+    `import { createHandlerFrom } from '@fluixi/start/handler-core';`,
+    `import { createPreloader } from '@fluixi/start/preload';`,
+    `import * as server from ${JSON.stringify(serverEntry)};`,
+    middleware ? `import * as middleware from ${JSON.stringify(middleware)};` : "",
+    ``,
+    `const template = ${JSON.stringify(template)};`,
+    // Inlined for the same reason as the template: this runs as an uploaded file, with
+    // no dist/server beside it to read.
+    `const routeAssets = ${JSON.stringify(routeAssets)};`,
+    `const handler = createHandlerFrom({`,
+    `  template,`,
+    `  mod: server,`,
+    `  cfg: { ssr: ${ssr}, mountId: ${JSON.stringify(mountId)} },`,
+    `  preload: createPreloader(routeAssets),`,
+    middleware ? `  middleware,` : "",
+    `});`
+  ].filter(Boolean).join("\n");
+}
+function cloudflareEntry(source) {
+  return `${preamble(source)}
+
+const prerendered = new Set(${JSON.stringify(source.prerendered)});
+
+export default {
+  async fetch(request, env, ctx) {
+    // Static first, but only for what is static. ASSETS answers "/" with index.html
+    // whether that is a prerendered page or the shell, so asking about every path
+    // costs an SSR app its home page. Extension means a file, prerendered means a
+    // page, the rest is the handler's: the rule \`withStaticFiles\` already uses.
+    const { pathname } = new URL(request.url);
+    if (env && env.ASSETS && (prerendered.has(pathname) || /\\.[^/]+$/.test(pathname))) {
+      const asset = await env.ASSETS.fetch(request.clone());
+      if (asset.status !== 404) return asset;
+    }
+    return handler(request, { env, ctx });
+  },
+};
+`;
+}
+function netlifyEntry(source) {
+  return `${preamble(source)}
+
+export default async (request, context) => handler(request, { context });
+
+export const config = { path: '/*', preferStatic: true };
+`;
+}
+function vercelEntry(source) {
+  return `${preamble(source)}
+
+export default async (req, res) => {
+  const proto = req.headers['x-forwarded-proto'] || 'https';
+  const host = req.headers['x-forwarded-host'] || req.headers.host;
+
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) for (const one of value) headers.append(name, one);
+    else if (value !== undefined) headers.set(name, value);
+  }
+
+  // A body has to be read off the stream before it can be handed to Request; only
+  // GET and HEAD are guaranteed not to have one.
+  let body;
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    const chunks = [];
+    for await (const chunk of req) chunks.push(chunk);
+    if (chunks.length) body = new Blob(chunks);
+  }
+
+  const response = await handler(
+    new Request(new URL(req.url, \`\${proto}://\${host}\`), { method: req.method, headers, body }),
+  );
+
+  res.statusCode = response.status;
+  // set-cookie is the one header that legitimately repeats; folding it into one line
+  // breaks the cookies.
+  for (const [name, value] of response.headers) {
+    if (name.toLowerCase() !== 'set-cookie') res.setHeader(name, value);
+  }
+  const cookies = response.headers.getSetCookie?.() ?? [];
+  if (cookies.length) res.setHeader('set-cookie', cookies);
+
+  if (response.body) for await (const chunk of response.body) res.write(chunk);
+  res.end();
+};
+`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cloudflareEntry,
+  netlifyEntry,
+  vercelEntry
+});

package/dist/adapters/entry.js

@@ -49,7 +49,7 @@ export default {
     // Static first, but only for what is static. ASSETS answers "/" with index.html
     // whether that is a prerendered page or the shell, so asking about every path
     // costs an SSR app its home page. Extension means a file, prerendered means a
-    // page, the rest is the handler's — the rule \`withStaticFiles\` already uses.
+    // page, the rest is the handler's: the rule \`withStaticFiles\` already uses.
     const { pathname } = new URL(request.url);
     if (env && env.ASSETS && (prerendered.has(pathname) || /\\.[^/]+$/.test(pathname))) {
       const asset = await env.ASSETS.fetch(request.clone());

package/dist/adapters/entry.mjs

@@ -0,0 +1,95 @@
+// src/adapters/entry.ts
+function preamble({ serverEntry, middleware, template, ssr, mountId, routeAssets }) {
+  return [
+    `import { createHandlerFrom } from '@fluixi/start/handler-core';`,
+    `import { createPreloader } from '@fluixi/start/preload';`,
+    `import * as server from ${JSON.stringify(serverEntry)};`,
+    middleware ? `import * as middleware from ${JSON.stringify(middleware)};` : "",
+    ``,
+    `const template = ${JSON.stringify(template)};`,
+    // Inlined for the same reason as the template: this runs as an uploaded file, with
+    // no dist/server beside it to read.
+    `const routeAssets = ${JSON.stringify(routeAssets)};`,
+    `const handler = createHandlerFrom({`,
+    `  template,`,
+    `  mod: server,`,
+    `  cfg: { ssr: ${ssr}, mountId: ${JSON.stringify(mountId)} },`,
+    `  preload: createPreloader(routeAssets),`,
+    middleware ? `  middleware,` : "",
+    `});`
+  ].filter(Boolean).join("\n");
+}
+function cloudflareEntry(source) {
+  return `${preamble(source)}
+
+const prerendered = new Set(${JSON.stringify(source.prerendered)});
+
+export default {
+  async fetch(request, env, ctx) {
+    // Static first, but only for what is static. ASSETS answers "/" with index.html
+    // whether that is a prerendered page or the shell, so asking about every path
+    // costs an SSR app its home page. Extension means a file, prerendered means a
+    // page, the rest is the handler's: the rule \`withStaticFiles\` already uses.
+    const { pathname } = new URL(request.url);
+    if (env && env.ASSETS && (prerendered.has(pathname) || /\\.[^/]+$/.test(pathname))) {
+      const asset = await env.ASSETS.fetch(request.clone());
+      if (asset.status !== 404) return asset;
+    }
+    return handler(request, { env, ctx });
+  },
+};
+`;
+}
+function netlifyEntry(source) {
+  return `${preamble(source)}
+
+export default async (request, context) => handler(request, { context });
+
+export const config = { path: '/*', preferStatic: true };
+`;
+}
+function vercelEntry(source) {
+  return `${preamble(source)}
+
+export default async (req, res) => {
+  const proto = req.headers['x-forwarded-proto'] || 'https';
+  const host = req.headers['x-forwarded-host'] || req.headers.host;
+
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) for (const one of value) headers.append(name, one);
+    else if (value !== undefined) headers.set(name, value);
+  }
+
+  // A body has to be read off the stream before it can be handed to Request; only
+  // GET and HEAD are guaranteed not to have one.
+  let body;
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    const chunks = [];
+    for await (const chunk of req) chunks.push(chunk);
+    if (chunks.length) body = new Blob(chunks);
+  }
+
+  const response = await handler(
+    new Request(new URL(req.url, \`\${proto}://\${host}\`), { method: req.method, headers, body }),
+  );
+
+  res.statusCode = response.status;
+  // set-cookie is the one header that legitimately repeats; folding it into one line
+  // breaks the cookies.
+  for (const [name, value] of response.headers) {
+    if (name.toLowerCase() !== 'set-cookie') res.setHeader(name, value);
+  }
+  const cookies = response.headers.getSetCookie?.() ?? [];
+  if (cookies.length) res.setHeader('set-cookie', cookies);
+
+  if (response.body) for await (const chunk of response.body) res.write(chunk);
+  res.end();
+};
+`;
+}
+export {
+  cloudflareEntry,
+  netlifyEntry,
+  vercelEntry
+};

package/dist/adapters/platforms.cjs

@@ -0,0 +1,311 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/platforms.ts
+var platforms_exports = {};
+__export(platforms_exports, {
+  cloudflareAdapter: () => cloudflareAdapter,
+  netlifyAdapter: () => netlifyAdapter,
+  vercelAdapter: () => vercelAdapter
+});
+module.exports = __toCommonJS(platforms_exports);
+var import_promises2 = require("node:fs/promises");
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+
+// src/adapter.ts
+var import_promises = require("node:fs/promises");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+
+// src/document.ts
+var import_head = require("@fluixi/head");
+
+// src/preload.ts
+var import_router = require("@fluixi/core/router");
+
+// src/adapter.ts
+async function readTemplate(clientDir, serverDir) {
+  const stashed = (0, import_node_path.join)(serverDir, "template.html");
+  return (0, import_promises.readFile)((0, import_node_fs.existsSync)(stashed) ? stashed : (0, import_node_path.join)(clientDir, "index.html"), "utf-8");
+}
+
+// src/adapters/entry.ts
+function preamble({ serverEntry, middleware, template, ssr, mountId, routeAssets }) {
+  return [
+    `import { createHandlerFrom } from '@fluixi/start/handler-core';`,
+    `import { createPreloader } from '@fluixi/start/preload';`,
+    `import * as server from ${JSON.stringify(serverEntry)};`,
+    middleware ? `import * as middleware from ${JSON.stringify(middleware)};` : "",
+    ``,
+    `const template = ${JSON.stringify(template)};`,
+    // Inlined for the same reason as the template: this runs as an uploaded file, with
+    // no dist/server beside it to read.
+    `const routeAssets = ${JSON.stringify(routeAssets)};`,
+    `const handler = createHandlerFrom({`,
+    `  template,`,
+    `  mod: server,`,
+    `  cfg: { ssr: ${ssr}, mountId: ${JSON.stringify(mountId)} },`,
+    `  preload: createPreloader(routeAssets),`,
+    middleware ? `  middleware,` : "",
+    `});`
+  ].filter(Boolean).join("\n");
+}
+function cloudflareEntry(source) {
+  return `${preamble(source)}
+
+const prerendered = new Set(${JSON.stringify(source.prerendered)});
+
+export default {
+  async fetch(request, env, ctx) {
+    // Static first, but only for what is static. ASSETS answers "/" with index.html
+    // whether that is a prerendered page or the shell, so asking about every path
+    // costs an SSR app its home page. Extension means a file, prerendered means a
+    // page, the rest is the handler's: the rule \`withStaticFiles\` already uses.
+    const { pathname } = new URL(request.url);
+    if (env && env.ASSETS && (prerendered.has(pathname) || /\\.[^/]+$/.test(pathname))) {
+      const asset = await env.ASSETS.fetch(request.clone());
+      if (asset.status !== 404) return asset;
+    }
+    return handler(request, { env, ctx });
+  },
+};
+`;
+}
+function netlifyEntry(source) {
+  return `${preamble(source)}
+
+export default async (request, context) => handler(request, { context });
+
+export const config = { path: '/*', preferStatic: true };
+`;
+}
+function vercelEntry(source) {
+  return `${preamble(source)}
+
+export default async (req, res) => {
+  const proto = req.headers['x-forwarded-proto'] || 'https';
+  const host = req.headers['x-forwarded-host'] || req.headers.host;
+
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) for (const one of value) headers.append(name, one);
+    else if (value !== undefined) headers.set(name, value);
+  }
+
+  // A body has to be read off the stream before it can be handed to Request; only
+  // GET and HEAD are guaranteed not to have one.
+  let body;
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    const chunks = [];
+    for await (const chunk of req) chunks.push(chunk);
+    if (chunks.length) body = new Blob(chunks);
+  }
+
+  const response = await handler(
+    new Request(new URL(req.url, \`\${proto}://\${host}\`), { method: req.method, headers, body }),
+  );
+
+  res.statusCode = response.status;
+  // set-cookie is the one header that legitimately repeats; folding it into one line
+  // breaks the cookies.
+  for (const [name, value] of response.headers) {
+    if (name.toLowerCase() !== 'set-cookie') res.setHeader(name, value);
+  }
+  const cookies = response.headers.getSetCookie?.() ?? [];
+  if (cookies.length) res.setHeader('set-cookie', cookies);
+
+  if (response.body) for await (const chunk of response.body) res.write(chunk);
+  res.end();
+};
+`;
+}
+
+// src/adapters/platforms.ts
+async function entrySource(ctx, from, prerendered) {
+  const template = await readTemplate(ctx.clientDir, ctx.serverDir);
+  const assetFile = (0, import_node_path2.join)(ctx.serverDir, "route-assets.json");
+  const routeAssets = (0, import_node_fs2.existsSync)(assetFile) ? JSON.parse(await (0, import_promises2.readFile)(assetFile, "utf-8")) : {};
+  const middleware = (0, import_node_path2.join)(ctx.serverDir, "middleware.js");
+  const rel = (file) => {
+    const path = (0, import_node_path2.join)(ctx.serverDir, file).replace(/\\/g, "/");
+    return path.startsWith("/") ? path : `./${path}`;
+  };
+  return {
+    serverEntry: rel("entry-server.js"),
+    middleware: (0, import_node_fs2.existsSync)(middleware) ? rel("middleware.js") : null,
+    template,
+    ssr: ctx.cfg.ssr,
+    mountId: ctx.cfg.mountId,
+    prerendered,
+    routeAssets
+  };
+}
+function indexIsPage(template, mountId) {
+  const mount = new RegExp(`<([a-z-]+)[^>]*\\sid=["']${mountId}["'][^>]*>`, "i").exec(template);
+  if (!mount) return false;
+  return !template.slice(mount.index + mount[0].length).trimStart().startsWith("</");
+}
+function skipWhenStatic(ctx, name) {
+  if (ctx.hasServer) return false;
+  console.log(`  fluixi: no server entry — ${name} gets the static output alone.`);
+  return true;
+}
+async function appendRedirect(clientDir, rule) {
+  const file = (0, import_node_path2.join)(clientDir, "_redirects");
+  const existing = await (0, import_promises2.readFile)(file, "utf-8").catch(() => "");
+  if (existing.includes(rule)) return;
+  const separator = existing && !existing.endsWith("\n") ? "\n" : "";
+  await (0, import_promises2.writeFile)(file, `${existing}${separator}${rule}
+`);
+}
+var SPA_FALLBACK = "/*  /index.html  200";
+var CF_MAX_RULES = 100;
+async function prerenderedRoutes(dir, mountId) {
+  const out = [];
+  const walk = async (current) => {
+    for (const entry of await (0, import_promises2.readdir)(current, { withFileTypes: true })) {
+      const path = (0, import_node_path2.join)(current, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "assets" || entry.name.startsWith(".")) continue;
+        await walk(path);
+      } else if (entry.name.endsWith(".html")) {
+        const rel = (0, import_node_path2.relative)(dir, path).replace(/\\/g, "/").replace(/index\.html$/, "").replace(/\.html$/, "");
+        out.push("/" + rel.replace(/\/$/, ""));
+      }
+    }
+  };
+  await walk(dir);
+  const index = await (0, import_promises2.readFile)((0, import_node_path2.join)(dir, "index.html"), "utf-8").catch(() => "");
+  const root = indexIsPage(index, mountId);
+  return out.filter((r) => r !== "/" || root).sort();
+}
+var cloudflareAdapter = {
+  name: "cloudflare",
+  bundle: "inline",
+  serve({ handler }) {
+    return { fetch: handler };
+  },
+  async build(ctx) {
+    if (skipWhenStatic(ctx, "cloudflare")) return;
+    const out = (0, import_node_path2.join)(ctx.clientDir, "_worker.js");
+    const prerendered = await prerenderedRoutes(ctx.clientDir, ctx.cfg.mountId);
+    await ctx.bundleEntry(cloudflareEntry(await entrySource(ctx, out, prerendered)), out);
+    const base = ["/assets/*", "/_worker.js"];
+    const room = CF_MAX_RULES - base.length;
+    const exclude = [...base, ...prerendered.slice(0, room)];
+    if (prerendered.length > room) {
+      console.warn(
+        `  fluixi: ${prerendered.length} prerendered routes exceed Cloudflare's ${CF_MAX_RULES}-rule limit for _routes.json; ${prerendered.length - room} will invoke the worker to serve a static file.`
+      );
+    }
+    await (0, import_promises2.writeFile)(
+      (0, import_node_path2.join)(ctx.clientDir, "_routes.json"),
+      JSON.stringify({ version: 1, include: ["/*"], exclude }, null, 2) + "\n"
+    );
+  }
+};
+var netlifyAdapter = {
+  name: "netlify",
+  bundle: "inline",
+  serve({ handler }) {
+    return { fetch: handler };
+  },
+  async build(ctx) {
+    if (skipWhenStatic(ctx, "netlify")) return appendRedirect(ctx.clientDir, SPA_FALLBACK);
+    const dir = (0, import_node_path2.join)(ctx.root, ".netlify", "functions-internal");
+    await (0, import_promises2.mkdir)(dir, { recursive: true });
+    const out = (0, import_node_path2.join)(dir, "fluixi-server.mjs");
+    const prerendered = await prerenderedRoutes(ctx.clientDir, ctx.cfg.mountId);
+    await ctx.bundleEntry(netlifyEntry(await entrySource(ctx, out, prerendered)), out);
+    await (0, import_promises2.writeFile)(
+      (0, import_node_path2.join)(dir, "fluixi-server.json"),
+      JSON.stringify({ config: { path: "/*", preferStatic: true }, version: 1 }, null, 2) + "\n"
+    );
+    if (!prerendered.includes("/")) {
+      await appendRedirect(ctx.clientDir, "/  /.netlify/functions/fluixi-server  200!");
+    }
+  }
+};
+var vercelAdapter = {
+  name: "vercel",
+  bundle: "inline",
+  serve({ handler }) {
+    return { fetch: handler };
+  },
+  async build(ctx) {
+    const output = (0, import_node_path2.join)(ctx.root, ".vercel", "output");
+    await (0, import_promises2.mkdir)(output, { recursive: true });
+    await (0, import_promises2.cp)(ctx.clientDir, (0, import_node_path2.join)(output, "static"), { recursive: true });
+    if (skipWhenStatic(ctx, "vercel")) {
+      await (0, import_promises2.writeFile)(
+        (0, import_node_path2.join)(output, "config.json"),
+        JSON.stringify(
+          {
+            version: 3,
+            // The filesystem phase alone answers 404 for a client route, since nothing
+            // is on disk at that path; the catch-all is what makes it a SPA.
+            routes: [{ handle: "filesystem" }, { src: "/(.*)", dest: "/index.html" }]
+          },
+          null,
+          2
+        ) + "\n"
+      );
+      return;
+    }
+    const fn = (0, import_node_path2.join)(output, "functions", "index.func");
+    await (0, import_promises2.mkdir)(fn, { recursive: true });
+    const out = (0, import_node_path2.join)(fn, "index.mjs");
+    const prerendered = await prerenderedRoutes(ctx.clientDir, ctx.cfg.mountId);
+    await ctx.bundleEntry(vercelEntry(await entrySource(ctx, out, prerendered)), out);
+    await (0, import_promises2.writeFile)(
+      (0, import_node_path2.join)(fn, ".vc-config.json"),
+      JSON.stringify(
+        { runtime: "nodejs20.x", handler: "index.mjs", launcherType: "Nodejs", shouldAddHelpers: false },
+        null,
+        2
+      ) + "\n"
+    );
+    await (0, import_promises2.writeFile)(
+      (0, import_node_path2.join)(output, "config.json"),
+      JSON.stringify(
+        {
+          version: 3,
+          routes: [
+            // The filesystem holds a shell at `/index.html`, so `/` has to be claimed
+            // before that phase or it is served unrendered. Skipped when `/` really is
+            // a prerendered page, which the filesystem should answer.
+            ...prerendered.includes("/") ? [] : [{ src: "/", dest: "/index" }],
+            // A prerendered page or an asset wins; only a miss reaches the function.
+            { handle: "filesystem" },
+            { src: "/(.*)", dest: "/index" }
+          ]
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cloudflareAdapter,
+  netlifyAdapter,
+  vercelAdapter
+});

package/dist/adapters/platforms.d.ts

@@ -3,7 +3,7 @@ import { type Adapter } from '../adapter.js';
  * Cloudflare Pages. `_worker.js` at the root of the published directory takes every
  * request; `_routes.json` is what decides whether a request costs an invocation.
  *
- * In advanced mode the worker sees everything not excluded — so a prerendered page
+ * In advanced mode the worker sees everything not excluded, so a prerendered page
  * would wake it just to proxy the file back through the ASSETS binding. On a plan
  * metered by request that is the whole page view budget spent on static files, so
  * every prerendered path is excluded by name.
@@ -13,7 +13,7 @@ import { type Adapter } from '../adapter.js';
 export declare const cloudflareAdapter: Adapter;
 /**
  * Netlify. The function is a v2 fetch handler under `.netlify/functions-internal/`,
- * which is where a framework — as opposed to the user — puts one, so it cannot
+ * which is where a framework: as opposed to the user, puts one, so it cannot
  * collide with the app's own `netlify/functions`.
  *
  * Publish `dist/client`.

package/dist/adapters/platforms.js

@@ -2,7 +2,7 @@
  * Deploy adapters for the three hosts that expect a specific output layout.
  *
  * Each one bundles the same generated entry and then writes whatever the platform
- * reads to route a request. What differs is only that layout — the handler, the
+ * reads to route a request. What differs is only that layout, the handler, the
  * dispatch order and the render are shared.
  *
  * All three inline the framework: a worker or a serverless function is a file that
@@ -40,7 +40,7 @@ async function entrySource(ctx, from, prerendered) {
  * Is `dist/client/index.html` a page, or the shell the server renders into?
  *
  * Vite writes the shell at the path a prerendered `/` would occupy, and every one of
- * these platforms serves a matching file before invoking anything — so `/` is the one
+ * these platforms serves a matching file before invoking anything, so `/` is the one
  * route an SSR app cannot render, and the CDN answers it with an empty mount element.
  * No other route is affected: nothing exists at `/about` unless it was prerendered.
  */
@@ -59,7 +59,7 @@ function skipWhenStatic(ctx, name) {
 }
 /**
  * Add a rule to `_redirects` without taking the file over. Apps ship their own (the
- * docs site redirects `/` to its default locale), so ours goes last — first match
+ * docs site redirects `/` to its default locale), so ours goes last, first match
  * wins, so the app's rules are reached first.
  */
 async function appendRedirect(clientDir, rule) {
@@ -112,7 +112,7 @@ async function prerenderedRoutes(dir, mountId) {
  * Cloudflare Pages. `_worker.js` at the root of the published directory takes every
  * request; `_routes.json` is what decides whether a request costs an invocation.
  *
- * In advanced mode the worker sees everything not excluded — so a prerendered page
+ * In advanced mode the worker sees everything not excluded, so a prerendered page
  * would wake it just to proxy the file back through the ASSETS binding. On a plan
  * metered by request that is the whole page view budget spent on static files, so
  * every prerendered path is excluded by name.
@@ -133,13 +133,13 @@ export const cloudflareAdapter = {
         await ctx.bundleEntry(cloudflareEntry(await entrySource(ctx, out, prerendered)), out);
         // Everything under /assets is content-hashed and immutable, so it never needs the
         // worker. `_worker.js` itself must be excluded or Pages would route it to itself.
-        // `/` is excluded only when it was prerendered — otherwise the worker is the only
+        // `/` is excluded only when it was prerendered, otherwise the worker is the only
         // thing that can answer it, and excluding it would serve the shell instead.
         const base = ['/assets/*', '/_worker.js'];
         const room = CF_MAX_RULES - base.length;
         const exclude = [...base, ...prerendered.slice(0, room)];
         if (prerendered.length > room) {
-            // Past the cap the remainder still works — it just wakes the worker to hand
+            // Past the cap the remainder still works: it just wakes the worker to hand
             // back a file. Worth saying, because the symptom is a bill, not an error.
             console.warn(`  fluixi: ${prerendered.length} prerendered routes exceed Cloudflare's ${CF_MAX_RULES}-rule ` +
                 `limit for _routes.json; ${prerendered.length - room} will invoke the worker to serve a static file.`);
@@ -149,7 +149,7 @@ export const cloudflareAdapter = {
 };
 /**
  * Netlify. The function is a v2 fetch handler under `.netlify/functions-internal/`,
- * which is where a framework — as opposed to the user — puts one, so it cannot
+ * which is where a framework: as opposed to the user, puts one, so it cannot
  * collide with the app's own `netlify/functions`.
  *
  * Publish `dist/client`.
@@ -173,7 +173,7 @@ export const netlifyAdapter = {
         // load an internal function at all.
         await writeFile(join(dir, 'fluixi-server.json'), JSON.stringify({ config: { path: '/*', preferStatic: true }, version: 1 }, null, 2) + '\n');
         // `preferStatic` is what keeps assets, prerendered pages and files like
-        // `favicon.ico` off the function — and it is also what would hand back the shell
+        // `favicon.ico` off the function: and it is also what would hand back the shell
         // for `/`. A forced redirect is the one exception the CDN honours over a file, so
         // it claims exactly that path and nothing else. Appended, so an app's own rules in
         // `public/_redirects` still match first.