zudoku 0.82.2 → 0.82.3

package/dist/cli/cli.js

@@ -59,7 +59,7 @@ __export(llms_exports, {
   generateLlmsTxtFiles: () => generateLlmsTxtFiles
 });
 import { writeFile as writeFile5 } from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 import colors6 from "picocolors";
 async function generateLlmsTxtFiles({
   markdownFileInfos,
@@ -94,7 +94,7 @@ async function generateLlmsTxtFiles({
       }
     }
     const llmsTxt2 = llmsTxtParts.join("\n");
-    await writeFile5(path20.join(baseOutputDir, "llms.txt"), llmsTxt2, "utf-8");
+    await writeFile5(path21.join(baseOutputDir, "llms.txt"), llmsTxt2, "utf-8");
     console.log(colors6.blue("\u2713 generated llms.txt"));
   }
   if (llmsTxtFull) {
@@ -120,7 +120,7 @@ ${info.content}
     }
     const llmsFull = llmsFullParts.join("\n");
     await writeFile5(
-      path20.join(baseOutputDir, "llms-full.txt"),
+      path21.join(baseOutputDir, "llms-full.txt"),
       llmsFull,
       "utf-8"
     );
@@ -139,12 +139,12 @@ import { hideBin } from "yargs/helpers";
 import yargs from "yargs/yargs";
 
 // src/cli/build/handler.ts
-import path25 from "node:path";
+import path26 from "node:path";
 
 // src/vite/build.ts
 import { existsSync as existsSync2 } from "node:fs";
-import { mkdir as mkdir6, readFile as readFile4, rename as rename2, rm as rm3, writeFile as writeFile6 } from "node:fs/promises";
-import path23 from "node:path";
+import { mkdir as mkdir6, readFile as readFile5, rename as rename2, rm as rm3, writeFile as writeFile6 } from "node:fs/promises";
+import path24 from "node:path";
 import { build as esbuild } from "esbuild";
 import { createBuilder } from "vite";
 
@@ -230,7 +230,7 @@ var getZudokuRootDir = () => path.dirname(getPackageJsonPath("zudoku"));
 
 // src/config/loader.ts
 import { stat as stat2 } from "node:fs/promises";
-import path3 from "node:path";
+import path5 from "node:path";
 import colors2 from "picocolors";
 import {
   runnerImport,
@@ -321,7 +321,47 @@ var ZudokuError = class extends Error {
 
 // src/config/file-exists.ts
 import { stat } from "node:fs/promises";
-var fileExists = (path30) => stat(path30).then(() => true).catch(() => false);
+var fileExists = (path31) => stat(path31).then(() => true).catch(() => false);
+
+// src/config/plugin-versions.ts
+import { readFile } from "node:fs/promises";
+import path3 from "node:path";
+
+// src/vite/package-root.ts
+import path2 from "node:path";
+var findPackageRoot = async (startDir) => {
+  let dir = startDir;
+  while (dir !== path2.dirname(dir)) {
+    if (await fileExists(path2.join(dir, "package.json"))) return dir;
+    dir = path2.dirname(dir);
+  }
+};
+
+// src/config/plugin-versions.ts
+var getPluginVersions = async (pluginDirs) => {
+  const roots = await Promise.all(
+    [...new Set(pluginDirs)].map(findPackageRoot)
+  );
+  const resolved = await Promise.all(
+    roots.map(async (root) => {
+      if (!root) return void 0;
+      try {
+        const pkg = JSON.parse(
+          await readFile(path3.join(root, "package.json"), "utf-8")
+        );
+        if (!pkg.name) return void 0;
+        return { name: pkg.name, version: pkg.version ?? "unknown" };
+      } catch {
+        return void 0;
+      }
+    })
+  );
+  const byName = /* @__PURE__ */ new Map();
+  for (const version of resolved) {
+    if (version && !byName.has(version.name)) byName.set(version.name, version);
+  }
+  return [...byName.values()];
+};
 
 // src/config/validators/ZudokuConfig.ts
 import colors from "picocolors";
@@ -329,7 +369,7 @@ import { isValidElement as isValidElement2 } from "react";
 import { z as z7 } from "zod";
 
 // src/vite/plugin-theme.ts
-import path2 from "node:path";
+import path4 from "node:path";
 import { normalizeTheme } from "shiki";
 
 // src/lib/shiki.ts
@@ -782,7 +822,7 @@ ${rootVars.join("\n")}
           config.__meta.rootDir,
           ...config.__meta.dependencies,
           ...config.__pluginDirs ?? []
-        ].map((file) => path2.relative(path2.dirname(id), file))
+        ].map((file) => path4.relative(path4.dirname(id), file))
       );
       const code = [...files].map((file) => `@source "${file}";`);
       code.push("@theme inline {");
@@ -2990,8 +3030,8 @@ import { createNanoEvents } from "nanoevents";
 
 // src/lib/util/url.ts
 import { matchPath } from "react-router";
