blume 1.6.5 → 1.7.0

package/src/deploy/artifacts.ts

@@ -0,0 +1,370 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+
+import { dirname, join, resolve } from "pathe";
+
+import { buildAgentReadability } from "../ai/agent-readability.ts";
+import { API_CATALOG_PATH, buildApiCatalog } from "../ai/api-catalog.ts";
+import { buildHomeLinkHeader } from "../ai/link-headers.ts";
+import { buildLlmsFiles } from "../ai/llms.ts";
+import { markdownRoutePaths } from "../ai/markdown.ts";
+import {
+  AGENT_SKILLS_DIR,
+  buildSkillsIndex,
+  collectSkills,
+} from "../ai/skills.ts";
+import type { SkillArtifact } from "../ai/skills.ts";
+import {
+  buildSignaturesDirectory,
+  SIGNATURES_DIRECTORY_PATH,
+} from "../ai/web-bot-auth.ts";
+import type { BlumeProject } from "../core/project-graph.ts";
+import type { ResolvedConfig } from "../core/schema.ts";
+import { buildSearchIndex } from "../search/build.ts";
+import { syncSearchProvider } from "../search/sync/index.ts";
+import { readsHeaderFiles } from "./adapter-output.ts";
+import { buildNetlifyHeaders } from "./headers.ts";
+import {
+  buildNetlifyRedirects,
+  buildRedirectManifest,
+  buildVercelConfig,
+  platformRedirects,
+} from "./redirects.ts";
+import { buildRobots } from "./robots.ts";
+import { buildSitemapFiles, describeSitemapFiles } from "./sitemap.ts";
+
+/**
+ * The deploy artifacts Blume layers onto Astro's build output: the search
+ * index (and hosted-provider sync), llms.txt, sitemap, robots, the
+ * agent-readability manifest, the `.well-known` discovery files, Agent
+ * Skills, and the platform `_redirects`/`_headers` files.
+ *
+ * Written from the integration's `astro:build:done` hook — Astro's channel
+ * for exactly this kind of post-build work — into the directory Astro
+ * reports as the client output (`dist/`, or `dist/client` for a server
+ * build). The Vercel adapter copies that directory into its Build Output
+ * static tree in a later hook, so the artifacts ride along; every other
+ * adapter serves it directly. Running inside the hook rather than after
+ * `astro build` returns means an ejected project keeps producing them.
+ *
+ * Every file yields to one the user ships in `public/` (Astro copied it into
+ * the output before this runs).
+ */
+
+/** The log surface the writers report through (Astro's integration logger). */
+export interface ArtifactLogger {
+  info: (message: string) => void;
+  warn: (message: string) => void;
+}
+
+/**
+ * Emit platform redirect files for a static build (adapters wire redirects
+ * natively). Always writes the manifest; writes `_redirects`/`vercel.json` only
+ * when the user hasn't shipped one via public/. Note that Vercel's
+ * git-integration builds read `vercel.json` from the repository root only —
+ * the copy emitted here takes effect when the dist folder itself is deployed
+ * directly via the Vercel CLI.
+ */
+const emitRedirectFiles = async (
+  config: ResolvedConfig,
+  distDir: string,
+  logger: ArtifactLogger
+): Promise<void> => {
+  const redirects = platformRedirects(config);
+  if (redirects.length === 0 || config.deployment.output !== "static") {
+    return;
+  }
+  await writeFile(
+    join(distDir, "blume-redirects.json"),
+    buildRedirectManifest(redirects),
+    "utf-8"
+  );
+  const platformFiles = [
+    { content: buildNetlifyRedirects(redirects), name: "_redirects" },
+    { content: buildVercelConfig(redirects), name: "vercel.json" },
+  ];
+  await Promise.all(
+    platformFiles.map((file) =>
+      existsSync(join(distDir, file.name))
+        ? Promise.resolve()
+        : writeFile(join(distDir, file.name), file.content, "utf-8")
+    )
+  );
+  logger.info(`Emitted redirect files for ${redirects.length} redirect(s)`);
+};
+
+/**
+ * Emit a `_headers` file so Netlify / Cloudflare serve the raw AI-ready
+ * endpoints (`*.md`, `*.mdx`, `*.txt`) with an explicit `charset=utf-8`. Without
+ * it those hosts send `text/markdown` / `text/plain` with no charset and
+ * browsers fall back to Windows-1252, garbling any non-ASCII docs (#82).
+ *
+ * The same file carries the rest of the agent-discovery surface that only a
+ * response header can express: the homepage `Link` header (RFC 8288, see
+ * `ai/link-headers.ts`), and the registered media types for the extensionless
+ * well-known files — `application/linkset+json` for the API catalog, the
+ * signatures directory, and the Agent Skills archives. A static host serves
+ * those as `octet-stream` or nothing at all without a rule.
+ *
+ * A `_headers` shipped in `public/` wins, exactly like `_redirects` — the opt-out
+ * is checked at its source rather than in `dist`, because on Cloudflare the file
+ * in `dist` is not necessarily the user's: `@astrojs/cloudflare` writes its own
+ * `_headers` (an immutable `Cache-Control` rule for `/_astro/*`) during the
+ * build, before this runs. Testing `dist` therefore read an adapter-generated
+ * file as a user opt-out and skipped silently. When both exist, the adapter's
+ * rules are preserved and ours are appended.
+ *
+ * Gated on {@link readsHeaderFiles}, not on `output === "static"`. A **Cloudflare
+ * server** build serves `dist/client` through the Worker's ASSETS binding, and
+ * Workers static assets honor `_headers` from that directory — so the file
+ * applies there too, and skipping it left every Cloudflare server build with no
+ * `Link` header and no media type on its own discovery files. The charset half
+ * of this file *is* redundant on a server build, because the runtime endpoint
+ * sets Content-Type on the Response itself; the `Link` and well-known halves are
+ * not, and one conclusion about the first was applied to all three.
+ *
+ * Exported for the test suite, which exercises it in a subprocess like the
+ * command helpers.
+ */
+export const emitHeaderFiles = async (
+  project: BlumeProject,
+  distDir: string,
+  logger: ArtifactLogger
+): Promise<void> => {
+  const { config } = project;
+  if (
+    !readsHeaderFiles(config.deployment) ||
+    existsSync(join(project.context.root, "public", "_headers"))
+  ) {
+    return;
+  }
+  const ours = buildNetlifyHeaders(
+    config,
+    buildHomeLinkHeader(config, markdownRoutePaths(project))
+  );
+  // An adapter may have written its own rules here already (Cloudflare adds an
+  // immutable Cache-Control for /_astro/*). Keep them and append ours: both
+  // sets are wanted, and `_headers` has no merge semantics beyond order.
+  const target = join(distDir, "_headers");
+  const existing = existsSync(target) ? await readFile(target, "utf-8") : "";
+  await writeFile(
+    target,
+    existing ? `${existing.trimEnd()}\n${ours}` : ours,
+    "utf-8"
+  );
+  logger.info("Emitted _headers (UTF-8 Content-Type + homepage Link header)");
+};
+
+/**
+ * Collect the Agent Skills `ai.skills` publishes, once per build, so both the
+ * skills surface and llms.txt (which lists them) read the same set. Empty
+ * when the feature is off, the directory is missing, nothing in it is
+ * publishable (each with a warning), or a user-shipped
+ * `public/.well-known/agent-skills/index.json` already owns the surface.
+ */
+const collectConfiguredSkills = async (
+  project: BlumeProject,
+  distDir: string,
+  logger: ArtifactLogger
+): Promise<SkillArtifact[]> => {
+  const configured = project.config.ai.skills;
+  if (!configured) {
+    return [];
+  }
+  const dir = resolve(project.context.root, configured);
+  if (!existsSync(dir)) {
+    logger.warn(
+      `ai.skills points at "${configured}" (${dir}), which does not exist; no skills published.`
+    );
+    return [];
+  }
+  if (existsSync(join(distDir, AGENT_SKILLS_DIR.slice(1), "index.json"))) {
+    return [];
+  }
+  const { skills, warnings } = await collectSkills(dir);
+  for (const warning of warnings) {
+    logger.warn(warning);
+  }
+  if (skills.length === 0) {
+    logger.warn(`ai.skills: no publishable skills found in "${configured}".`);
+  }
+  return skills;
+};
+
+/**
+ * Publish the collected Agent Skills: copy each skill artifact under
+ * `.well-known/agent-skills/` and emit the discovery index. A user-shipped
+ * `public/.well-known/agent-skills/index.json` takes over the whole surface
+ * (the collector returns nothing then), matching every other generated
+ * artifact.
+ */
+const emitAgentSkills = async (
+  project: BlumeProject,
+  distDir: string,
+  skills: readonly SkillArtifact[],
+  logger: ArtifactLogger
+): Promise<void> => {
+  if (skills.length === 0) {
+    return;
+  }
+  const outDir = join(distDir, AGENT_SKILLS_DIR.slice(1));
+  await Promise.all(
+    skills.map(async (skill) => {
+      const target = join(outDir, skill.path);
+      await mkdir(dirname(target), { recursive: true });
+      await writeFile(target, skill.content);
+    })
+  );
+  await writeFile(
+    join(outDir, "index.json"),
+    buildSkillsIndex(skills, project.config),
+    "utf-8"
+  );
+  logger.info(
+    `Published ${skills.length} agent skill(s) (.well-known/agent-skills/index.json)`
+  );
+};
+
+/**
+ * Emit the generated `.well-known` discovery files — the RFC 9727 API catalog
+ * and the Web Bot Auth signature directory — each skipped when the feature is
+ * off or when the user ships their own copy via public/ (already in dist by
+ * the time this runs).
+ */
+const emitWellKnownFiles = async (
+  config: ResolvedConfig,
+  distDir: string,
+  logger: ArtifactLogger
+): Promise<void> => {
+  const files = [
+    {
+      content: buildSignaturesDirectory(config),
+      label: "Web Bot Auth",
+      path: SIGNATURES_DIRECTORY_PATH,
+    },
+    {
+      content: buildApiCatalog(config),
+      label: "RFC 9727",
+      path: API_CATALOG_PATH,
+    },
+  ];
+  for (const file of files) {
+    const target = join(distDir, file.path.slice(1));
+    if (!file.content || existsSync(target)) {
+      continue;
+    }
+    // Sequential by nature: both files share the .well-known dir creation.
+    // oxlint-disable-next-line no-await-in-loop
+    await mkdir(join(distDir, ".well-known"), { recursive: true });
+    // oxlint-disable-next-line no-await-in-loop
+    await writeFile(target, file.content, "utf-8");
+    logger.info(`Generated ${file.path.slice(1)} (${file.label})`);
+  }
+};
+
+/**
+ * Generate `llms.txt`/`llms-full.txt` into the dist dir. A user's own file in
+ * `public/` (copied into dist by Astro before this runs, like the sitemap and
+ * robots.txt) wins over the generated one — each file is checked and replaced
+ * independently, so a custom `llms.txt` still gets a generated `llms-full.txt`.
+ */
+const publishLlmsFiles = async (
+  project: BlumeProject,
+  distDir: string,
+  skills: readonly SkillArtifact[],
+  logger: ArtifactLogger
+): Promise<void> => {
+  const indexPath = join(distDir, "llms.txt");
+  const fullPath = join(distDir, "llms-full.txt");
+  const writeIndex = !existsSync(indexPath);
+  const writeFull = !existsSync(fullPath);
+  if (!(writeIndex || writeFull)) {
+    return;
+  }
+  const { index, full } = await buildLlmsFiles(project, { skills });
+  const writes: Promise<void>[] = [];
+  if (writeIndex) {
+    writes.push(writeFile(indexPath, index, "utf-8"));
+  }
+  if (writeFull) {
+    writes.push(writeFile(fullPath, full, "utf-8"));
+  }
+  await Promise.all(writes);
+  logger.info(
+    `Generated ${[
+      writeIndex ? "llms.txt" : null,
+      writeFull ? "llms-full.txt" : null,
+    ]
+      .filter(Boolean)
+      .join(" and ")}`
+  );
+};
+
+/**
+ * Write every deploy artifact into `distDir`, the directory the platform
+ * serves as static files (see the module comment). A user's own `public/`
+ * file always wins. `indexSearch` is the Pagefind indexer, replaceable by
+ * tests: Pagefind's in-process service cannot be reopened once a build has
+ * closed it, so only one suite may run the real one.
+ */
+export const publishBuildArtifacts = async (
+  project: BlumeProject,
+  distDir: string,
+  logger: ArtifactLogger,
+  indexSearch: (outDir: string) => Promise<number> = buildSearchIndex
+): Promise<void> => {
+  if (project.config.search.provider === "pagefind") {
+    logger.info("Building search index");
+    const indexed = await indexSearch(distDir);
+    logger.info(`Indexed ${indexed} page(s) for search`);
+  }
+
+  // Upload the index to a hosted provider (Algolia, Orama Cloud, Typesense).
+  // Skipped with a warning when its admin key isn't configured.
+  await syncSearchProvider(project, {
+    start: logger.info.bind(logger),
+    success: logger.info.bind(logger),
+    warn: logger.warn.bind(logger),
+  });
+
+  // Collected once: llms.txt lists the skills the build publishes below.
+  const skills = await collectConfiguredSkills(project, distDir, logger);
+  if (project.config.ai.llmsTxt.enabled) {
+    await publishLlmsFiles(project, distDir, skills, logger);
+  }
+
+  const sitemapFiles = buildSitemapFiles(project);
+  if (sitemapFiles && !existsSync(join(distDir, "sitemap.xml"))) {
+    await Promise.all(
+      sitemapFiles.map((file) =>
+        writeFile(join(distDir, file.name), file.xml, "utf-8")
+      )
+    );
+    logger.info(describeSitemapFiles(sitemapFiles));
+  }
+
+  const robots = buildRobots(project);
+  if (robots && !existsSync(join(distDir, "robots.txt"))) {
+    await writeFile(join(distDir, "robots.txt"), robots, "utf-8");
+    logger.info("Generated robots.txt");
+  }
+
+  const agentReadability = buildAgentReadability(project);
+  if (
+    agentReadability &&
+    !existsSync(join(distDir, "agent-readability.json"))
+  ) {
+    await writeFile(
+      join(distDir, "agent-readability.json"),
+      `${JSON.stringify(agentReadability, null, 2)}\n`,
+      "utf-8"
+    );
+    logger.info("Generated agent-readability.json");
+  }
+
+  await emitWellKnownFiles(project.config, distDir, logger);
+  await emitAgentSkills(project, distDir, skills, logger);
+
+  await emitRedirectFiles(project.config, distDir, logger);
+  await emitHeaderFiles(project, distDir, logger);
+};

