blume 1.6.4 → 1.6.6

package/src/cli/commands/eject.ts

@@ -1,63 +1,26 @@
 import { defineCommand } from "citty";
 import { relative } from "pathe";
 
-import { loadConfig } from "../../core/config.ts";
 import { eject } from "../../registry/eject.ts";
+import { commandMeta } from "../command-meta.ts";
 import { refuseIfDevRunning } from "../dev-lock.ts";
-import {
-  droppedArtifactNotices,
-  updatePackageScripts,
-} from "../eject-scripts.ts";
+import { updatePackageScripts } from "../eject-scripts.ts";
 import { commandsFor, detectProjectPackageManager } from "../init/scaffold.ts";
 import { logger } from "../log.ts";
 
-/**
- * Warn which `blume build` post-build artifacts the ejected app stops
- * producing. Printed both at the confirmation (so the decision is informed)
- * and after `--yes` (so a direct eject still sees it). No-op when the config
- * activates none of them.
- */
-const reportDroppedArtifacts = (notices: string[]): void => {
-  if (notices.length === 0) {
-    return;
-  }
-  logger.warn(
-    [
-      "The ejected build script runs plain `astro build`, which stops producing these `blume build` artifacts:",
-      ...notices.map((notice) => `  - ${notice}`),
-    ].join("\n")
-  );
-};
-
 export const ejectCommand = defineCommand({
   args: {
     yes: { description: "Skip the confirmation prompt.", type: "boolean" },
   },
-  meta: {
-    description: "Promote the generated runtime into an owned Astro project.",
-    name: "eject",
-  },
+  meta: commandMeta.eject,
   async run({ args }) {
     const root = process.cwd();
     refuseIfDevRunning(root, "ejecting");
 
-    // Config-aware drop list: only the artifacts this project actually
-    // produces are mentioned (e.g. the Pagefind index only for
-    // `search.provider: "pagefind"`).
-    let notices: string[] = [];
-    try {
-      const { config } = await loadConfig(root);
-      notices = droppedArtifactNotices(config);
-    } catch {
-      // A config that fails to load can't gate the notice; the eject itself
-      // surfaces the load error.
-    }
-
     if (!args.yes) {
       logger.warn(
         "Eject is one-way: it writes astro.config.mjs, src/, and (if absent) tsconfig.json, rewrites your package.json scripts, and removes .blume. An existing tsconfig.json is left untouched."
       );
-      reportDroppedArtifacts(notices);
       logger.info("Re-run with --yes to proceed.");
       return;
     }
@@ -75,7 +38,6 @@ export const ejectCommand = defineCommand({
     for (const file of files) {
       process.stdout.write(`  ${relative(root, file)}\n`);
     }
-    reportDroppedArtifacts(notices);
     // Print run commands matching the project's package manager (lockfile
     // detection, since eject runs inside an existing project).
     const pm = await detectProjectPackageManager(root);

package/src/cli/commands/eval.ts

@@ -22,6 +22,7 @@ import {
 import { runEval } from "../../eval/run.ts";
 import type { EvalResult } from "../../eval/run.ts";
 import { EvalsFileError, loadEvalsFile } from "../../eval/schema.ts";
+import { commandMeta } from "../command-meta.ts";
 import { reportInternalError } from "../internal-error.ts";
 import { flushStdout, logger } from "../log.ts";
 
@@ -183,11 +184,7 @@ export const evalCommand = defineCommand({
       type: "boolean",
     },
   },
-  meta: {
-    description:
-      "Test the docs: an agent answers your questions using only the documentation.",
-    name: "eval",
-  },
+  meta: commandMeta.eval,
   async run({ args }) {
     const root = process.cwd();
     const { agent, threshold, timeoutS } = parseFlags(args);

package/src/cli/commands/init.ts

@@ -4,6 +4,7 @@ import { resolve } from "pathe";
 
 import { ensureGitignore } from "../../core/gitignore.ts";
 import { eject } from "../../registry/eject.ts";
+import { commandMeta } from "../command-meta.ts";
 import { updatePackageScripts } from "../eject-scripts.ts";
 import { collectAnswers } from "../init/questions.ts";
 import {
@@ -84,10 +85,7 @@ export const initCommand = defineCommand({
       type: "boolean",
     },
   },
-  meta: {
-    description: "Scaffold a minimal Blume project.",
-    name: "init",
-  },
+  meta: commandMeta.init,
   async run({ args }) {
     const cwd = process.cwd();
 

package/src/cli/commands/mcp-stdio.ts

@@ -4,6 +4,7 @@ import { defineCommand } from "citty";
 
 import type { McpData } from "../../ai/mcp/data.ts";
 import { serveMcpStdio } from "../../ai/mcp/stdio.ts";
+import { commandMeta } from "../command-meta.ts";
 
 export const mcpStdioCommand = defineCommand({
   args: {
@@ -13,11 +14,7 @@ export const mcpStdioCommand = defineCommand({
       type: "string",
     },
   },
-  meta: {
-    description:
-      "Serve an MCP data snapshot over stdio (internal, used by `blume eval`).",
-    name: "mcp-stdio",
-  },
+  meta: commandMeta["mcp-stdio"],
   async run({ args }) {
     // stdout belongs to the JSON-RPC transport from here on; every diagnostic
     // must go to stderr or the MCP client chokes on the stray line.

package/src/cli/commands/preview.ts

@@ -7,18 +7,16 @@ import { join } from "pathe";
 import { loadConfig } from "../../core/config.ts";
 import { resolveProjectContext } from "../../core/project.ts";
 import { parsePort } from "../args.ts";
+import { commandMeta } from "../command-meta.ts";
+import { normalizeHost } from "../host-args.ts";
 import { logger } from "../log.ts";
-import { normalizeHost } from "./dev.ts";
 
 export const previewCommand = defineCommand({
   args: {
     host: { description: "Network host to bind.", type: "string" },
     port: { description: "Port to listen on.", type: "string" },
   },
-  meta: {
-    description: "Preview the last production build.",
-    name: "preview",
-  },
+  meta: commandMeta.preview,
   async run({ args }) {
     const root = process.cwd();
     const { config } = await loadConfig(root);

package/src/cli/commands/sync.ts

@@ -8,6 +8,7 @@ import {
   resolveProjectContext,
   resolveRuntimeDir,
 } from "../../core/project.ts";
+import { commandMeta } from "../command-meta.ts";
 import { readDevLock } from "../dev-lock.ts";
 import { logger } from "../log.ts";
 import { prepareProject } from "../prepare.ts";
@@ -24,10 +25,7 @@ export const syncCommand = defineCommand({
     },
     strict: { description: "Fail on diagnostics.", type: "boolean" },
   },
-  meta: {
-    description: "Re-fetch remote content sources and regenerate the runtime.",
-    name: "sync",
-  },
+  meta: commandMeta.sync,
   async run({ args }) {
     const root = process.cwd();
 

package/src/cli/commands/translate.ts

@@ -26,6 +26,7 @@ import {
 } from "../../translate/report.ts";
 import { runTranslate } from "../../translate/run.ts";
 import { computeWorkList } from "../../translate/work-list.ts";
+import { commandMeta } from "../command-meta.ts";
 import { reportInternalError } from "../internal-error.ts";
 import { flushStdout, logger } from "../log.ts";
 
@@ -181,11 +182,7 @@ export const translateCommand = defineCommand({
       type: "string",
     },
   },
-  meta: {
-    description:
-      "Translate docs into the configured locales with a local agent CLI.",
-    name: "translate",
-  },
+  meta: commandMeta.translate,
   async run({ args }) {
     const root = process.cwd();
     const { agent, concurrency, timeoutS } = parseFlags(args);

package/src/cli/commands/validate.ts

@@ -13,6 +13,7 @@ import { validateLinks } from "../../core/links.ts";
 import { buildManifest } from "../../core/manifest.ts";
 import { scanProject } from "../../core/project-graph.ts";
 import type { Diagnostic } from "../../core/types.ts";
+import { commandMeta } from "../command-meta.ts";
 import { reportInternalError } from "../internal-error.ts";
 import {
   flushStdout,
@@ -36,10 +37,7 @@ export const validateCommand = defineCommand({
       type: "boolean",
     },
   },
-  meta: {
-    description: "Validate internal, anchor, asset, and external links.",
-    name: "validate",
-  },
+  meta: commandMeta.validate,
   async run({ args }) {
     const root = process.cwd();
     const diagnostics: Diagnostic[] = [];

package/src/cli/commands/version.ts

@@ -3,6 +3,7 @@ import { defineCommand } from "citty";
 import { loadConfig } from "../../core/config.ts";
 import { BlumeError } from "../../core/diagnostics.ts";
 import { CutError, cutVersion } from "../../core/version-cut.ts";
+import { commandMeta } from "../command-meta.ts";
 import { reportInternalError } from "../internal-error.ts";
 import { logger } from "../log.ts";
 
@@ -18,10 +19,7 @@ export const versionCommand = defineCommand({
       type: "positional",
     },
   },
-  meta: {
-    description: "Freeze the current docs as an archived version.",
-    name: "version",
-  },
+  meta: commandMeta.version,
   async run({ args }) {
     const root = process.cwd();
 

package/src/cli/eject-scripts.ts

@@ -2,9 +2,6 @@ import { readFile, writeFile } from "node:fs/promises";
 
 import { join } from "pathe";
 
-import type { ResolvedConfig } from "../core/schema.ts";
-import { searchProviderMeta } from "../search/providers.ts";
-
 /** A JSON value, as `JSON.parse` of a manifest can return. */
 type JsonValue =
   | string
@@ -20,48 +17,6 @@ interface PackageManifest {
   scripts?: Record<string, string>;
 }
 
-/**
- * The `blume build`-only artifacts this project's config actually produces, as
- * notice lines for the eject command. After an eject the build script runs
- * plain `astro build`, which emits none of them — printing the config-aware
- * list makes the loss explicit instead of silent (a Pagefind site would
- * otherwise eject into a build whose search fails at runtime). Each gate
- * mirrors the artifact's producer in `blume build` (cli/commands/build.ts).
- */
-export const droppedArtifactNotices = (config: ResolvedConfig): string[] => {
-  const notices: string[] = [];
-  if (config.search.provider === "pagefind") {
-    notices.push(
-      'the Pagefind search index — the search UI loads it from the built site, so search will break in production. Add a post-build step: `"build": "astro build && pagefind --site dist"` (with `pagefind` installed as a devDependency).'
-    );
-  }
-  if (searchProviderMeta(config.search.provider).syncs) {
-    notices.push(
-      `the hosted ${config.search.provider} index sync — new and updated pages stop being pushed; re-upload your search records after each build with the provider's API or CLI.`
-    );
-  }
-  if (config.ai.llmsTxt.enabled) {
-    notices.push("llms.txt and llms-full.txt");
-  }
-  if (config.deployment.site && config.seo.sitemap) {
-    notices.push(
-      "sitemap.xml — recreate it with the @astrojs/sitemap integration."
-    );
-  }
-  if (config.seo.robots) {
-    notices.push("robots.txt — recreate it as a public/robots.txt file.");
-  }
-  if (config.seo.agentReadability) {
-    notices.push("agent-readability.json");
-  }
-  if (config.redirects.length > 0 && config.deployment.output === "static") {
-    notices.push(
-      "the platform redirect files (_redirects, vercel.json) — your redirects still work as Astro-generated meta-refresh pages."
-    );
-  }
-  return notices;
-};
-
 /**
  * Rewrite the project's package.json scripts to run Astro directly. After an
  * eject the Blume CLI no longer manages the runtime, so scaffolded scripts like

package/src/cli/host-args.ts

@@ -16,3 +16,19 @@ export const normalizeHostArgs = (rawArgs: readonly string[]): string[] =>
     const next = rawArgs[index + 1];
     return next === undefined || next.startsWith("-") ? "--host=" : arg;
   });
+
+/**
+ * Resolve a `--host` flag value into what Astro/Vite's `server.host` expects.
+ * citty has no mixed string/boolean arg type, so `host` is declared as a
+ * string and a bare `--host` parses as `""` (`normalizeHostArgs` rewrites it
+ * to `--host=` first) — Node would bind all interfaces for `""`, but Vite's
+ * `resolveHostname` treats it as a literal hostname and prints malformed URLs
+ * like `http://:4321/`. Match Astro's own `--host` semantics instead: bare
+ * flag → `true` (bind all interfaces), `--host 10.0.0.1` → that address,
+ * absent → `false` (localhost only).
+ *
+ * Lives beside `normalizeHostArgs` rather than in `commands/dev.ts` so
+ * `preview` can share it without importing the whole dev command graph.
+ */
+export const normalizeHost = (host?: string): boolean | string =>
+  host === "" ? true : (host ?? false);

package/src/cli/index.ts

@@ -1,24 +1,18 @@
 import { defineCommand, runMain } from "citty";
 
 import { getBlumeVersion } from "../core/version.ts";
-import { addCommand } from "./commands/add.ts";
-import { auditCommand } from "./commands/audit.ts";
-import { buildCommand } from "./commands/build.ts";
-import { checkCommand } from "./commands/check.ts";
-import { devCommand } from "./commands/dev.ts";
-import { doctorCommand } from "./commands/doctor.ts";
-import { ejectCommand } from "./commands/eject.ts";
-import { evalCommand } from "./commands/eval.ts";
-import { initCommand } from "./commands/init.ts";
-import { mcpStdioCommand } from "./commands/mcp-stdio.ts";
-import { previewCommand } from "./commands/preview.ts";
-import { syncCommand } from "./commands/sync.ts";
-import { translateCommand } from "./commands/translate.ts";
-import { validateCommand } from "./commands/validate.ts";
-import { versionCommand } from "./commands/version.ts";
+import { commandMeta } from "./command-meta.ts";
 import { loadEnvFiles } from "./env.ts";
 import { normalizeHostArgs } from "./host-args.ts";
 import { reportInternalError } from "./internal-error.ts";
+import { lazyCommand } from "./lazy-command.ts";
+// consola reads CONSOLA_LEVEL / NODE_ENV / TEST / CI / DEBUG when its module
+// evaluates. Import the logger here, ahead of `loadEnvFiles`, so those values
+// come from the real environment — never from a project `.env`, which would
+// otherwise silence or restyle every command's output. The commands are loaded
+// lazily below, so without this line consola would first evaluate after `.env`
+// had been applied.
+import "./log.ts";
 
 const main = defineCommand({
   meta: {
@@ -27,31 +21,86 @@ const main = defineCommand({
     version: getBlumeVersion(),
   },
   subCommands: {
-    add: addCommand,
-    audit: auditCommand,
-    build: buildCommand,
-    check: checkCommand,
-    dev: devCommand,
-    doctor: doctorCommand,
-    eject: ejectCommand,
-    eval: evalCommand,
-    init: initCommand,
-    "mcp-stdio": mcpStdioCommand,
-    preview: previewCommand,
-    sync: syncCommand,
-    translate: translateCommand,
-    validate: validateCommand,
-    version: versionCommand,
+    add: lazyCommand(
+      commandMeta.add,
+      () => import("./commands/add.ts"),
+      "addCommand"
+    ),
+    audit: lazyCommand(
+      commandMeta.audit,
+      () => import("./commands/audit.ts"),
+      "auditCommand"
+    ),
+    build: lazyCommand(
+      commandMeta.build,
+      () => import("./commands/build.ts"),
+      "buildCommand"
+    ),
+    check: lazyCommand(
+      commandMeta.check,
+      () => import("./commands/check.ts"),
+      "checkCommand"
+    ),
+    dev: lazyCommand(
+      commandMeta.dev,
+      () => import("./commands/dev.ts"),
+      "devCommand"
+    ),
+    doctor: lazyCommand(
+      commandMeta.doctor,
+      () => import("./commands/doctor.ts"),
+      "doctorCommand"
+    ),
+    eject: lazyCommand(
+      commandMeta.eject,
+      () => import("./commands/eject.ts"),
+      "ejectCommand"
+    ),
+    eval: lazyCommand(
+      commandMeta.eval,
+      () => import("./commands/eval.ts"),
+      "evalCommand"
+    ),
+    init: lazyCommand(
+      commandMeta.init,
+      () => import("./commands/init.ts"),
+      "initCommand"
+    ),
+    "mcp-stdio": lazyCommand(
+      commandMeta["mcp-stdio"],
+      () => import("./commands/mcp-stdio.ts"),
+      "mcpStdioCommand"
+    ),
+    preview: lazyCommand(
+      commandMeta.preview,
+      () => import("./commands/preview.ts"),
+      "previewCommand"
+    ),
+    sync: lazyCommand(
+      commandMeta.sync,
+      () => import("./commands/sync.ts"),
+      "syncCommand"
+    ),
+    translate: lazyCommand(
+      commandMeta.translate,
+      () => import("./commands/translate.ts"),
+      "translateCommand"
+    ),
+    validate: lazyCommand(
+      commandMeta.validate,
+      () => import("./commands/validate.ts"),
+      "validateCommand"
+    ),
+    version: lazyCommand(
+      commandMeta.version,
+      () => import("./commands/version.ts"),
+      "versionCommand"
+    ),
   },
 });
 
-// Load `.env`/`.env.local` before any command runs so remote content sources
-// can read their tokens (e.g. `GITHUB_TOKEN`) during the content scan.
 loadEnvFiles(process.cwd());
 
-// Backstop for unexpected async failures that escape a command's own handling
-// (e.g. a rejected timer/watcher in `blume dev`), so even those report through
-// the stable internal-error contract rather than a bare stack trace.
 process.on("uncaughtException", (error) => {
   reportInternalError(error);
   process.exit(1);

package/src/cli/lazy-command.ts

@@ -0,0 +1,47 @@
+import type { ArgsDef, CommandDef, CommandMeta } from "citty";
+
+/**
+ * Wrap a command so its module is imported only when citty needs its `args`
+ * or runs it. `meta` stays static (from `command-meta.ts`), so rendering root
+ * usage, matching an unknown name, and `blume <cmd> --help` for *another*
+ * command never touch this one's dependency graph.
+ *
+ * `load` imports the command's module and `key` names its export, so the call
+ * site stays a plain `() => import("./commands/x.ts")`.
+ *
+ * Only `args`, `setup`, `run`, and `cleanup` are forwarded: no Blume command
+ * declares `default`, `plugins`, or nested `subCommands`.
+ */
+export const lazyCommand = <Args extends ArgsDef, Key extends string>(
+  meta: CommandMeta,
+  load: () => Promise<Record<Key, CommandDef<Args>>>,
+  key: Key
+): CommandDef<Args> => {
+  const command = async () => {
+    const module = await load();
+    return module[key];
+  };
+  return {
+    args: async () => {
+      const { args } = await command();
+      // SAFETY: every Blume command passes `args` to `defineCommand` as a plain
+      // object literal (the "command registry" test checks it); citty's
+      // `Resolvable` widening is the only reason the type also admits a thunk
+      // or a promise here.
+      return args as Args;
+    },
+    cleanup: async (context) => {
+      const loaded = await command();
+      await loaded.cleanup?.(context);
+    },
+    meta,
+    run: async (context) => {
+      const loaded = await command();
+      await loaded.run?.(context);
+    },
+    setup: async (context) => {
+      const loaded = await command();
+      await loaded.setup?.(context);
+    },
+  };
+};

package/src/components/content/GithubInfo.astro

@@ -3,6 +3,7 @@
 // at build time (no client JS). Pass `owner`/`repo`, or omit them to use the
 // repo from blume.config. A `GITHUB_TOKEN` env var lifts the API rate limit.
 // If the API is unreachable the card still renders, just without counts.
+import { getSecret } from "astro:env/server";
 import { apiUrl, PUBLIC_HOST_URL } from "../../core/github.ts";
 import { resolveIcon } from "../../theme/icons.ts";
 import data from "blume:data";
@@ -38,7 +39,9 @@ interface Props {
 const configured = data.config.github;
 const owner = Astro.props.owner ?? configured?.owner;
 const repo = Astro.props.repo ?? configured?.repo;
-const token = Astro.props.token ?? process.env.GITHUB_TOKEN;
+// Read through Astro's `getSecret` so the adapter's secret store is honored
+// (the card renders at build time, where that is the environment).
+const token = Astro.props.token ?? getSecret("GITHUB_TOKEN");
 // A `host` prop is reduced to its origin, as the config field is, so a
 // trailing slash or a path never lands mid-link.
 const host = Astro.props.host

package/src/components/content/mermaid-element.ts

@@ -42,6 +42,14 @@ class BlumeMermaid extends HTMLElement {
       const token = this.#renderToken;
       const mermaid = await loadMermaid();
       mermaid.initialize({
+        // Mermaid 12 defaults to the bundled ELK layout and the "neo" look,
+        // which re-lays out and restyles every existing diagram and pulls a
+        // ~1.4 MB ELK chunk onto any page with a flowchart. Pin the previous
+        // defaults so diagrams keep rendering as authored; a diagram opts
+        // into ELK or neo through its own front matter (`config: { layout:
+        // elk }`), which outranks these initialize() values.
+        layout: "dagre",
+        look: "classic",
         securityLevel: "strict",
         startOnLoad: false,
         theme: prefersDark() ? "dark" : "default",

package/src/components/layout/Analytics.astro

@@ -3,7 +3,7 @@ import VercelAnalytics from "@vercel/analytics/astro";
 
 // Analytics scripts injected into <head>. PostHog and custom providers use the
 // inline-snippet house style (banner/theme/JSON-LD); Vercel uses its official
-// Astro component. Loads ONLY in production builds so `blume dev` stays clean
+// Astro component; Cloudflare is its beacon script tag. Loads ONLY in production builds so `blume dev` stays clean
 // and local traffic never reaches your analytics.
 interface AnalyticsScript {
   attributes?: Record<string, string>;
@@ -14,6 +14,7 @@ interface AnalyticsScript {
 
 interface Props {
   analytics?: {
+    cloudflare?: { token: string };
     posthog?: { host?: string; key: string };
     scripts?: AnalyticsScript[];
     vercel?: boolean;
@@ -45,6 +46,14 @@ const posthogSnippet = posthog
   ? `${POSTHOG_LOADER}posthog.init(${JSON.stringify(posthog.key)},{api_host:${JSON.stringify(posthog.host ?? "https://us.i.posthog.com")}});${POSTHOG_SPA_PAGEVIEWS}`
   : null;
 
+// Cloudflare Web Analytics (manual setup): the beacon script keyed by the
+// site token, exactly as the dashboard's snippet renders it. It tracks
+// history changes itself, so client-router navigations need no extra hook.
+const cloudflareBeacon =
+  enabled && analytics?.cloudflare
+    ? JSON.stringify({ token: analytics.cloudflare.token })
+    : null;
+
 // Custom scripts: any other provider. Each is either external (`src`) or inline
 // (`content`). Explicit fields win over spread `attributes`.
 const customScripts = enabled ? (analytics?.scripts ?? []) : [];
@@ -62,6 +71,16 @@ const inlineScripts = customScripts
 ---
 
 {vercelEnabled && <VercelAnalytics />}
+{
+  cloudflareBeacon && (
+    <script
+      is:inline
+      defer
+      src="https://static.cloudflareinsights.com/beacon.min.js"
+      data-cf-beacon={cloudflareBeacon}
+    />
+  )
+}
 {posthogSnippet && <script is:inline set:html={posthogSnippet} />}
 {externalScripts.map((attrs) => <script is:inline {...attrs} />)}
 {

package/src/components/layout/PageLayout.astro

@@ -35,6 +35,7 @@ import {
 import { buildStructuredData } from "../../seo/jsonld.ts";
 import { normalizeXHandle } from "../../seo/x-handle.ts";
 import { withBase } from "../islands/base-path.ts";
+import { pageDirection, pageLocale } from "./page-locale.ts";
 import { searchLocaleFor } from "./search-locale.ts";
 import "blume:theme";
 import { ClientRouter } from "astro:transitions";
@@ -108,7 +109,11 @@ interface Props {
    */
   x?: { creator?: string; handle?: string };
   noindex?: boolean;
-  /** Active locale + direction for `<html lang>`/`<html dir>`. */
+  /**
+   * Active locale + direction for `<html lang>`/`<html dir>`. Default to the
+   * locale Astro resolved from the URL (`Astro.currentLocale`), then the site
+   * default, and to that locale's configured direction.
+   */
   locale?: string;
   dir?: "ltr" | "rtl";
   /** Resolved UI dictionary; English baseline when omitted. */
@@ -145,13 +150,19 @@ const {
   structuredDataEnabled,
   x,
   noindex,
-  locale = "en",
-  dir = "ltr",
+  locale: localeProp,
+  dir: dirProp,
   ui,
   localeSwitch,
   clientData,
 } = Astro.props;
 
+// The locale and direction: the page's own values when it passes them (the
+// content catch-all always does), else what Astro's i18n routing resolved for
+// this URL, else the site default (see `page-locale.ts`).
+const locale = pageLocale(data.config.i18n, localeProp, Astro.currentLocale);
+const dir = dirProp ?? pageDirection(data.config.i18n, locale);
+
 const clientDataJson = clientData
   ? JSON.stringify(clientData).replaceAll("<", "\\u003c")
   : null;