-var matchesProtectedPattern = (pattern, path30) => matchPath({ path: pattern, end: true }, path30) != null;
-var matchesAnyProtectedPattern = (patterns, path30) => patterns.some((p) => matchesProtectedPattern(p, path30));
+var matchesProtectedPattern = (pattern, path31) => matchPath({ path: pattern, end: true }, path31) != null;
+var matchesAnyProtectedPattern = (patterns, path31) => patterns.some((p) => matchesProtectedPattern(p, path31));
 
 // src/lib/core/ZudokuContext.ts
 var normalizeProtectedRoutes = (val) => {
@@ -3635,7 +3675,7 @@ var zudokuConfigFiles = [
 ];
 async function getConfigFilePath(rootDir) {
   for (const fileName of zudokuConfigFiles) {
-    const filepath = path3.join(rootDir, fileName);
+    const filepath = path5.join(rootDir, fileName);
     if (await fileExists(filepath)) {
       return filepath;
     }
@@ -3771,6 +3811,15 @@ async function loadZudokuConfig(configEnv, rootDir) {
       colors2.cyan(`loaded config file `) + colors2.dim(config.__meta.configPath),
       { timestamp: true }
     );
+    const pluginVersions = await getPluginVersions(config.__pluginDirs ?? []);
+    if (pluginVersions.length > 0) {
+      logger.info(
+        colors2.cyan(`loaded plugins `) + colors2.dim(
+          pluginVersions.map((p) => `${p.name}@${p.version}`).join(", ")
+        ),
+        { timestamp: true }
+      );
+    }
     return { config, envPrefix, publicEnv };
   } catch (error) {
     const lastValid = getConfig();
@@ -3846,7 +3895,7 @@ var getIssuer = async (config) => {
 init_joinUrl();
 
 // src/vite/config.ts
-import path16 from "node:path";
+import path17 from "node:path";
 import dotenv from "dotenv";
 import colors4 from "picocolors";
 import {
@@ -3894,22 +3943,12 @@ var buildManifest = (config) => {
 // src/vite/config.ts
 init_joinUrl();
 
-// src/vite/package-root.ts
-import path4 from "node:path";
-var findPackageRoot = async (startDir) => {
-  let dir = startDir;
-  while (dir !== path4.dirname(dir)) {
-    if (await fileExists(path4.join(dir, "package.json"))) return dir;
-    dir = path4.dirname(dir);
-  }
-};
-
 // src/vite/plugin.ts
 import tailwindcss from "@tailwindcss/vite";
 import react from "@vitejs/plugin-react";
 
 // src/vite/css/plugin.ts
-import path5 from "node:path";
+import path6 from "node:path";
 import { isCSSRequest as isCSSRequest2 } from "vite";
 
 // src/vite/css/collect.ts
@@ -3944,7 +3983,7 @@ var VIRTUAL_ENTRY = "virtual:ssr-css.css";
 function vitePluginSsrCss(pluginOpts) {
   let server;
   const config = getCurrentConfig();
-  const virtualHref = path5.join(
+  const virtualHref = path6.join(
     config.basePath ?? "",
     `/@id/__x00__${VIRTUAL_ENTRY}?direct`
   );
@@ -4076,12 +4115,12 @@ var plugin_api_keys_default = viteApiKeysPlugin;
 
 // src/vite/plugin-api.ts
 import fs2 from "node:fs/promises";
-import path11 from "node:path";
+import path12 from "node:path";
 import { deepEqual as deepEqual2 } from "fast-equals";
 import { runnerImport as runnerImport3 } from "vite";
 
 // src/config/validators/BuildSchema.ts
-import path6 from "node:path";
+import path7 from "node:path";
 import { runnerImport as runnerImport2 } from "vite";
 import { z as z8 } from "zod";
 var BuildProcessorSchema = z8.custom((val) => typeof val === "function");
@@ -4105,7 +4144,7 @@ var zudokuBuildConfigFiles = [
 ];
 async function getBuildConfigFilePath(rootDir) {
   for (const fileName of zudokuBuildConfigFiles) {
-    const filepath = path6.join(rootDir, fileName);
+    const filepath = path7.join(rootDir, fileName);
     if (await fileExists(filepath)) {
       return filepath;
     }
@@ -4227,14 +4266,14 @@ var flattenAllOf = (schema2) => {
 };
 
 // src/lib/util/traverse.ts
-var traverse = (specification, transform, path30 = []) => {
-  const transformed = transform(specification, path30);
+var traverse = (specification, transform, path31 = []) => {
+  const transformed = transform(specification, path31);
   if (typeof transformed !== "object" || transformed === null) {
     return transformed;
   }
   const result = Array.isArray(transformed) ? [] : {};
   for (const [key, value] of Object.entries(transformed)) {
-    const currentPath = [...path30, key];
+    const currentPath = [...path31, key];
     if (Array.isArray(value)) {
       result[key] = value.map(
         (item, index) => typeof item === "object" && item != null ? traverse(item, transform, [...currentPath, index.toString()]) : item
@@ -4262,9 +4301,9 @@ var resolveLocalRef = (schema2, ref) => {
   if (schemaCache?.has(ref)) {
     return schemaCache.get(ref);
   }
-  const path30 = ref.split("/").slice(1);
+  const path31 = ref.split("/").slice(1);
   let current = schema2;
-  for (const segment of path30) {
+  for (const segment of path31) {
     if (!current || typeof current !== "object") {
       current = null;
     }
@@ -4283,7 +4322,7 @@ var dereference = async (schema2, resolvers = []) => {
   }
   const cloned = structuredClone(schema2);
   const visited = /* @__PURE__ */ new Set();
-  const resolve = async (current, path30) => {
+  const resolve = async (current, path31) => {
     if (isIndexableObject(current)) {
       if (visited.has(current)) {
         return CIRCULAR_REF;
@@ -4291,7 +4330,7 @@ var dereference = async (schema2, resolvers = []) => {
       visited.add(current);
       if (Array.isArray(current)) {
         for (let index = 0; index < current.length; index++) {
-          current[index] = await resolve(current[index], `${path30}/${index}`);
+          current[index] = await resolve(current[index], `${path31}/${index}`);
         }
       } else {
         if ("$ref" in current && typeof current.$ref === "string") {
@@ -4302,13 +4341,13 @@ var dereference = async (schema2, resolvers = []) => {
           for (const resolver of resolvers) {
             const resolved = await resolver($ref);
             if (resolved) {
-              result2 = await resolve(resolved, path30);
+              result2 = await resolve(resolved, path31);
               break;
             }
           }
           if (result2 === void 0) {
             const resolved = await resolveLocalRef(cloned, $ref);
-            result2 = await resolve(resolved, path30);
+            result2 = await resolve(resolved, path31);
           }
           if (hasSiblings) {
             if (result2 === CIRCULAR_REF) {
@@ -4321,7 +4360,7 @@ var dereference = async (schema2, resolvers = []) => {
           return result2;
         }
         for (const key in current) {
-          current[key] = await resolve(current[key], `${path30}/${key}`);
+          current[key] = await resolve(current[key], `${path31}/${key}`);
         }
       }
       visited.delete(current);
@@ -4360,9 +4399,9 @@ var upgradeSchema = (schema2) => {
     }
     return sub;
   });
-  schema2 = traverse(schema2, (sub, path30) => {
+  schema2 = traverse(schema2, (sub, path31) => {
     if (sub.example !== void 0) {
-      if (isSchemaPath(path30 ?? [])) {
+      if (isSchemaPath(path31 ?? [])) {
         sub.examples = [sub.example];
       } else {
         sub.examples = {
@@ -4375,11 +4414,11 @@ var upgradeSchema = (schema2) => {
     }
     return sub;
   });
-  schema2 = traverse(schema2, (schema3, path30) => {
+  schema2 = traverse(schema2, (schema3, path31) => {
     if (schema3.type === "object" && schema3.properties !== void 0) {
-      const parentPath = path30?.slice(0, -1);
+      const parentPath = path31?.slice(0, -1);
       const isMultipart = parentPath?.some((segment, index) => {
-        return segment === "content" && path30?.[index + 1] === "multipart/form-data";
+        return segment === "content" && path31?.[index + 1] === "multipart/form-data";
       });
       if (isMultipart) {
         const entries = Object.entries(schema3.properties);
@@ -4393,8 +4432,8 @@ var upgradeSchema = (schema2) => {
     }
     return schema3;
   });
-  schema2 = traverse(schema2, (schema3, path30) => {
-    if (path30?.includes("content") && path30.includes("application/octet-stream")) {
+  schema2 = traverse(schema2, (schema3, path31) => {
+    if (path31?.includes("content") && path31.includes("application/octet-stream")) {
       return {};
     }
     if (schema3.type === "string" && schema3.format === "binary") {
@@ -4420,11 +4459,11 @@ var upgradeSchema = (schema2) => {
     }
     return sub;
   });
-  schema2 = traverse(schema2, (schema3, path30) => {
+  schema2 = traverse(schema2, (schema3, path31) => {
     if (schema3.type === "string" && schema3.format === "byte") {
-      const parentPath = path30?.slice(0, -1);
+      const parentPath = path31?.slice(0, -1);
       const contentMediaType = parentPath?.find(
-        (_, index) => path30?.[index - 1] === "content"
+        (_, index) => path31?.[index - 1] === "content"
       );
       return {
         type: "string",
@@ -4436,7 +4475,7 @@ var upgradeSchema = (schema2) => {
   });
   return schema2;
 };
-function isSchemaPath(path30) {
+function isSchemaPath(path31) {
   const schemaLocations = [
     ["components", "schemas"],
     "properties",
@@ -4449,10 +4488,10 @@ function isSchemaPath(path30) {
   ];
   return schemaLocations.some((location) => {
     if (Array.isArray(location)) {
-      return location.every((segment, index) => path30[index] === segment);
+      return location.every((segment, index) => path31[index] === segment);
     }
-    return path30.includes(location);
-  }) || path30.includes("schema") || path30.some((segment) => segment.endsWith("Schema"));
+    return path31.includes(location);
+  }) || path31.includes("schema") || path31.some((segment) => segment.endsWith("Schema"));
 }
 
 // src/lib/oas/parser/index.ts
@@ -4534,13 +4573,13 @@ var OPENAPI_PROPS = /* @__PURE__ */ new Set([
   "anyOf",
   "oneOf"
 ]);
-var handleCircularRefs = (obj, currentPath = /* @__PURE__ */ new WeakSet(), refs = /* @__PURE__ */ new WeakMap(), path30 = [], currentRefPaths = /* @__PURE__ */ new Set()) => {
+var handleCircularRefs = (obj, currentPath = /* @__PURE__ */ new WeakSet(), refs = /* @__PURE__ */ new WeakMap(), path31 = [], currentRefPaths = /* @__PURE__ */ new Set()) => {
   if (obj === null || typeof obj !== "object") return obj;
   const refPath = obj.__$ref;
   const isCircular = currentPath.has(obj) || typeof refPath === "string" && currentRefPaths.has(refPath);
   if (isCircular) {
     if (typeof refPath === "string") return SCHEMA_REF_PREFIX + refPath;
-    const circularProp = path30.find((p) => !OPENAPI_PROPS.has(p)) || path30[0];
+    const circularProp = path31.find((p) => !OPENAPI_PROPS.has(p)) || path31[0];
     return [CIRCULAR_REF, circularProp].filter(Boolean).join(":");
   }
   if (refs.has(obj)) return refs.get(obj);
@@ -4550,7 +4589,7 @@ var handleCircularRefs = (obj, currentPath = /* @__PURE__ */ new WeakSet(), refs
     value,
     currentPath,
     refs,
-    [...path30, key],
+    [...path31, key],
     currentRefPaths
   );
   const result = Array.isArray(obj) ? obj.map((item, i) => recurse(item, i.toString())) : Object.fromEntries(
@@ -4588,7 +4627,7 @@ var resolveExtensions = (obj) => Object.fromEntries(
 var getAllTags = (schema2) => {
   const rootTags = schema2.tags ?? [];
   const operations = Object.values(schema2.paths ?? {}).flatMap(
-    (path30) => HttpMethods.map((k) => path30?.[k]).filter((op) => op != null)
+    (path31) => HttpMethods.map((k) => path31?.[k]).filter((op) => op != null)
   );
   const operationTags = new Set(operations.flatMap((op) => op.tags ?? []));
   const hasUntaggedOperations = operations.some(
@@ -4643,7 +4682,7 @@ var getAllSlugs = (ops, schemaTags = []) => {
 var getOperationSlugKey = (op) => [op.path, op.method, op.operationId, op.summary].filter(Boolean).join("-");
 var getAllOperations = (paths) => {
   const operations = Object.entries(paths ?? {}).flatMap(
-    ([path30, value]) => HttpMethods.flatMap((method) => {
+    ([path31, value]) => HttpMethods.flatMap((method) => {
       if (!value?.[method]) return [];
       const operation = value[method];
       const pathParameters = value.parameters ?? [];
@@ -4663,7 +4702,7 @@ var getAllOperations = (paths) => {
       return {
         ...operation,
         method,
-        path: path30,
+        path: path31,
         parameters,
         servers,
         tags: operation.tags ?? []
@@ -5161,8 +5200,8 @@ var Schema = builder.objectRef("Schema").implement({
     }),
     paths: t.field({
       type: [PathItem],
-      resolve: (root) => Object.entries(root.paths ?? {}).map(([path30, value]) => ({
-        path: path30,
+      resolve: (root) => Object.entries(root.paths ?? {}).map(([path31, value]) => ({
+        path: path31,
         // biome-ignore lint/style/noNonNullAssertion: value is guaranteed to be defined
         methods: Object.keys(value)
       }))
@@ -5266,11 +5305,9 @@ var ensureArray = (value) => Array.isArray(value) ? value : [value];
 
 // src/vite/api/SchemaManager.ts
 import fs from "node:fs/promises";
-import path7 from "node:path";
-import {
-  $RefParser as $RefParser2
-} from "@apidevtools/json-schema-ref-parser";
-import { upgrade, validate as validate2 } from "@scalar/openapi-parser";
+import path8 from "node:path";
+import { $RefParser as $RefParser2 } from "@apidevtools/json-schema-ref-parser";
+import { upgrade } from "@scalar/openapi-parser";
 import { deepEqual } from "fast-equals";
 
 // src/lib/util/flattenAllOfProcessor.ts
@@ -5318,7 +5355,7 @@ init_joinUrl();
 
 // src/vite/api/schema-codegen.ts
 var unescapeJsonPointer = (uri) => decodeURIComponent(uri.replace(/~1/g, "/").replace(/~0/g, "~"));
-var getSegmentsFromPath = (path30) => path30.split("/").slice(1).map(unescapeJsonPointer);
+var getSegmentsFromPath = (path31) => path31.split("/").slice(1).map(unescapeJsonPointer);
 var createLocalRefMap = (obj) => {
   const refMap = /* @__PURE__ */ new Map();
   const siblingsMap = /* @__PURE__ */ new Map();
@@ -5349,16 +5386,16 @@ var replaceMarkers = (code, mergedRefs) => code.replace(/"__refMap:(.*?)"/g, '__
   /"__refMap\+Siblings:(.*?)"/g,
   (_, key) => mergedRefs.get(key) ?? `__refMap["${key}"]`
 );
-var lookup = (schema2, path30, filePath) => {
-  const parts = getSegmentsFromPath(path30);
+var lookup = (schema2, path31, filePath) => {
+  const parts = getSegmentsFromPath(path31);
   let val = schema2;
   for (const part of parts) {
     while (val.$ref?.startsWith("#/")) {
-      val = val.$ref === path30 ? val : lookup(schema2, val.$ref, filePath);
+      val = val.$ref === path31 ? val : lookup(schema2, val.$ref, filePath);
     }
     if (val[part] === void 0) {
       throw new Error(
-        `Error in ${filePath ?? "code generation"}: Could not find path segment ${part} in path: ${path30}`
+        `Error in ${filePath ?? "code generation"}: Could not find path segment ${part} in path: ${path31}`
       );
     }
     val = val[part];
@@ -5450,24 +5487,30 @@ var SchemaManager = class {
     this.storeDir = storeDir;
     this.config = config;
     this.processors = [
-      ({ schema: schema2 }) => upgrade(schema2).specification,
+      ({ schema: schema2 }) => {
+        const upgraded = upgrade(schema2).specification;
+        if (upgraded?.info && typeof upgraded.info.version !== "string") {
+          upgraded.info.version = "0.0.1";
+        }
+        return upgraded;
+      },
       flattenAllOfProcessor,
       ...processors
     ];
   }
   getPathForFile = (input, params) => {
-    const filePath = path7.resolve(this.config.__meta.rootDir, input);
+    const filePath = path8.resolve(this.config.__meta.rootDir, input);
     const apis = ensureArray(this.config.apis ?? []);
     for (const apiConfig of apis) {
       if (!apiConfig || apiConfig.type !== "file" || !apiConfig.path) continue;
       const match = normalizeInputs(apiConfig.input).some(
-        (i) => path7.resolve(this.config.__meta.rootDir, i.input) === filePath && deepEqual(i.params, params)
+        (i) => path8.resolve(this.config.__meta.rootDir, i.input) === filePath && deepEqual(i.params, params)
       );
       if (match) return apiConfig.path;
     }
   };
   processSchema = async (input) => {
-    const filePath = path7.resolve(this.config.__meta.rootDir, input.input);
+    const filePath = path8.resolve(this.config.__meta.rootDir, input.input);
     const params = input.params;
     const configuredPath = this.getPathForFile(input.input, params);
     if (!configuredPath) {
@@ -5485,7 +5528,6 @@ var SchemaManager = class {
       }
       this.referencedBy.get(file)?.add(filePath);
     });
-    const validatedSchema = await this.validateSchema(schema2, filePath);
     const processedSchema = await this.processors.reduce(
       async (schema3, processor) => processor({
         schema: await schema3,
@@ -5498,14 +5540,14 @@ var SchemaManager = class {
           }
         })
       }),
-      Promise.resolve(validatedSchema)
+      Promise.resolve(schema2)
     );
     const processedTime = Date.now();
     const code = generateCode(processedSchema, filePath);
     const prefixPath = slugify(configuredPath);
-    const processedFilePath = path7.posix.join(
+    const processedFilePath = path8.posix.join(
       this.storeDir,
-      `${prefixPath}-${path7.basename(filePath)}${paramsSuffix(params)}.js`
+      `${prefixPath}-${path8.basename(filePath)}${paramsSuffix(params)}.js`
     );
     const importKey = processedFilePath;
     await fs.writeFile(processedFilePath, code);
@@ -5558,7 +5600,7 @@ var SchemaManager = class {
   };
   getAllTrackedFiles = () => Array.from(this.referencedBy.keys());
   getFilesToReprocess = (changedFile) => {
-    const resolvedPath = path7.resolve(this.config.__meta.rootDir, changedFile);
+    const resolvedPath = path8.resolve(this.config.__meta.rootDir, changedFile);
     const referencedBy = this.referencedBy.get(resolvedPath);
     if (!referencedBy) return [];
     const filesToProcess = referencedBy.size === 0 ? [resolvedPath] : Array.from(referencedBy);
@@ -5587,7 +5629,7 @@ var SchemaManager = class {
         version: "",
         path: input.path ?? "",
         label: input.label,
-        inputPath: path7.resolve(this.config.__meta.rootDir, input.input),
+        inputPath: path8.resolve(this.config.__meta.rootDir, input.input),
         params: input.params,
         importKey: "",
         downloadUrl: "",
@@ -5607,8 +5649,8 @@ var SchemaManager = class {
       }
     }
   };
-  getLatestSchema = (path30) => this.processedSchemas[path30]?.at(0);
-  getSchemasForPath = (path30) => this.processedSchemas[path30];
+  getLatestSchema = (path31) => this.processedSchemas[path31]?.at(0);
+  getSchemasForPath = (path31) => this.processedSchemas[path31];
   getSchemaImports = () => Object.values(this.processedSchemas).flat().filter((s) => s.importKey);
   getUrlToFilePathMap = () => {
     const map = /* @__PURE__ */ new Map();
@@ -5630,7 +5672,7 @@ var SchemaManager = class {
   };
   createSchemaPath = (inputPath, versionPath, apiPath, params, config) => {
     const suffix = paramsSuffix(params);
-    const extension = suffix ? ".json" : path7.extname(inputPath);
+    const extension = suffix ? ".json" : path8.extname(inputPath);
     const fileName = config?.schemaDownload?.fileName ?? this.config.defaults?.apis?.schemaDownload?.fileName ?? "schema";
     return joinUrl(
       this.config.basePath,
@@ -5639,20 +5681,10 @@ var SchemaManager = class {
       `${fileName}${suffix}${extension}`
     );
   };
-  validateSchema = async (schema2, filePath) => {
-    const validated = await validate2(schema2);
-    if (validated.errors?.length) {
-      console.warn(`Schema warnings in ${filePath}:`);
-      for (const error of validated.errors) {
-        console.warn(error);
-      }
-    }
-    return schema2;
-  };
 };
 
 // src/vite/plugin-config-reload.ts
-import path10 from "node:path";
+import path11 from "node:path";
 import colors3 from "picocolors";
 
 // src/vite/plugin-navigation.ts
@@ -5660,14 +5692,14 @@ import { stringify as stringify3 } from "javascript-stringify";
 import { isElement } from "react-is";
 
 // src/config/validators/NavigationSchema.ts
-import path8 from "node:path";
+import path9 from "node:path";
 import { glob } from "glob";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { mdxFromMarkdown } from "mdast-util-mdx";
 import { mdxjs } from "micromark-extension-mdxjs";
 
 // src/lib/util/readFrontmatter.ts
-import { readFile } from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
 import matter from "gray-matter";
 import { parse, stringify as stringify2 } from "yaml";
 var yaml = {
@@ -5675,7 +5707,7 @@ var yaml = {
   stringify: (obj) => stringify2(obj)
 };
 var readFrontmatter = async (filePath) => {
-  const content = await readFile(filePath, "utf-8");
+  const content = await readFile2(filePath, "utf-8");
   const normalizedContent = content.replace(/\r\n/g, "\n");
   return matter(normalizedContent, { engines: { yaml } });
 };
@@ -5710,7 +5742,7 @@ var extractRichH1 = (content) => {
   }
 };
 var isNavigationItem = (item) => item !== void 0;
-var toPosixPath = (filePath) => filePath.split(path8.win32.sep).join(path8.posix.sep);
+var toPosixPath = (filePath) => filePath.split(path9.win32.sep).join(path9.posix.sep);
 var NavigationResolver = class {
   rootDir;
   globPatterns;
@@ -5843,13 +5875,13 @@ var NavigationResolver = class {
 
 // src/vite/debug.ts
 import { mkdir, writeFile } from "node:fs/promises";
-import path9 from "node:path";
+import path10 from "node:path";
 async function writePluginDebugCode(rootDir, pluginName, code, extension = "js") {
   if (process.env.ZUDOKU_BUILD_DEBUG) {
-    const debugDir = path9.join(rootDir, "dist", "debug");
+    const debugDir = path10.join(rootDir, "dist", "debug");
     await mkdir(debugDir, { recursive: true });
     await writeFile(
-      path9.join(debugDir, `${pluginName}.${extension}`),
+      path10.join(debugDir, `${pluginName}.${extension}`),
       typeof code === "string" ? code : code.join("\n")
     );
   }
@@ -5960,7 +5992,7 @@ var viteConfigReloadPlugin = () => ({
       });
       logger.info(
         colors3.blue(
-          `Config ${path10.basename(currentConfig.__meta.configPath)} changed. Reloading...`
+          `Config ${path11.basename(currentConfig.__meta.configPath)} changed. Reloading...`
         ),
         { timestamp: true }
       );
@@ -5975,11 +6007,11 @@ var viteApiPlugin = async () => {
   const resolvedVirtualModuleId4 = `\0${virtualModuleId4}`;
   const initialConfig = getCurrentConfig();
   const zuploProcessors = ZuploEnv.isZuplo ? await runnerImport3(
-    path11.resolve(getZudokuRootDir(), "src/zuplo/with-zuplo-processors.ts")
+    path12.resolve(getZudokuRootDir(), "src/zuplo/with-zuplo-processors.ts")
   ).then((m) => m.module.default(initialConfig.__meta.rootDir)) : [];
   const buildConfig = await getBuildConfig();
   const buildProcessors = buildConfig?.processors ?? [];
-  const tmpStoreDir = path11.posix.join(
+  const tmpStoreDir = path12.posix.join(
     initialConfig.__meta.rootDir,
     PROCESSED_STORE_SUBPATH
   );
@@ -6007,7 +6039,7 @@ var viteApiPlugin = async () => {
         const inputPath = pathMap.get(req.url);
         if (!inputPath) return next();
         const content = await fs2.readFile(inputPath, "utf-8");
-        const mimeType = path11.extname(inputPath).toLowerCase() === ".json" ? "application/json" : "application/x-yaml";
+        const mimeType = path12.extname(inputPath).toLowerCase() === ".json" ? "application/json" : "application/x-yaml";
         res.setHeader("Content-Type", `${mimeType}; charset=utf-8`);
         return res.end(content);
       });
@@ -6233,8 +6265,8 @@ var viteApiPlugin = async () => {
       if (process.env.NODE_ENV !== "production") return;
       for (const [urlPath, inputPath] of pathMap) {
         const content = await fs2.readFile(inputPath, "utf-8");
-        const outputPath = path11.join(config.__meta.rootDir, "dist", urlPath);
-        await fs2.mkdir(path11.dirname(outputPath), { recursive: true });
+        const outputPath = path12.join(config.__meta.rootDir, "dist", urlPath);
+        await fs2.mkdir(path12.dirname(outputPath), { recursive: true });
         await fs2.writeFile(outputPath, content, "utf-8");
       }
     }
@@ -6399,7 +6431,7 @@ var viteDocMetadataPlugin = () => ({
 });
 
 // src/vite/plugin-docs.ts
-import path12 from "node:path";
+import path13 from "node:path";
 import { glob as glob3 } from "glob";
 import globParent from "glob-parent";
 
@@ -6466,7 +6498,7 @@ var globMarkdownFiles = async (config, options = { absolute: false }) => {
     if (process.env.NODE_ENV !== "development") {
       const draftStatuses = await Promise.all(
         globbedFiles.map(async (file) => {
-          const absolutePath = path12.resolve(config.__meta.rootDir, file);
+          const absolutePath = path13.resolve(config.__meta.rootDir, file);
           const { data } = await readFrontmatter(absolutePath);
           return { file, isDraft: data.draft === true };
         })
@@ -6479,9 +6511,9 @@ var globMarkdownFiles = async (config, options = { absolute: false }) => {
       if (draftFiles.has(file)) {
         continue;
       }
-      const relativePath = path12.posix.relative(parent, file);
+      const relativePath = path13.posix.relative(parent, file);
       const routePath = ensureLeadingSlash(relativePath.replace(/\.mdx?$/, ""));
-      const filePath = options.absolute ? path12.resolve(config.__meta.rootDir, file) : file;
+      const filePath = options.absolute ? path13.resolve(config.__meta.rootDir, file) : file;
       fileMapping[routePath] = filePath;
     }
   }
@@ -6565,7 +6597,7 @@ var plugin_docs_default = viteDocsPlugin;
 
 // src/vite/plugin-markdown-export.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import path13 from "node:path";
+import path14 from "node:path";
 init_joinUrl();
 var processMarkdownFile = async (filePath) => {
   const { content: markdownContent, data: frontmatter } = await readFrontmatter(filePath);
@@ -6582,7 +6614,7 @@ ${markdownContent}`;
 };
 var getMarkdownOutputPath = (distDir, routePath) => {
   const segments = routePath === "/" ? ["index"] : routePath.split("/").filter(Boolean);
-  return `${path13.join(distDir, ...segments)}.md`;
+  return `${path14.join(distDir, ...segments)}.md`;
 };
 var resolveMarkdownRoutePath = (requestUrl, basePath) => {
   const pathname = requestUrl.split(/[?#]/)[0] ?? requestUrl;
@@ -6654,7 +6686,7 @@ var viteMarkdownExportPlugin = () => {
       if (process.env.NODE_ENV !== "production" || Object.keys(markdownFiles).length === 0 || !needsMdFiles(config)) {
         return;
       }
-      const distDir = path13.join(
+      const distDir = path14.join(
         config.__meta.rootDir,
         "dist",
         config.basePath ?? ""
@@ -6675,14 +6707,14 @@ var viteMarkdownExportPlugin = () => {
             content: finalMarkdown
           });
           const outputPath = getMarkdownOutputPath(distDir, routePath);
-          await mkdir2(path13.dirname(outputPath), { recursive: true });
+          await mkdir2(path14.dirname(outputPath), { recursive: true });
           await writeFile2(outputPath, finalMarkdown, "utf-8");
         } catch (error) {
           console.warn(`Failed to export markdown for ${routePath}:`, error);
         }
       }
       if (config.docs.llms.llmsTxt || config.docs.llms.llmsTxtFull) {
-        const markdownInfoPath = path13.join(
+        const markdownInfoPath = path14.join(
           config.__meta.rootDir,
           "node_modules/.zudoku/markdown-info.json"
         );
@@ -6699,9 +6731,11 @@ var plugin_markdown_export_default = viteMarkdownExportPlugin;
 
 // src/vite/plugin-mdx.ts
 import rehypeMetaAsAttributes from "@lekoarts/rehype-meta-as-attributes";
+import { nodeTypes } from "@mdx-js/mdx";
 import mdx from "@mdx-js/rollup";
 import { toString as hastToString2 } from "hast-util-to-string";
 import rehypeMdxImportMedia from "rehype-mdx-import-media";
+import rehypeRaw from "rehype-raw";
 import rehypeSlug from "rehype-slug";
 import remarkComment from "remark-comment";
 import remarkDirective from "remark-directive";
@@ -6832,9 +6866,9 @@ var remarkCodeTabs = () => (tree) => {
 };
 
 // src/vite/mdx/remark-inject-filepath.ts
-import path14 from "node:path";
+import path15 from "node:path";
 var remarkInjectFilepath = (rootDir) => (tree, vfile) => {
-  const relativePath = path14.relative(rootDir, vfile.path).split(path14.sep).join(path14.posix.sep);
+  const relativePath = path15.relative(rootDir, vfile.path).split(path15.sep).join(path15.posix.sep);
   tree.children.unshift(exportMdxjsConst("__filepath", relativePath));
 };
 
@@ -6921,7 +6955,7 @@ var remarkLastModified = () => {
 };
 
 // src/vite/mdx/remark-link-rewrite.ts
-import path15 from "node:path";
+import path16 from "node:path";
 import { visit as visit5 } from "unist-util-visit";
 var markdownExtension = /\.mdx?$/;
 var resolveToRoute = (url, filePath, routesByFile) => {
@@ -6929,7 +6963,7 @@ var resolveToRoute = (url, filePath, routesByFile) => {
   if (!markdownExtension.test(pathname) || pathname.startsWith("/")) {
     return void 0;
   }
-  const targetFile = path15.resolve(path15.dirname(filePath), pathname).replace(markdownExtension, "");
+  const targetFile = path16.resolve(path16.dirname(filePath), pathname).replace(markdownExtension, "");
   const route = routesByFile.get(targetFile);
   if (route === void 0) return void 0;
   return `${route}${suffix}`;
@@ -6944,11 +6978,11 @@ var remarkLinkRewrite = (basePath = "", routesByFile = /* @__PURE__ */ new Map()
       node.url = resolved;
       return;
     }
-    const base = path15.posix.join(basePath);
+    const base = path16.posix.join(basePath);
     if (basePath && node.url.startsWith(base)) {
       node.url = node.url.slice(base.length);
     } else if (!node.url.startsWith("/") && !node.url.startsWith("#")) {
-      node.url = path15.posix.join("..", node.url);
+      node.url = path16.posix.join("..", node.url);
     }
     node.url = node.url.replace(/\.mdx?(#.*)?$/, "$1");
   });
@@ -7146,6 +7180,7 @@ var viteMdxPlugin = async () => {
   ];
   const remarkPlugins = typeof buildConfig?.remarkPlugins === "function" ? buildConfig.remarkPlugins(defaultRemarkPlugins) : [...defaultRemarkPlugins, ...buildConfig?.remarkPlugins ?? []];
   const defaultRehypePlugins = [
+    [rehypeRaw, { passThrough: nodeTypes }],
     rehypeSlug,
     rehype_extract_toc_with_jsx_default,
     rehype_extract_toc_with_jsx_export_default,
@@ -7456,8 +7491,8 @@ var protectedAnnotatorPlugin = () => ({
 });
 
 // src/vite/config.ts
-var getAppClientEntryPath = () => path16.posix.join(getZudokuRootDir(), "src/app/entry.client.tsx");
-var getAppServerEntryPath = () => path16.posix.join(getZudokuRootDir(), "src/app/entry.server.tsx");
+var getAppClientEntryPath = () => path17.posix.join(getZudokuRootDir(), "src/app/entry.client.tsx");
+var getAppServerEntryPath = () => path17.posix.join(getZudokuRootDir(), "src/app/entry.server.tsx");
 var hasLoggedCdnInfo = false;
 var MEDIA_REGEX = /\.(a?png|jpe?g|gif|bmp|svg|webp|tiff|ico|webm|ogg|mp3|wav|m4a|avif|mp4)/i;
 var defineEnvVars = (vars) => Object.fromEntries(
@@ -7491,7 +7526,7 @@ async function getViteConfig(dir, configEnv, options = {}) {
   );
   if (ZuploEnv.isZuplo) {
     dotenv.config({
-      path: path16.resolve(config.__meta.rootDir, "../.env.zuplo"),
+      path: path17.resolve(config.__meta.rootDir, "../.env.zuplo"),
       quiet: true
     });
   }
@@ -7551,7 +7586,7 @@ async function getViteConfig(dir, configEnv, options = {}) {
       sourcemap: true,
       target: "es2022",
       chunkSizeWarningLimit: 1500,
-      outDir: path16.resolve(path16.join(dir, "dist", config.basePath ?? "")),
+      outDir: path17.resolve(path17.join(dir, "dist", config.basePath ?? "")),
       emptyOutDir: false,
       rolldownOptions: {
         external: [joinUrl(config.basePath, "/pagefind/pagefind.js")],
@@ -7581,8 +7616,8 @@ async function getViteConfig(dir, configEnv, options = {}) {
           external: ["@shikijs/themes", "@shikijs/langs"]
         },
         build: {
-          outDir: path16.resolve(
-            path16.join(dir, "dist", config.basePath ?? "", "server")
+          outDir: path17.resolve(
+            path17.join(dir, "dist", config.basePath ?? "", "server")
           ),
           copyPublicDir: false,
           rolldownOptions: {
@@ -7597,7 +7632,7 @@ async function getViteConfig(dir, configEnv, options = {}) {
         if (filename.startsWith(`${PROTECTED_CHUNK_DIR}/`)) {
           return joinUrl(config.basePath, `/${filename}`);
         }
-        if (cdnUrl?.base && [".js", ".css"].includes(path16.extname(filename))) {
+        if (cdnUrl?.base && [".js", ".css"].includes(path17.extname(filename))) {
           return joinUrl(cdnUrl.base, filename);
         }
         if (cdnUrl?.media && MEDIA_REGEX.test(filename)) {
@@ -7607,7 +7642,7 @@ async function getViteConfig(dir, configEnv, options = {}) {
       }
     },
     optimizeDeps: {
-      entries: [path16.posix.join(getZudokuRootDir(), "src/{app,lib}/**")],
+      entries: [path17.posix.join(getZudokuRootDir(), "src/{app,lib}/**")],
       exclude: ["zudoku"],
       include: [
         "@mdx-js/react",
@@ -7704,10 +7739,10 @@ ${cssLinks}
 
 // src/vite/manifest.ts
 import { writeFile as writeFile3 } from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 var writeManifest = async (distDir, config) => {
   await writeFile3(
-    path17.join(distDir, MANIFEST_FILENAME),
+    path18.join(distDir, MANIFEST_FILENAME),
     `${JSON.stringify(buildManifest(config), null, 2)}
 `,
     "utf-8"
@@ -7717,7 +7752,7 @@ var writeManifest = async (distDir, config) => {
 // src/vite/output.ts
 import assert from "node:assert";
 import { cp, mkdir as mkdir3, writeFile as writeFile4 } from "node:fs/promises";
-import path18 from "node:path";
+import path19 from "node:path";
 init_joinUrl();
 var pkgJson = getZudokuPackageJson();
 function generateOutput({
@@ -7775,9 +7810,9 @@ async function writeOutput(dir, {
   rewrites
 }) {
   const output = generateOutput({ config, redirects, rewrites });
-  const outputDir = process.env.VERCEL ? path18.join(dir, ".vercel/output") : path18.join(dir, "dist/.output");
+  const outputDir = process.env.VERCEL ? path19.join(dir, ".vercel/output") : path19.join(dir, "dist/.output");
   await mkdir3(outputDir, { recursive: true });
-  const outputFile = path18.join(outputDir, "config.json");
+  const outputFile = path19.join(outputDir, "config.json");
   await writeFile4(outputFile, JSON.stringify(output, null, 2), "utf-8");
   if (process.env.VERCEL) {
     console.log("Wrote Vercel output to", outputDir);
@@ -7786,9 +7821,9 @@ async function writeOutput(dir, {
 
 // src/vite/prerender/prerender.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import { readFile as readFile2, rm } from "node:fs/promises";
+import { readFile as readFile3, rm } from "node:fs/promises";
 import os from "node:os";
-import path21 from "node:path";
+import path22 from "node:path";
 import { pathToFileURL } from "node:url";
 import { createIndex } from "pagefind";
 import colors7 from "picocolors";
@@ -7828,7 +7863,7 @@ function throttle(fn) {
 init_joinUrl();
 import { createWriteStream, existsSync } from "node:fs";
 import { mkdir as mkdir4 } from "node:fs/promises";
-import path19 from "node:path";
+import path20 from "node:path";
 import colors5 from "picocolors";
 import { SitemapStream } from "sitemap";
 async function generateSitemap({
@@ -7842,11 +7877,11 @@ async function generateSitemap({
     return;
   }
   const sitemap = new SitemapStream({ hostname: config.siteUrl });
-  const outputDir = path19.resolve(baseOutputDir, config.outDir ?? "");
+  const outputDir = path20.resolve(baseOutputDir, config.outDir ?? "");
   if (!existsSync(outputDir)) {
     await mkdir4(outputDir, { recursive: true });
   }
-  const sitemapOutputPath = path19.join(outputDir, "sitemap.xml");
+  const sitemapOutputPath = path20.join(outputDir, "sitemap.xml");
   const writeStream = createWriteStream(sitemapOutputPath);
   sitemap.pipe(writeStream);
   let lastmod;
@@ -7876,14 +7911,14 @@ async function generateSitemap({
 
 // src/vite/prerender/utils.ts
 init_joinUrl();
-var resolveRoutePath = (path30) => {
-  const segments = path30.split("/");
+var resolveRoutePath = (path31) => {
+  const segments = path31.split("/");
   if (segments.some((s) => s.startsWith(":") && !s.endsWith("?"))) {
     return void 0;
   }
   return segments.filter((s) => !s.startsWith(":")).join("/") || void 0;
 };
-var isSkipped = (path30) => path30.includes("*") || /^\d+$/.test(path30);
+var isSkipped = (path31) => path31.includes("*") || /^\d+$/.test(path31);
 var resolveRoutes = (routes, parentPath = "") => routes.flatMap((route) => {
   if (route.path && isSkipped(route.path)) return [];
   const routePath = route.path ? resolveRoutePath(route.path) : void 0;
@@ -7913,6 +7948,16 @@ var collectRewrites = (resolved) => resolved.flatMap((r) => [
 ]);
 var routesToPaths = (routes) => collectPaths(resolveRoutes(routes), "");
 var routesToRewrites = (routes) => collectRewrites(resolveRoutes(routes));
+var selectPagesToIndex = (pages, paths) => {
+  const withUrl = pages.flatMap(({ indexStatusCode, html }, i) => {
+    const url = paths[i];
+    return url === void 0 ? [] : [{ url, html, indexStatusCode }];
+  });
+  return {
+    include: withUrl.filter((p) => p.indexStatusCode < 400).map(({ url, html }) => ({ url, html })),
+    exclude: withUrl.filter((p) => p.indexStatusCode >= 400).map(({ url, indexStatusCode }) => ({ url, status: indexStatusCode }))
+  };
+};
 
 // src/vite/prerender/prerender.ts
 var Piscina = PiscinaImport;
@@ -7932,12 +7977,12 @@ var prerender = async ({
   serverConfigFilename,
   writeRedirects = true
 }) => {
-  const distDir = path21.join(dir, "dist", basePath);
+  const distDir = path22.join(dir, "dist", basePath);
   const serverConfigPath = pathToFileURL(
-    path21.join(distDir, "server", serverConfigFilename)
+    path22.join(distDir, "server", serverConfigFilename)
   ).href;
   const entryServerPath = pathToFileURL(
-    path21.join(distDir, "server/entry.server.js")
+    path22.join(distDir, "server/entry.server.js")
   ).href;
   const rawConfig = await import(serverConfigPath).then((m) => m.default);
   const config = validateConfig(await runPluginTransformConfig(rawConfig));
@@ -8026,9 +8071,18 @@ var prerender = async ({
     logger.info(colors7.blue(message));
   }
   if (pagefindIndex) {
-    const pagesToIndex = workerResults.flatMap(
-      ({ statusCode, html: html2 }, i) => statusCode < 400 ? { url: paths[i], html: html2 } : []
+    const { include: pagesToIndex, exclude } = selectPagesToIndex(
+      workerResults,
+      paths
     );
+    if (exclude.length > 0) {
+      const details = exclude.map(({ url, status }) => `${url} (${status})`).join(", ");
+      logger.warn(
+        colors7.yellow(
+          `\u26A0 ${exclude.length} route(s) excluded from the search index (render status >= 400): ${details}`
+        )
+      );
+    }
     const BATCH_SIZE = 40;
     const pagefindStart = performance.now();
     for (let offset = 0; offset < pagesToIndex.length; offset += BATCH_SIZE) {
@@ -8047,7 +8101,7 @@ var prerender = async ({
     }
     if (isTTY()) writeLine("");
     const { outputPath } = await pagefindIndex.writeFiles({
-      outputPath: path21.join(distDir, "pagefind")
+      outputPath: path22.join(distDir, "pagefind")
     });
     if (outputPath) {
       const duration = (performance.now() - pagefindStart) / 1e3;
@@ -8067,13 +8121,13 @@ var prerender = async ({
     redirectUrls
   });
   const llmsConfig = config.docs.llms;
-  const markdownInfoPath = path21.join(
+  const markdownInfoPath = path22.join(
     dir,
     "node_modules/.zudoku/markdown-info.json"
   );
   let markdownFileInfos = [];
   if (await fileExists(markdownInfoPath)) {
-    const markdownInfoContent = await readFile2(markdownInfoPath, "utf-8");
+    const markdownInfoContent = await readFile3(markdownInfoPath, "utf-8");
     markdownFileInfos = JSON.parse(markdownInfoContent);
   }
   if (llmsConfig.llmsTxt || llmsConfig.llmsTxtFull) {
@@ -8093,7 +8147,7 @@ var prerender = async ({
     await Promise.all(
       markdownFileInfos.map((info) => {
         const outputPath = getMarkdownOutputPath(distDir, info.routePath);
-        if (!path21.resolve(outputPath).startsWith(path21.resolve(distDir))) {
+        if (!path22.resolve(outputPath).startsWith(path22.resolve(distDir))) {
           return;
         }
         return rm(outputPath).catch(() => {
@@ -8151,8 +8205,8 @@ var getContainerMemoryLimitMb = () => {
 };
 
 // src/vite/protected/build.ts
-import { mkdir as mkdir5, readdir, readFile as readFile3, rename, rm as rm2 } from "node:fs/promises";
-import path22 from "node:path";
+import { mkdir as mkdir5, readdir, readFile as readFile4, rename, rm as rm2 } from "node:fs/promises";
+import path23 from "node:path";
 init_joinUrl();
 var assertProtectedPatternsCovered = (config) => {
   const { patterns } = getProtectedSourceMatcher(config);
@@ -8174,11 +8228,11 @@ var findProtectedLeaks = (output) => {
     const visited = /* @__PURE__ */ new Set();
     const stack = [{ fileName: entry.fileName, path: [entry.fileName] }];
     while (stack.length > 0) {
-      const { fileName, path: path30 } = stack.pop();
+      const { fileName, path: path31 } = stack.pop();
       if (visited.has(fileName)) continue;
       visited.add(fileName);
       for (const imp of byFileName.get(fileName)?.imports ?? []) {
-        const next = [...path30, imp];
+        const next = [...path31, imp];
         if (isProtected(imp)) {
           leaks.push(next.join(" -> "));
           continue;
@@ -8209,17 +8263,17 @@ This eagerly pulls gated content into the public bundle. Check that nothing in n
   );
 };
 var moveProtectedChunks = async (clientOutDir, serverOutDir) => {
-  const srcDir = path22.join(clientOutDir, PROTECTED_CHUNK_DIR);
+  const srcDir = path23.join(clientOutDir, PROTECTED_CHUNK_DIR);
   const files = await readdir(srcDir).catch((err) => {
     if (err.code === "ENOENT") return null;
     throw err;
   });
   if (!files) return;
-  const destDir = path22.join(serverOutDir, PROTECTED_CHUNK_DIR);
+  const destDir = path23.join(serverOutDir, PROTECTED_CHUNK_DIR);
   await mkdir5(destDir, { recursive: true });
   await Promise.all(
     files.map(
-      (file) => rename(path22.join(srcDir, file), path22.join(destDir, file))
+      (file) => rename(path23.join(srcDir, file), path23.join(destDir, file))
     )
   );
   const leftover = await readdir(srcDir).catch(() => []);
@@ -8237,7 +8291,7 @@ var assertCloudflareWranglerGatesProtected = async (dir, config) => {
   const protectedPrefix = `${joinUrl(config.basePath, PROTECTED_CHUNK_DIR)}/`;
   const candidates = ["wrangler.toml", "wrangler.jsonc", "wrangler.json"];
   for (const name of candidates) {
-    const file = await readFile3(path22.join(dir, name), "utf-8").catch(
+    const file = await readFile4(path23.join(dir, name), "utf-8").catch(
       () => void 0
     );
     if (file === void 0) continue;
@@ -8265,7 +8319,7 @@ async function runBuild(options) {
   const builder2 = await createBuilder(viteConfig);
   invariant(builder2.environments.client, "Client environment is missing");
   invariant(builder2.environments.ssr, "SSR environment is missing");
-  const distDir = path23.resolve(path23.join(dir, "dist"));
+  const distDir = path24.resolve(path24.join(dir, "dist"));
   await rm3(distDir, { recursive: true, force: true });
   const [clientResult, serverResult] = await Promise.all([
     builder2.build(builder2.environments.client),
@@ -8315,13 +8369,13 @@ async function runBuild(options) {
       await assertCloudflareWranglerGatesProtected(dir, config);
     }
     await writeFile6(
-      path23.join(distDir, "package.json"),
+      path24.join(distDir, "package.json"),
       `${JSON.stringify({ type: "module" }, null, 2)}
 `,
       "utf-8"
     );
     await writeManifest(distDir, config);
-    await rm3(path23.join(clientOutDir, "index.html"), { force: true });
+    await rm3(path24.join(clientOutDir, "index.html"), { force: true });
   } else {
     await runPrerender({
       dir,
@@ -8352,25 +8406,25 @@ var runPrerender = async (options) => {
       serverConfigFilename,
       writeRedirects: process.env.VERCEL === void 0
     });
-    const indexHtml = path23.join(clientOutDir, "index.html");
+    const indexHtml = path24.join(clientOutDir, "index.html");
     if (!workerResults.find((r) => r.outputPath === indexHtml)) {
       await writeFile6(indexHtml, html, "utf-8");
     }
     const statusPages = workerResults.flatMap(
-      (r) => /^(400|404|500)\.html$/.test(path23.basename(r.outputPath)) ? r.outputPath : []
+      (r) => /^(400|404|500)\.html$/.test(path24.basename(r.outputPath)) ? r.outputPath : []
     );
     for (const statusPage of statusPages) {
       await rename2(
         statusPage,
-        path23.join(dir, DIST_DIR, path23.basename(statusPage))
+        path24.join(dir, DIST_DIR, path24.basename(statusPage))
       );
     }
     await rm3(serverOutDir, { recursive: true, force: true });
     if (process.env.VERCEL) {
-      await mkdir6(path23.join(dir, ".vercel/output/static"), { recursive: true });
+      await mkdir6(path24.join(dir, ".vercel/output/static"), { recursive: true });
       await rename2(
-        path23.join(dir, DIST_DIR),
-        path23.join(dir, ".vercel/output/static")
+        path24.join(dir, DIST_DIR),
+        path24.join(dir, ".vercel/output/static")
       );
     }
     await writeOutput(dir, {
@@ -8381,7 +8435,7 @@ var runPrerender = async (options) => {
     if (ZuploEnv.isZuplo && issuer) {
       const provider = config.authentication?.type;
       await writeFile6(
-        path23.join(dir, DIST_DIR, ".output/zuplo.json"),
+        path24.join(dir, DIST_DIR, ".output/zuplo.json"),
         JSON.stringify({ issuer, provider }, null, 2),
         "utf-8"
       );
@@ -8393,7 +8447,7 @@ var runPrerender = async (options) => {
 };
 var findUserEntry = (dir) => {
   for (const ext of ["ts", "tsx", "js", "mjs"]) {
-    const candidate = path23.join(dir, `zudoku.server.${ext}`);
+    const candidate = path24.join(dir, `zudoku.server.${ext}`);
     if (existsSync2(candidate)) return candidate;
   }
 };
@@ -8404,15 +8458,15 @@ var bundleSSREntry = async (options) => {
   let entryPoint = userEntry;
   let tempEntryPath;
   if (!entryPoint) {
-    tempEntryPath = path23.join(dir, "__ssr-entry.ts");
-    const templateContent = await readFile4(
-      path23.join(packageRoot, "src/vite/ssr-templates", `${adapter}.ts`),
+    tempEntryPath = path24.join(dir, "__ssr-entry.ts");
+    const templateContent = await readFile5(
+      path24.join(packageRoot, "src/vite/ssr-templates", `${adapter}.ts`),
       "utf-8"
     );
     await writeFile6(tempEntryPath, templateContent, "utf-8");
     entryPoint = tempEntryPath;
   }
-  const frameworkPath = path23.join(serverOutDir, "entry.server.js");
+  const frameworkPath = path24.join(serverOutDir, "entry.server.js");
   try {
     await esbuild({
       entryPoints: [entryPoint],
@@ -8420,9 +8474,9 @@ var bundleSSREntry = async (options) => {
       platform: ["node", "lambda"].includes(adapter) ? "node" : "neutral",
       target: "es2022",
       format: "esm",
-      outfile: path23.join(serverOutDir, "entry.js"),
+      outfile: path24.join(serverOutDir, "entry.js"),
       external: ["./zudoku.config.js"],
-      nodePaths: [path23.join(packageRoot, "node_modules")],
+      nodePaths: [path24.join(packageRoot, "node_modules")],
       banner: { js: "// Bundled SSR entry" },
       define: {
         __ZUDOKU_TEMPLATE__: JSON.stringify(html)
@@ -8441,7 +8495,7 @@ var bundleSSREntry = async (options) => {
     await Promise.all([
       rm3(frameworkPath, { force: true }),
       rm3(`${frameworkPath}.map`, { force: true }),
-      rm3(path23.join(serverOutDir, "assets"), {
+      rm3(path24.join(serverOutDir, "assets"), {
         recursive: true,
         force: true
       })
@@ -8471,11 +8525,11 @@ function printWarningToConsole(message) {
 }
 
 // src/cli/preview/handler.ts
-import path24 from "node:path";
+import path25 from "node:path";
 import { preview as vitePreview } from "vite";
 var DEFAULT_PREVIEW_PORT = 4e3;
 async function preview(argv) {
-  const dir = path24.resolve(process.cwd(), argv.dir);
+  const dir = path25.resolve(process.cwd(), argv.dir);
   const viteConfig = await getViteConfig(dir, {
     command: "serve",
     mode: "production",
@@ -8513,7 +8567,7 @@ async function build(argv) {
   printDiagnosticsToConsole(`Starting Zudoku build v${packageJson2.version}`);
   printDiagnosticsToConsole("");
   printDiagnosticsToConsole("");
-  const dir = path25.resolve(process.cwd(), argv.dir);
+  const dir = path26.resolve(process.cwd(), argv.dir);
   try {
     await runBuild({
       dir,
@@ -8667,13 +8721,13 @@ var build_default = {
 
 // src/cli/dev/handler.ts
 init_joinUrl();
-import path28 from "node:path";
+import path29 from "node:path";
 
 // src/vite/dev-server.ts
 import fs3 from "node:fs/promises";
 import http from "node:http";
 import https from "node:https";
-import path27 from "node:path";
+import path28 from "node:path";
 import { stripVTControlCharacters } from "node:util";
 import { createHttpTerminator } from "http-terminator";
 import {
@@ -8705,7 +8759,7 @@ async function findAvailablePort(startPort) {
 init_joinUrl();
 
 // src/vite/pagefind-dev-index.ts
-import path26 from "node:path";
+import path27 from "node:path";
 import { createIndex as createIndex2 } from "pagefind";
 import { isRunnableDevEnvironment } from "vite";
 init_joinUrl();
@@ -8759,7 +8813,7 @@ async function* buildPagefindDevIndex(vite, config) {
       path: urlPath
     };
   }
-  const outputPath = path26.join(vite.config.publicDir, "pagefind");
+  const outputPath = path27.join(vite.config.publicDir, "pagefind");
   await pagefindIndex.writeFiles({ outputPath });
   yield { type: "complete", success: true, indexed };
 }
@@ -8779,9 +8833,9 @@ var DevServer = class {
     this.protocol = "https";
     const { dir } = this.#options;
     const [key, cert, ca] = await Promise.all([
-      fs3.readFile(path27.resolve(dir, config.https.key)),
-      fs3.readFile(path27.resolve(dir, config.https.cert)),
-      config.https.ca ? fs3.readFile(path27.resolve(dir, config.https.ca)) : void 0
+      fs3.readFile(path28.resolve(dir, config.https.key)),
+      fs3.readFile(path28.resolve(dir, config.https.cert)),
+      config.https.ca ? fs3.readFile(path28.resolve(dir, config.https.ca)) : void 0
     ]);
     return https.createServer({ key, cert, ca });
   }
@@ -8809,7 +8863,7 @@ var DevServer = class {
           // built-in transform middleware which would treat the path as a static asset.
           name: "zudoku:entry-client",
           configureServer(server2) {
-            const entryPath = path27.posix.join(
+            const entryPath = path28.posix.join(
               server2.config.base,
               "/__z/entry.client.tsx"
             );
@@ -8921,13 +8975,13 @@ var DevServer = class {
       `Server-side rendering ${this.#options.ssr ? "enabled" : "disabled"}`
     );
     if (config.search?.type === "pagefind") {
-      const pagefindPath = path27.join(
+      const pagefindPath = path28.join(
         vite.config.publicDir,
         "pagefind/pagefind.js"
       );
       const exists = await fs3.stat(pagefindPath).catch(() => false);
       if (!exists) {
-        await fs3.mkdir(path27.dirname(pagefindPath), { recursive: true });
+        await fs3.mkdir(path28.dirname(pagefindPath), { recursive: true });
         await fs3.writeFile(pagefindPath, 'throw new Error("NOT_BUILT_YET");');
       }
     }
@@ -9029,7 +9083,7 @@ var DevServer = class {
 async function dev(argv) {
   const packageJson2 = getZudokuPackageJson();
   process.env.NODE_ENV = "development";
-  const dir = path28.resolve(process.cwd(), argv.dir);
+  const dir = path29.resolve(process.cwd(), argv.dir);
   const server = new DevServer({
     dir,
     argPort: argv.port,
@@ -9135,7 +9189,7 @@ var preview_default = previewCommand;
 
 // src/cli/common/outdated.ts
 import { existsSync as existsSync3, mkdirSync } from "node:fs";
-import { readFile as readFile5, writeFile as writeFile7 } from "node:fs/promises";
+import { readFile as readFile6, writeFile as writeFile7 } from "node:fs/promises";
 import { join } from "node:path";
 import colors10 from "picocolors";
 import { gt } from "semver";
@@ -9185,12 +9239,12 @@ function box(message, {
 
 // src/cli/common/xdg/lib.ts
 import { homedir } from "node:os";
-import path29 from "node:path";
+import path30 from "node:path";
 function defineDirectoryWithFallback(xdgName, fallback) {
   if (process.env[xdgName]) {
     return process.env[xdgName];
   } else {
-    return path29.join(homedir(), fallback);
+    return path30.join(homedir(), fallback);
   }
 }
 var XDG_CONFIG_HOME = defineDirectoryWithFallback(
@@ -9205,15 +9259,15 @@ var XDG_STATE_HOME = defineDirectoryWithFallback(
   "XDG_DATA_HOME",
   ".local/state"
 );
-var ZUDOKU_XDG_CONFIG_HOME = path29.join(
+var ZUDOKU_XDG_CONFIG_HOME = path30.join(
   XDG_CONFIG_HOME,
   CLI_XDG_FOLDER_NAME
 );
-var ZUDOKU_XDG_DATA_HOME = path29.join(
+var ZUDOKU_XDG_DATA_HOME = path30.join(
   XDG_DATA_HOME,
   CLI_XDG_FOLDER_NAME
 );
-var ZUDOKU_XDG_STATE_HOME = path29.join(
+var ZUDOKU_XDG_STATE_HOME = path30.join(
   XDG_STATE_HOME,
   CLI_XDG_FOLDER_NAME
 );
@@ -9262,7 +9316,7 @@ async function getVersionCheckInfo() {
   let versionCheckInfo;
   if (existsSync3(versionCheckPath)) {
     try {
-      versionCheckInfo = await readFile5(versionCheckPath, "utf-8").then(
+      versionCheckInfo = await readFile6(versionCheckPath, "utf-8").then(
         JSON.parse
       );
     } catch {