package/src/deploy/cloudflare-negotiation.ts

@@ -4,9 +4,11 @@
  * Blume prerenders every content page — even under `deployment.output:
  * "server"` — and on Cloudflare the ASSETS binding serves those files before
  * the Worker script runs, so no server-side code (Astro middleware included)
- * ever sees a content-page request. Worse, even a request that does reach the
- * Worker is answered by `@astrojs/cloudflare`'s handler straight from the
- * ASSETS binding, ahead of `app.render` — the only place middleware runs.
+ * ever sees a content-page request. Worse, even a content-page request that
+ * does reach the Worker is answered by `@astrojs/cloudflare`'s handler
+ * straight from the ASSETS binding, ahead of `app.render` — the only place
+ * middleware runs — because `app.match` resolves a prerendered route to
+ * nothing and the handler then falls back to the binding.
  *
  * Negotiation therefore needs two coordinated pieces, both applied to the
  * adapter's emitted deploy bundle after `astro build`:
@@ -20,6 +22,22 @@
  *    from the ASSETS binding, and it delegates everything else to the Astro
  *    Worker untouched.
  *
+ * The prerendered per-page JSON documents (`/api/docs/pages/{route}.json`)
+ * are the one prerendered surface the adapter's fallback does *not* cover.
+ * They come from a prerendered *dynamic* route, and for those Astro's
+ * `matchRequest` returns the first non-prerendered route matching the same
+ * path — on a server build that is the `/api/[...path]` catch-all, which
+ * answers with a 404 problem document; `fallbackToAssets` never runs. The
+ * static-pathname endpoints (`pages.json`, `navigation.json`) are unaffected:
+ * they sit in the manifest's asset set, which the handler serves from the
+ * binding first. So whenever a worker-first rule claims a page JSON URL, the
+ * wrapper answers it from the binding itself, keyed by the exact set of
+ * documents the build emitted. The generated rule sets that would claim every
+ * `.json` file — a subpath base and the coarse fallback — exempt `*.json`
+ * outright, keeping those files on the zero-Worker path; the wrapper branch
+ * covers the remaining claims (a content section under `/api`, or
+ * user-configured rules).
+ *
  * Cloudflare does not apply `_headers` to worker-first routes, so the wrapper
  * also re-stamps what the static layer would otherwise add on the routes it
  * takes over: the homepage agent-discovery `Link` header and the Markdown
@@ -64,8 +82,19 @@ const MAX_RULE_LENGTH = 100;
  * route everything through the Worker except the fingerprinted build assets
  * and the raw AI-ready endpoints, whose `charset=utf-8` comes from `_headers`
  * (not applied on worker-first routes) and whose responses never negotiate.
+ * The prerendered `.json` documents are exempted for the same reason, and
+ * because the Astro Worker would hand the per-page ones to the `/api/`
+ * catch-all (see the module comment); a miss on an exempted path still
+ * invokes the Worker, so unknown `.json` URLs keep their problem document.
  */
-const FALLBACK_RULES = ["/*", "!/_astro/*", "!/*.md", "!/*.mdx", "!/*.txt"];
+const FALLBACK_RULES = [
+  "/*",
+  "!/_astro/*",
+  "!/*.md",
+  "!/*.mdx",
+  "!/*.txt",
+  "!/*.json",
+];
 
 /**
  * The deployment base as a rule/URL prefix: trailing slash stripped, empty
@@ -107,7 +136,8 @@ const ruleBody = (rule: string): string =>
  * `.md`/`.mdx` mirrors; a bare route gets its exact path in both request
  * spellings (with and without the trailing slash) so no unrelated URL pays
  * the Worker hop. On a subpath deploy the whole base is routed as one group —
- * every route lives under it anyway.
+ * every route lives under it anyway — with the raw endpoints and the
+ * prerendered `.json` documents exempted like the coarse fallback does.
  *
  * Configured redirects need no exemption from these rules: the wrapper Worker
  * answers any it claims from its baked-in redirect table with the configured
@@ -125,6 +155,7 @@ export const buildRunWorkerFirstRules = (
       `!${prefix}/*.md`,
       `!${prefix}/*.mdx`,
       `!${prefix}/*.txt`,
+      `!${prefix}/*.json`,
       `!${prefix}/_astro/*`,
     ];
   }
@@ -230,6 +261,13 @@ export interface NegotiationWorkerOptions {
   homeTokens?: number;
   /** Configured redirects the wrapper answers with their exact status. */
   redirects?: readonly WorkerRedirect[];
+  /**
+   * Base-less served paths of the prerendered per-page JSON documents the
+   * build emitted (see `pageJsonPath`), decoded. The wrapper answers exactly
+   * these from the assets binding, since the Astro Worker would route them to
+   * the `/api/` catch-all (see the module comment).
+   */
+  pageJsonPaths?: readonly string[];
 }
 
 /**
@@ -242,6 +280,7 @@ export const buildNegotiationWorker = (
   options: NegotiationWorkerOptions
 ): string => {
   const routes = JSON.stringify(options.routePaths);
+  const pageJson = JSON.stringify(options.pageJsonPaths ?? []);
   const binding = JSON.stringify(options.assetsBinding);
   const prefix = JSON.stringify(encodeURI(basePrefix(options.base)));
   const homeLinkHeader = JSON.stringify(options.homeLinkHeader ?? null);
@@ -266,13 +305,17 @@ export const buildNegotiationWorker = (
 // build. \`assets.run_worker_first\` routes content-page requests here instead
 // of the platform's static layer; a client that prefers Markdown gets the
 // page's prerendered \`.md\` mirror from the assets binding, a configured
-// redirect is answered with its exact configured status, and every other
+// redirect is answered with its exact configured status, and a prerendered
+// per-page JSON document is served from the binding (the Astro Worker would
+// route it to the \`/api/\` catch-all, because Astro resolves a prerendered
+// dynamic route to the first live route on the same path). Every other
 // request is delegated to the Astro Worker untouched. \`_headers\` does not
 // apply to worker-first routes, so the homepage Link header and the Markdown
 // charset are re-stamped here.
 import server from ${JSON.stringify(options.mainSpecifier)};
 
 const ROUTES = new Set(${routes});
+const PAGE_JSON = new Set(${pageJson});
 const BASE_PREFIX = ${prefix};
 const ASSETS_BINDING = ${binding};
 const HOME_LINK_HEADER = ${homeLinkHeader};
@@ -286,13 +329,32 @@ const REDIRECTS = ${redirects};
 const redirectFor = (pathname) => {
   const trimmed =
     pathname !== "/" && pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
-  let path = trimmed;
+  const path = safeDecode(trimmed);
+  return Object.hasOwn(REDIRECTS, path) ? REDIRECTS[path] : null;
+};
+
+// The request path with the deployment base removed: the whole path on a
+// root deploy, \`""\` for the bare base, \`null\` for a path outside the base.
+const stripBase = (pathname) => {
+  if (!BASE_PREFIX) {
+    return pathname;
+  }
+  if (pathname === BASE_PREFIX) {
+    return "";
+  }
+  return pathname.startsWith(BASE_PREFIX + "/")
+    ? pathname.slice(BASE_PREFIX.length)
+    : null;
+};
+
+// Decoded for the lookups, which are keyed by decoded paths; a malformed
+// escape keeps the raw path, which simply won't match anything.
+const safeDecode = (path) => {
   try {
-    path = decodeURIComponent(trimmed);
+    return decodeURIComponent(path);
   } catch {
-    // Keep the raw path; it simply won't match a configured redirect.
+    return path;
   }
-  return Object.hasOwn(REDIRECTS, path) ? REDIRECTS[path] : null;
 };
 
 // \`_redirects\` semantics, which the static layer applies to these same
@@ -341,21 +403,13 @@ const markdownVariantUrl = (rawUrl) => {
   const queryIndex = rawUrl.indexOf("?");
   const query = queryIndex === -1 ? "" : rawUrl.slice(queryIndex);
   const rawPath = queryIndex === -1 ? rawUrl : rawUrl.slice(0, queryIndex);
-  let path = rawPath;
-  if (BASE_PREFIX) {
-    if (path === BASE_PREFIX || path.startsWith(BASE_PREFIX + "/")) {
-      path = path.slice(BASE_PREFIX.length) || "/";
-    } else {
-      return null;
-    }
+  const rest = stripBase(rawPath);
+  if (rest === null) {
+    return null;
   }
+  const path = rest || "/";
   const trimmed = path !== "/" && path.endsWith("/") ? path.slice(0, -1) : path;
-  let pathname = trimmed;
-  try {
-    pathname = decodeURIComponent(trimmed);
-  } catch {
-    // Keep the raw path; it simply won't match a content route.
-  }
+  const pathname = safeDecode(trimmed);
   if (!ROUTES.has(pathname)) {
     return null;
   }
@@ -363,15 +417,17 @@ const markdownVariantUrl = (rawUrl) => {
   return BASE_PREFIX + encodeURI(target) + ".md" + query;
 };
 
+// Exactly the per-page JSON documents the build emitted, so a URL the site
+// never generated (a hidden page, a path outside the API) takes the normal
+// route to the Astro Worker and its problem document.
+const isPageJson = (pathname) => {
+  const rest = stripBase(pathname);
+  return rest !== null && PAGE_JSON.has(safeDecode(rest));
+};
+
 const isHomePath = (pathname) => {
-  let path = pathname;
-  if (BASE_PREFIX) {
-    if (path !== BASE_PREFIX && !path.startsWith(BASE_PREFIX + "/")) {
-      return false;
-    }
-    path = path.slice(BASE_PREFIX.length);
-  }
-  return path === "" || path === "/";
+  const rest = stripBase(pathname);
+  return rest === "" || rest === "/";
 };
 
 const withHeaders = (response, apply) => {
@@ -395,9 +451,18 @@ export default {
     if (request.method !== "GET" && request.method !== "HEAD") {
       return server.fetch(request, env, context);
     }
+    const assets = env[ASSETS_BINDING];
+    // The request goes through untouched, so a conditional revalidation
+    // reaches the binding and comes back as a 304 — anything but a miss is
+    // the document's own answer. A miss falls through to the Astro Worker.
+    if (assets !== undefined && isPageJson(url.pathname)) {
+      const asset = await assets.fetch(request);
+      if (asset.status !== 404) {
+        return asset;
+      }
+    }
     const variant = markdownVariantUrl(url.pathname + url.search);
     const home = isHomePath(url.pathname);
-    const assets = env[ASSETS_BINDING];
     if (
       variant !== null &&
       assets !== undefined &&