zudoku 0.92.0 → 0.93.1

package/dist/cli/cli.js

@@ -136,8 +136,8 @@ __export(llms_exports, {
   generateLlmsTxtFiles: () => generateLlmsTxtFiles
 });
 import { writeFile as writeFile5 } from "node:fs/promises";
-import path22 from "node:path";
-import colors6 from "picocolors";
+import path23 from "node:path";
+import colors7 from "picocolors";
 async function generateLlmsTxtFiles({
   markdownFileInfos,
   outputUrls,
@@ -180,11 +180,11 @@ async function generateLlmsTxtFiles({
       ...documentationLinks.length > 0 ? ["## Documentation", documentationLinks.join("\n")] : []
     ];
     await writeFile5(
-      path22.join(baseOutputDir, "llms.txt"),
+      path23.join(baseOutputDir, "llms.txt"),
       llmsTxtParts.join("\n\n"),
       "utf-8"
     );
-    console.log(colors6.blue("\u2713 generated llms.txt"));
+    console.log(colors7.blue("\u2713 generated llms.txt"));
   }
   if (llmsTxtFull) {
     const llmsFullParts = [];
@@ -211,11 +211,11 @@ ${info.content}
     }
     const llmsFull = llmsFullParts.join("\n");
     await writeFile5(
-      path22.join(baseOutputDir, "llms-full.txt"),
+      path23.join(baseOutputDir, "llms-full.txt"),
       llmsFull,
       "utf-8"
     );
-    console.log(colors6.blue("\u2713 generated llms-full.txt"));
+    console.log(colors7.blue("\u2713 generated llms-full.txt"));
   }
 }
 var DEFAULT_TITLE, DEFAULT_DESCRIPTION, toSingleLine, escapeMarkdownLinkLabel, formatInstructions;
@@ -238,70 +238,36 @@ import { hideBin } from "yargs/helpers";
 import yargs from "yargs/yargs";
 
 // src/cli/build/handler.ts
-import path27 from "node:path";
+import path28 from "node:path";
 
 // src/vite/build.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { mkdir as mkdir6, readFile as readFile5, rename as rename2, rm as rm4, writeFile as writeFile6 } from "node:fs/promises";
-import path25 from "node:path";
+import path26 from "node:path";
 import { build as esbuild } from "esbuild";
 import { createBuilder } from "vite";
 
-// src/app/env.ts
-import { z as z2 } from "zod/mini";
-
-// src/app/ZuploBuildConfig.ts
-import { z } from "zod/mini";
-var EntitlementsSchema = z.object({
-  devPortalZuploBranding: z.boolean(),
-  numberOfProjects: z.number(),
-  numberOfUsers: z.number(),
-  egressGbPerMonth: z.number(),
-  requestsPerMonth: z.number(),
-  numberOfApiKeys: z.number(),
-  customDomains: z.number(),
-  advancedAnalyticsEnabled: z.boolean(),
-  devPortalAnalyticsEnabled: z.boolean(),
-  premiumSupport: z.boolean(),
-  emergencyPhoneSupport: z.boolean(),
-  rbacEnabled: z.boolean(),
-  onPremEnabled: z.boolean(),
-  largeBuildRunners: z.boolean()
-});
-var BuildConfigSchema = z.object({
-  entitlements: EntitlementsSchema,
-  environmentType: z.optional(z.string()),
-  deploymentName: z.string(),
-  deploymentUrl: z.optional(z.string()),
-  projectId: z.optional(z.string()),
-  projectType: z.optional(z.string()),
-  sourceType: z.optional(z.string()),
-  accountName: z.optional(z.string()),
-  projectName: z.optional(z.string())
-});
-var parseBuildConfig = (value) => BuildConfigSchema.parse(value);
-
-// src/app/env.ts
-var formatError = (error) => {
-  if (error instanceof SyntaxError) {
-    return "ZUPLO_BUILD_CONFIG contains invalid JSON";
-  }
-  if (error instanceof z2.core.$ZodError) {
-    return `ZUPLO_BUILD_CONFIG is invalid:
-${z2.prettifyError(error)}`;
-  }
-  return `ZUPLO_BUILD_CONFIG is invalid: ${error}`;
-};
-var getZuploBuildConfig = () => {
-  if (!process.env.ZUPLO_BUILD_CONFIG) return void 0;
+// src/vite/zuplo.ts
+import bs58 from "bs58";
+var getZuploSystemConfigurations = (string) => {
+  if (!string) return void 0;
   try {
-    const parsed = JSON.parse(process.env.ZUPLO_BUILD_CONFIG);
-    return parseBuildConfig(parsed);
+    const zuploSystemConfigurations = JSON.parse(
+      Buffer.from(bs58.decode(string)).toString("utf8")
+    );
+    return zuploSystemConfigurations;
   } catch (error) {
-    console.error(formatError(error));
+    console.error(error);
     return void 0;
   }
 };
+
+// src/app/env.ts
+var parseBoolean = (value) => {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return void 0;
+};
 var ZuploEnv = {
   /**
    * Indicates that the build is running in Zuplo "mode"
@@ -312,7 +278,21 @@ var ZuploEnv = {
   get serverUrl() {
     return process.env.ZUPLO_SERVER_URL;
   },
-  buildConfig: getZuploBuildConfig()
+  /**
+   * The Zuplo deployment name, from `ZUPLO_DEPLOYMENT_NAME`, falling back to
+   * the deployment name in `ZUPLO_SYSTEM_CONFIGURATIONS`.
+   */
+  get deploymentName() {
+    return process.env.ZUPLO_DEPLOYMENT_NAME || getZuploSystemConfigurations(process.env.ZUPLO_SYSTEM_CONFIGURATIONS)?.__ZUPLO_DEPLOYMENT_NAME;
+  },
+  /**
+   * Whether Zuplo branding is shown in the dev portal, from
+   * `ZUPLO_DEV_PORTAL_ZUPLO_BRANDING` (`"true"` or `"false"`). Any other value
+   * means it isn't set.
+   */
+  get devPortalZuploBranding() {
+    return parseBoolean(process.env.ZUPLO_DEV_PORTAL_ZUPLO_BRANDING);
+  }
 };
 
 // src/cli/common/package-json.ts
@@ -420,7 +400,7 @@ var ZudokuError = class extends Error {
 
 // src/config/file-exists.ts
 import { stat } from "node:fs/promises";
-var fileExists = (path32) => stat(path32).then(() => true).catch(() => false);
+var fileExists = (path33) => stat(path33).then(() => true).catch(() => false);
 
 // src/config/plugin-versions.ts
 import { readFile } from "node:fs/promises";
@@ -465,7 +445,7 @@ var getPluginVersions = async (pluginDirs) => {
 // src/config/validators/ZudokuConfig.ts
 import colors from "picocolors";
 import { isValidElement as isValidElement2 } from "react";
-import { z as z7 } from "zod";
+import { z as z5 } from "zod";
 
 // src/vite/plugin-theme.ts
 import path4 from "node:path";
@@ -630,27 +610,27 @@ var createConfiguredShikiRehypePlugins = (highlighterInstance, themes = defaultH
 var objectEntries = (obj) => Object.entries(obj);
 
 // src/vite/shadcn-registry.ts
-import { z as z3 } from "zod";
-var registryItemCssSchema = z3.record(
-  z3.string(),
-  z3.lazy(
-    () => z3.union([
-      z3.string(),
-      z3.record(
-        z3.string(),
-        z3.union([z3.string(), z3.record(z3.string(), z3.string())])
+import { z } from "zod";
+var registryItemCssSchema = z.record(
+  z.string(),
+  z.lazy(
+    () => z.union([
+      z.string(),
+      z.record(
+        z.string(),
+        z.union([z.string(), z.record(z.string(), z.string())])
       )
     ])
   )
 );
-var registryItemSchema = z3.object({
-  $schema: z3.literal("https://ui.shadcn.com/schema/registry-item.json"),
-  name: z3.string(),
-  type: z3.enum(["registry:theme", "registry:style"]),
-  cssVars: z3.object({
-    theme: z3.record(z3.string(), z3.string()).optional(),
-    light: z3.record(z3.string(), z3.string()).optional(),
-    dark: z3.record(z3.string(), z3.string()).optional()
+var registryItemSchema = z.object({
+  $schema: z.literal("https://ui.shadcn.com/schema/registry-item.json"),
+  name: z.string(),
+  type: z.enum(["registry:theme", "registry:style"]),
+  cssVars: z.object({
+    theme: z.record(z.string(), z.string()).optional(),
+    light: z.record(z.string(), z.string()).optional(),
+    dark: z.record(z.string(), z.string()).optional()
   }).optional(),
   css: registryItemCssSchema.optional()
 });
@@ -1005,7 +985,7 @@ ${rootVars.join("\n")}
 };
 
 // src/config/validators/HeaderNavigationSchema.ts
-import { z as z4 } from "zod";
+import { z as z2 } from "zod";
 
 // src/config/validators/icon-types.ts
 var IconNames = [
@@ -3142,122 +3122,122 @@ var IconNames = [
 ];
 
 // src/config/validators/HeaderNavigationSchema.ts
-var IconSchema = z4.enum(IconNames);
-var HeaderNavLinkItemSchema = z4.object({
-  label: z4.string(),
+var IconSchema = z2.enum(IconNames);
+var HeaderNavLinkItemSchema = z2.object({
+  label: z2.string(),
   icon: IconSchema.optional(),
-  description: z4.string().optional(),
-  to: z4.string(),
-  target: z4.enum(["_self", "_blank"]).optional()
+  description: z2.string().optional(),
+  to: z2.string(),
+  target: z2.enum(["_self", "_blank"]).optional()
 });
-var HeaderNavGroupSchema = z4.object({
-  label: z4.string(),
-  items: z4.array(HeaderNavLinkItemSchema)
+var HeaderNavGroupSchema = z2.object({
+  label: z2.string(),
+  items: z2.array(HeaderNavLinkItemSchema)
 });
-var HeaderNavItemSchema = z4.union([
-  z4.object({
-    label: z4.string(),
+var HeaderNavItemSchema = z2.union([
+  z2.object({
+    label: z2.string(),
     icon: IconSchema.optional(),
-    to: z4.string(),
-    target: z4.enum(["_self", "_blank"]).optional()
+    to: z2.string(),
+    target: z2.enum(["_self", "_blank"]).optional()
   }),
-  z4.object({
-    label: z4.string(),
-    items: z4.array(z4.union([HeaderNavLinkItemSchema, HeaderNavGroupSchema]))
+  z2.object({
+    label: z2.string(),
+    items: z2.array(z2.union([HeaderNavLinkItemSchema, HeaderNavGroupSchema]))
   })
 ]);
-var HeaderNavigationSchema = z4.array(HeaderNavItemSchema);
+var HeaderNavigationSchema = z2.array(HeaderNavItemSchema);
 
 // src/config/validators/InputNavigationSchema.ts
-import { z as z5 } from "zod";
-var IconSchema2 = z5.custom((f) => typeof f === "string");
-var BadgeSchema = z5.object({
-  label: z5.string(),
+import { z as z3 } from "zod";
+var IconSchema2 = z3.custom((f) => typeof f === "string");
+var BadgeSchema = z3.object({
+  label: z3.string(),
   // prettier-ignore
-  color: z5.enum(["green", "blue", "yellow", "red", "purple", "indigo", "gray", "outline"]),
-  invert: z5.boolean().optional(),
-  className: z5.string().optional()
+  color: z3.enum(["green", "blue", "yellow", "red", "purple", "indigo", "gray", "outline"]),
+  invert: z3.boolean().optional(),
+  className: z3.string().optional()
 });
-var InputNavigationCategoryLinkDocSchema = z5.union([
-  z5.string(),
-  z5.object({
-    type: z5.literal("doc"),
-    file: z5.string(),
-    label: z5.string().optional(),
-    path: z5.string().optional()
+var InputNavigationCategoryLinkDocSchema = z3.union([
+  z3.string(),
+  z3.object({
+    type: z3.literal("doc"),
+    file: z3.string(),
+    label: z3.string().optional(),
+    path: z3.string().optional()
   }),
-  z5.object({
-    type: z5.literal("link"),
-    to: z5.string(),
-    label: z5.string().optional()
+  z3.object({
+    type: z3.literal("link"),
+    to: z3.string(),
+    label: z3.string().optional()
   })
 ]);
-var DisplaySchema = z5.union([
-  z5.enum(["auth", "anon", "always", "hide"]),
-  z5.custom((val) => typeof val === "function")
+var DisplaySchema = z3.union([
+  z3.enum(["auth", "anon", "always", "hide"]),
+  z3.custom((val) => typeof val === "function")
 ]).optional();
 var CommonItemFields = {
   icon: IconSchema2.optional(),
   badge: BadgeSchema.optional(),
   display: DisplaySchema
 };
-var InputNavigationDocObjectSchema = z5.object({
-  type: z5.literal("doc"),
-  file: z5.string(),
+var InputNavigationDocObjectSchema = z3.object({
+  type: z3.literal("doc"),
+  file: z3.string(),
   // Custom URL path for this document (overrides file-based path)
-  path: z5.string().optional(),
-  label: z5.string().optional(),
+  path: z3.string().optional(),
+  label: z3.string().optional(),
   ...CommonItemFields
 });
-var InputNavigationLinkSchema = z5.object({
-  type: z5.literal("link"),
-  to: z5.string(),
-  label: z5.string(),
-  target: z5.enum(["_self", "_blank"]).optional(),
-  stack: z5.boolean().optional(),
+var InputNavigationLinkSchema = z3.object({
+  type: z3.literal("link"),
+  to: z3.string(),
+  label: z3.string(),
+  target: z3.enum(["_self", "_blank"]).optional(),
+  stack: z3.boolean().optional(),
   ...CommonItemFields
 });
-var InputNavigationCustomPageSchema = z5.object({
-  type: z5.literal("custom-page"),
-  path: z5.string(),
-  label: z5.string().optional(),
-  element: z5.any(),
-  layout: z5.enum(["default", "none"]).optional(),
+var InputNavigationCustomPageSchema = z3.object({
+  type: z3.literal("custom-page"),
+  path: z3.string(),
+  label: z3.string().optional(),
+  element: z3.any(),
+  layout: z3.enum(["default", "none"]).optional(),
   ...CommonItemFields
 });
-var InputNavigationSeparatorSchema = z5.object({
-  type: z5.literal("separator"),
+var InputNavigationSeparatorSchema = z3.object({
+  type: z3.literal("separator"),
   display: DisplaySchema
 });
-var InputNavigationSectionSchema = z5.object({
-  type: z5.literal("section"),
-  label: z5.string(),
+var InputNavigationSectionSchema = z3.object({
+  type: z3.literal("section"),
+  label: z3.string(),
   display: DisplaySchema
 });
-var InputNavigationFilterSchema = z5.object({
-  type: z5.literal("filter"),
-  placeholder: z5.string().optional(),
+var InputNavigationFilterSchema = z3.object({
+  type: z3.literal("filter"),
+  placeholder: z3.string().optional(),
   display: DisplaySchema
 });
-var BaseInputNavigationCategorySchema = z5.object({
-  type: z5.literal("category"),
+var BaseInputNavigationCategorySchema = z3.object({
+  type: z3.literal("category"),
   icon: IconSchema2.optional(),
-  label: z5.string(),
-  collapsible: z5.boolean().optional(),
-  collapsed: z5.boolean().optional(),
+  label: z3.string(),
+  collapsible: z3.boolean().optional(),
+  collapsed: z3.boolean().optional(),
   link: InputNavigationCategoryLinkDocSchema.optional(),
   display: DisplaySchema,
-  stack: z5.boolean().optional()
+  stack: z3.boolean().optional()
 });
-var InputNavigationCategorySchema = z5.object({
+var InputNavigationCategorySchema = z3.object({
   ...BaseInputNavigationCategorySchema.shape,
   get items() {
     return InputNavigationItemSchema.array();
   }
 });
-var InputNavigationItemSchema = z5.union([
-  z5.string(),
-  z5.discriminatedUnion("type", [
+var InputNavigationItemSchema = z3.union([
+  z3.string(),
+  z3.discriminatedUnion("type", [
     InputNavigationDocObjectSchema,
     InputNavigationLinkSchema,
     InputNavigationCustomPageSchema,
@@ -3268,43 +3248,43 @@ var InputNavigationItemSchema = z5.union([
   ])
 ]);
 var InputNavigationSchema = InputNavigationItemSchema.array();
-var NavigationModifyRuleSchema = z5.object({
-  type: z5.literal("modify"),
-  match: z5.string(),
-  set: z5.object({
-    label: z5.string().optional(),
+var NavigationModifyRuleSchema = z3.object({
+  type: z3.literal("modify"),
+  match: z3.string(),
+  set: z3.object({
+    label: z3.string().optional(),
     icon: IconSchema2.optional(),
     badge: BadgeSchema.optional(),
-    collapsed: z5.boolean().optional(),
-    collapsible: z5.boolean().optional(),
+    collapsed: z3.boolean().optional(),
+    collapsible: z3.boolean().optional(),
     display: DisplaySchema,
     // Turn a (plugin-generated) category into a stacked sub-nav
     // E.g. make each OpenAPI tag drill into its own panel. See `stack` above.
-    stack: z5.boolean().optional()
+    stack: z3.boolean().optional()
   })
 });
-var NavigationInsertRuleSchema = z5.object({
-  type: z5.literal("insert"),
-  match: z5.string(),
-  position: z5.enum(["before", "after"]),
+var NavigationInsertRuleSchema = z3.object({
+  type: z3.literal("insert"),
+  match: z3.string(),
+  position: z3.enum(["before", "after"]),
   items: InputNavigationItemSchema.array()
 });
-var NavigationRemoveRuleSchema = z5.object({
-  type: z5.literal("remove"),
-  match: z5.string()
+var NavigationRemoveRuleSchema = z3.object({
+  type: z3.literal("remove"),
+  match: z3.string()
 });
-var NavigationSortRuleSchema = z5.object({
-  type: z5.literal("sort"),
-  match: z5.string(),
-  by: z5.custom((val) => typeof val === "function")
+var NavigationSortRuleSchema = z3.object({
+  type: z3.literal("sort"),
+  match: z3.string(),
+  by: z3.custom((val) => typeof val === "function")
 });
-var NavigationMoveRuleSchema = z5.object({
-  type: z5.literal("move"),
-  match: z5.string(),
-  to: z5.string(),
-  position: z5.enum(["before", "after"])
+var NavigationMoveRuleSchema = z3.object({
+  type: z3.literal("move"),
+  match: z3.string(),
+  to: z3.string(),
+  position: z3.enum(["before", "after"])
 });
-var NavigationRuleSchema = z5.discriminatedUnion("type", [
+var NavigationRuleSchema = z3.discriminatedUnion("type", [
   NavigationModifyRuleSchema,
   NavigationInsertRuleSchema,
   NavigationRemoveRuleSchema,
@@ -3314,15 +3294,15 @@ var NavigationRuleSchema = z5.discriminatedUnion("type", [
 var NavigationRulesSchema = NavigationRuleSchema.array();
 
 // src/config/validators/ProtectedRoutesSchema.ts
-import { z as z6 } from "zod/mini";
+import { z as z4 } from "zod/mini";
 
 // src/lib/core/ZudokuContext.ts
 import { createNanoEvents } from "nanoevents";
 
 // src/lib/util/url.ts
 import { matchPath } from "react-router";
-var matchesProtectedPattern = (pattern, path32) => matchPath({ path: pattern, end: true }, path32) != null;
-var matchesAnyProtectedPattern = (patterns, path32) => patterns.some((p) => matchesProtectedPattern(p, path32));
+var matchesProtectedPattern = (pattern, path33) => matchPath({ path: pattern, end: true }, path33) != null;
+var matchesAnyProtectedPattern = (patterns, path33) => patterns.some((p) => matchesProtectedPattern(p, path33));
 
 // src/lib/core/ZudokuContext.ts
 var normalizeProtectedRoutes = (val) => {
@@ -3339,147 +3319,147 @@ var normalizeProtectedRoutes = (val) => {
 };
 
 // src/config/validators/ProtectedRoutesSchema.ts
-var ProtectedRoutesInputSchema = z6.optional(
-  z6.union([
-    z6.array(z6.string()),
-    z6.record(
-      z6.string(),
-      z6.custom((val) => typeof val === "function")
+var ProtectedRoutesInputSchema = z4.optional(
+  z4.union([
+    z4.array(z4.string()),
+    z4.record(
+      z4.string(),
+      z4.custom((val) => typeof val === "function")
     )
   ])
 );
-var ProtectedRoutesSchema = z6.pipe(
+var ProtectedRoutesSchema = z4.pipe(
   ProtectedRoutesInputSchema,
-  z6.transform(normalizeProtectedRoutes)
+  z4.transform(normalizeProtectedRoutes)
 );
 
 // src/config/validators/ZudokuConfig.ts
-var ThemeSchema = z7.object({
-  background: z7.string(),
-  foreground: z7.string(),
-  card: z7.string(),
-  cardForeground: z7.string(),
-  popover: z7.string(),
-  popoverForeground: z7.string(),
-  primary: z7.string(),
-  primaryForeground: z7.string(),
-  secondary: z7.string(),
-  secondaryForeground: z7.string(),
-  muted: z7.string(),
-  mutedForeground: z7.string(),
-  accent: z7.string(),
-  accentForeground: z7.string(),
-  destructive: z7.string(),
-  destructiveForeground: z7.string(),
-  border: z7.string(),
-  input: z7.string(),
-  ring: z7.string(),
-  radius: z7.string()
+var ThemeSchema = z5.object({
+  background: z5.string(),
+  foreground: z5.string(),
+  card: z5.string(),
+  cardForeground: z5.string(),
+  popover: z5.string(),
+  popoverForeground: z5.string(),
+  primary: z5.string(),
+  primaryForeground: z5.string(),
+  secondary: z5.string(),
+  secondaryForeground: z5.string(),
+  muted: z5.string(),
+  mutedForeground: z5.string(),
+  accent: z5.string(),
+  accentForeground: z5.string(),
+  destructive: z5.string(),
+  destructiveForeground: z5.string(),
+  border: z5.string(),
+  input: z5.string(),
+  ring: z5.string(),
+  radius: z5.string()
 }).partial();
-var ApiCatalogCategorySchema = z7.object({
-  label: z7.string(),
-  tags: z7.array(z7.string())
+var ApiCatalogCategorySchema = z5.object({
+  label: z5.string(),
+  tags: z5.array(z5.string())
 });
-var LanguageOption = z7.object({
-  value: z7.string().min(1),
-  label: z7.string().min(1)
+var LanguageOption = z5.object({
+  value: z5.string().min(1),
+  label: z5.string().min(1)
 });
-var AiAssistantCustomSchema = z7.object({
-  label: z7.string(),
-  icon: z7.custom().optional(),
-  url: z7.union([
-    z7.string(),
-    z7.custom((val) => typeof val === "function")
+var AiAssistantCustomSchema = z5.object({
+  label: z5.string(),
+  icon: z5.custom().optional(),
+  url: z5.union([
+    z5.string(),
+    z5.custom((val) => typeof val === "function")
   ])
 });
 var AiAssistantPresets = ["claude", "chatgpt"];
-var AiAssistantsSchema = z7.union([
-  z7.literal(false),
-  z7.array(z7.union([z7.enum(AiAssistantPresets), AiAssistantCustomSchema]))
+var AiAssistantsSchema = z5.union([
+  z5.literal(false),
+  z5.array(z5.union([z5.enum(AiAssistantPresets), AiAssistantCustomSchema]))
 ]).optional();
-var ApiOptionsSchema = z7.object({
-  examplesLanguage: z7.string(),
-  supportedLanguages: z7.array(LanguageOption),
-  disablePlayground: z7.boolean(),
-  disableSidecar: z7.boolean(),
-  disableRequestBox: z7.boolean(),
-  showVersionSelect: z7.enum(["always", "if-available", "hide"]),
-  expandAllTags: z7.boolean(),
-  showInfoPage: z7.boolean(),
-  disableSecurity: z7.boolean(),
-  disableMcpAuthInstructions: z7.boolean(),
-  schemaDownload: z7.object({
-    enabled: z7.boolean(),
-    fileName: z7.string().regex(/^[A-Za-z0-9_-]+$/).optional()
+var ApiOptionsSchema = z5.object({
+  examplesLanguage: z5.string(),
+  supportedLanguages: z5.array(LanguageOption),
+  disablePlayground: z5.boolean(),
+  disableSidecar: z5.boolean(),
+  disableRequestBox: z5.boolean(),
+  showVersionSelect: z5.enum(["always", "if-available", "hide"]),
+  expandAllTags: z5.boolean(),
+  showInfoPage: z5.boolean(),
+  disableSecurity: z5.boolean(),
+  disableMcpAuthInstructions: z5.boolean(),
+  schemaDownload: z5.object({
+    enabled: z5.boolean(),
+    fileName: z5.string().regex(/^[A-Za-z0-9_-]+$/).optional()
   }).partial(),
-  transformExamples: z7.custom(
+  transformExamples: z5.custom(
     (val) => typeof val === "function"
   ),
-  generateCodeSnippet: z7.custom(
+  generateCodeSnippet: z5.custom(
     (val) => typeof val === "function"
   )
 }).partial();
-var ApiConfigSchema = z7.object({
-  server: z7.string(),
-  path: z7.string(),
-  categories: z7.array(ApiCatalogCategorySchema),
+var ApiConfigSchema = z5.object({
+  server: z5.string(),
+  path: z5.string(),
+  categories: z5.array(ApiCatalogCategorySchema),
   options: ApiOptionsSchema
 }).partial();
-var OpenApiPublicationSchema = z7.object({
-  path: z7.string().regex(
+var OpenApiPublicationSchema = z5.object({
+  path: z5.string().regex(
     /^\/(?!\/)(?:[A-Za-z0-9._~-]+\/)*[A-Za-z0-9._~-]+\.(?:json|ya?ml)$/i,
     "OpenAPI publication path must be a root-relative .json, .yaml, or .yml path without traversal, query, or fragment components"
   ).refine(
     (value) => value.split("/").every((segment) => segment !== "." && segment !== ".."),
     "OpenAPI publication path must not contain traversal segments"
   ),
-  agentQuality: z7.boolean().optional()
+  agentQuality: z5.boolean().optional()
 });
-var VersionConfigSchema = z7.object({
-  path: z7.string(),
-  input: z7.string(),
-  label: z7.string().optional()
+var VersionConfigSchema = z5.object({
+  path: z5.string(),
+  input: z5.string(),
+  label: z5.string().optional()
 });
-var ApiSchema = z7.discriminatedUnion("type", [
-  z7.object({
-    type: z7.literal("url"),
-    input: z7.union([z7.string(), z7.array(VersionConfigSchema)]),
+var ApiSchema = z5.discriminatedUnion("type", [
+  z5.object({
+    type: z5.literal("url"),
+    input: z5.union([z5.string(), z5.array(VersionConfigSchema)]),
     ...ApiConfigSchema.shape
   }),
-  z7.object({
-    type: z7.literal("file"),
-    input: z7.union([
-      z7.string(),
-      z7.array(z7.union([z7.string(), VersionConfigSchema]))
+  z5.object({
+    type: z5.literal("file"),
+    input: z5.union([
+      z5.string(),
+      z5.array(z5.union([z5.string(), VersionConfigSchema]))
     ]),
     publish: OpenApiPublicationSchema.optional(),
     ...ApiConfigSchema.shape
   }),
-  z7.object({
-    type: z7.literal("raw"),
-    input: z7.string(),
+  z5.object({
+    type: z5.literal("raw"),
+    input: z5.string(),
     ...ApiConfigSchema.shape
   })
 ]);
-var ApiKeysSchema = z7.object({
-  enabled: z7.boolean(),
-  getConsumers: z7.custom(
+var ApiKeysSchema = z5.object({
+  enabled: z5.boolean(),
+  getConsumers: z5.custom(
     (val) => typeof val === "function"
   ).optional(),
-  rollKey: z7.custom(
+  rollKey: z5.custom(
     (val) => typeof val === "function"
   ).optional(),
-  deleteKey: z7.custom((val) => typeof val === "function").optional(),
-  updateKeyDescription: z7.custom((val) => typeof val === "function").optional(),
-  createKey: z7.custom((val) => typeof val === "function").optional()
+  deleteKey: z5.custom((val) => typeof val === "function").optional(),
+  updateKeyDescription: z5.custom((val) => typeof val === "function").optional(),
+  createKey: z5.custom((val) => typeof val === "function").optional()
 });
-var LogoSchema = z7.object({
-  src: z7.object({ light: z7.string(), dark: z7.string() }),
-  alt: z7.string().optional(),
-  width: z7.string().or(z7.number()).optional(),
-  height: z7.string().or(z7.number()).optional(),
-  href: z7.string().optional(),
-  reloadDocument: z7.boolean().optional()
+var LogoSchema = z5.object({
+  src: z5.object({ light: z5.string(), dark: z5.string() }),
+  alt: z5.string().optional(),
+  width: z5.string().or(z5.number()).optional(),
+  height: z5.string().or(z5.number()).optional(),
+  href: z5.string().optional(),
+  reloadDocument: z5.boolean().optional()
 });
 var FooterSocialIcons = [
   "reddit",
@@ -3497,38 +3477,38 @@ var FooterSocialIcons = [
   "whatsapp",
   "telegram"
 ];
-var FooterSocialSchema = z7.object({
-  label: z7.string().optional(),
-  href: z7.string(),
-  icon: z7.union([
-    z7.enum(FooterSocialIcons),
-    z7.custom((val) => isValidElement2(val))
+var FooterSocialSchema = z5.object({
+  label: z5.string().optional(),
+  href: z5.string(),
+  icon: z5.union([
+    z5.enum(FooterSocialIcons),
+    z5.custom((val) => isValidElement2(val))
   ]).optional()
 });
-var FooterSchema = z7.object({
-  columns: z7.array(
-    z7.object({
-      position: z7.enum(["start", "center", "end"]).optional(),
-      title: z7.string(),
-      links: z7.array(z7.object({ label: z7.string(), href: z7.string() }))
+var FooterSchema = z5.object({
+  columns: z5.array(
+    z5.object({
+      position: z5.enum(["start", "center", "end"]).optional(),
+      title: z5.string(),
+      links: z5.array(z5.object({ label: z5.string(), href: z5.string() }))
     })
   ).optional(),
-  social: z7.array(FooterSocialSchema).optional(),
-  copyright: z7.string().optional(),
+  social: z5.array(FooterSocialSchema).optional(),
+  copyright: z5.string().optional(),
   logo: LogoSchema.optional(),
-  position: z7.enum(["start", "center", "end"]).optional()
+  position: z5.enum(["start", "center", "end"]).optional()
 }).optional();
-var SiteMapSchema = z7.object({
+var SiteMapSchema = z5.object({
   /**
    * Base url of your website
    */
-  siteUrl: z7.string(),
+  siteUrl: z5.string(),
   /**
    * Change frequency.
    * @default 'daily'
    */
-  changefreq: z7.optional(
-    z7.enum([
+  changefreq: z5.optional(
+    z5.enum([
       "always",
       "hourly",
       "daily",
@@ -3542,59 +3522,59 @@ var SiteMapSchema = z7.object({
    * Priority
    * @default 0.7
    */
-  priority: z7.optional(z7.number()),
-  outDir: z7.string().optional(),
+  priority: z5.optional(z5.number()),
+  outDir: z5.string().optional(),
   /**
    * Add <lastmod/> property.
    * @default true
    */
-  autoLastmod: z7.boolean().optional(),
+  autoLastmod: z5.boolean().optional(),
   /**
    * Array of relative paths to exclude from listing on sitemap.xml or sitemap-*.xml.
    * @example ['/page-0', '/page/example']
    */
-  exclude: z7.union([
-    z7.custom((val) => typeof val === "function"),
-    z7.array(z7.string())
+  exclude: z5.union([
+    z5.custom((val) => typeof val === "function"),
+    z5.array(z5.string())
   ]).optional()
 }).optional();
 var DEFAULT_DOCS_FILES = "/pages/**/*.{md,mdx}";
-var LlmsConfigSchema = z7.object({
-  llmsTxt: z7.boolean().default(false).describe(
+var LlmsConfigSchema = z5.object({
+  llmsTxt: z5.boolean().default(false).describe(
     "When enabled, generates an llms.txt file following the spec at https://llmstxt.org/. This file provides a summary with links to all documentation."
   ),
-  llmsTxtFull: z7.boolean().default(false).describe(
+  llmsTxtFull: z5.boolean().default(false).describe(
     "When enabled, generates an llms-full.txt file with the complete content of all markdown documents for LLM consumption."
   ),
-  includeProtected: z7.boolean().default(false).describe(
+  includeProtected: z5.boolean().default(false).describe(
     "When enabled, includes content from protected routes in the generated .md files and llms.txt files. By default, protected routes are excluded."
   ),
-  title: z7.string().trim().min(1).optional().describe(
+  title: z5.string().trim().min(1).optional().describe(
     "The project or site name rendered as the llms.txt H1. Defaults to the configured site title."
   ),
-  description: z7.string().trim().min(1).optional().describe("A short project summary rendered as the llms.txt blockquote."),
-  instructions: z7.string().trim().min(1).optional().describe(
+  description: z5.string().trim().min(1).optional().describe("A short project summary rendered as the llms.txt blockquote."),
+  instructions: z5.string().trim().min(1).optional().describe(
     "Guidance for agents, such as when to use the documentation and how to interpret it. Rendered as introductory prose before the link sections."
   )
 }).partial().prefault({});
-var DocsConfigSchema = z7.object({
-  files: z7.union([z7.string(), z7.array(z7.string())]).transform((val) => typeof val === "string" ? [val] : val).default([DEFAULT_DOCS_FILES]),
-  publishMarkdown: z7.boolean().default(true).describe(
+var DocsConfigSchema = z5.object({
+  files: z5.union([z5.string(), z5.array(z5.string())]).transform((val) => typeof val === "string" ? [val] : val).default([DEFAULT_DOCS_FILES]),
+  publishMarkdown: z5.boolean().default(true).describe(
     "When enabled, generates .md files for each document during build. Access documents at their URL path with .md extension (e.g., /foo/hello.md). Markdown files are generated without frontmatter."
   ),
-  contentNegotiation: z7.boolean().optional().describe(
+  contentNegotiation: z5.boolean().optional().describe(
     "When enabled, serves generated Markdown at canonical document URLs when Accept prefers text/markdown and adds Vary: Accept. Defaults to the value of publishMarkdown."
   ),
-  defaultOptions: z7.object({
-    toc: z7.boolean(),
-    copyPage: z7.boolean().optional(),
-    disablePager: z7.boolean(),
-    showLastModified: z7.boolean(),
-    fullWidth: z7.boolean().optional(),
-    centered: z7.boolean().optional(),
-    suggestEdit: z7.object({
-      url: z7.string(),
-      text: z7.string().optional()
+  defaultOptions: z5.object({
+    toc: z5.boolean(),
+    copyPage: z5.boolean().optional(),
+    disablePager: z5.boolean(),
+    showLastModified: z5.boolean(),
+    fullWidth: z5.boolean().optional(),
+    centered: z5.boolean().optional(),
+    suggestEdit: z5.object({
+      url: z5.string(),
+      text: z5.string().optional()
     }).optional()
   }).partial().optional(),
   llms: LlmsConfigSchema
@@ -3602,73 +3582,73 @@ var DocsConfigSchema = z7.object({
   ...docs,
   contentNegotiation: docs.publishMarkdown && (docs.contentNegotiation ?? true)
 })).prefault({});
-var Redirect = z7.object({
-  from: z7.string(),
-  to: z7.string()
+var Redirect = z5.object({
+  from: z5.string(),
+  to: z5.string()
 });
-var SearchSchema = z7.discriminatedUnion("type", [
+var SearchSchema = z5.discriminatedUnion("type", [
   // looseObject to allow additional properties so the
   // user can set other inkeep settings
-  z7.looseObject({
-    type: z7.literal("inkeep"),
-    apiKey: z7.string(),
-    integrationId: z7.string(),
-    organizationId: z7.string(),
-    primaryBrandColor: z7.string(),
-    organizationDisplayName: z7.string(),
-    searchSettings: z7.custom().optional(),
-    aiChatSettings: z7.custom().optional(),
-    modalSettings: z7.custom().optional()
+  z5.looseObject({
+    type: z5.literal("inkeep"),
+    apiKey: z5.string(),
+    integrationId: z5.string(),
+    organizationId: z5.string(),
+    primaryBrandColor: z5.string(),
+    organizationDisplayName: z5.string(),
+    searchSettings: z5.custom().optional(),
+    aiChatSettings: z5.custom().optional(),
+    modalSettings: z5.custom().optional()
   }),
-  z7.object({
-    type: z7.literal("pagefind"),
-    ranking: z7.object({
-      termFrequency: z7.number(),
-      pageLength: z7.number(),
-      termSimilarity: z7.number(),
-      termSaturation: z7.number()
+  z5.object({
+    type: z5.literal("pagefind"),
+    ranking: z5.object({
+      termFrequency: z5.number(),
+      pageLength: z5.number(),
+      termSimilarity: z5.number(),
+      termSaturation: z5.number()
     }).optional(),
-    maxResults: z7.number().optional(),
-    maxSubResults: z7.number().optional(),
-    transformResults: z7.custom((val) => typeof val === "function").optional()
+    maxResults: z5.number().optional(),
+    maxSubResults: z5.number().optional(),
+    transformResults: z5.custom((val) => typeof val === "function").optional()
   })
 ]).optional();
-var SignUpUrlValueSchema = z7.string().min(1).refine((v) => v.startsWith("/") || URL.canParse(v), {
+var SignUpUrlValueSchema = z5.string().min(1).refine((v) => v.startsWith("/") || URL.canParse(v), {
   message: "signUp.url must be an absolute URL or a path starting with '/'"
 });
-var SignUpUrlSchema = z7.object({ url: SignUpUrlValueSchema }).strict();
-var SignUpOpenIdSchema = z7.union([
+var SignUpUrlSchema = z5.object({ url: SignUpUrlValueSchema }).strict();
+var SignUpOpenIdSchema = z5.union([
   SignUpUrlSchema,
-  z7.object({
-    authorizationParams: z7.record(z7.string(), z7.string())
+  z5.object({
+    authorizationParams: z5.record(z5.string(), z5.string())
   }).strict()
 ]);
-var AuthenticationSchema = z7.discriminatedUnion("type", [
-  z7.object({
-    type: z7.literal("clerk"),
-    clerkPubKey: z7.custom().refine((val) => /^pk_(test|live)_\w+$/.test(val), {
+var AuthenticationSchema = z5.discriminatedUnion("type", [
+  z5.object({
+    type: z5.literal("clerk"),
+    clerkPubKey: z5.custom().refine((val) => /^pk_(test|live)_\w+$/.test(val), {
       message: "Clerk public key invalid, must start with pk_test or pk_live"
     }),
     // No default: an absent template must stay absent so Clerk issues its
     // standard session token instead of requesting a non-existent template.
-    jwtTemplateName: z7.string().optional(),
-    redirectToAfterSignUp: z7.string().optional(),
-    redirectToAfterSignIn: z7.string().optional(),
-    redirectToAfterSignOut: z7.string().optional(),
+    jwtTemplateName: z5.string().optional(),
+    redirectToAfterSignUp: z5.string().optional(),
+    redirectToAfterSignIn: z5.string().optional(),
+    redirectToAfterSignOut: z5.string().optional(),
     signUp: SignUpUrlSchema.optional(),
-    disableSignUp: z7.boolean().optional()
+    disableSignUp: z5.boolean().optional()
   }),
-  z7.object({
-    type: z7.literal("firebase"),
-    apiKey: z7.string(),
-    authDomain: z7.string(),
-    projectId: z7.string(),
-    storageBucket: z7.string().optional(),
-    messagingSenderId: z7.string().optional(),
-    appId: z7.string(),
-    measurementId: z7.string().optional(),
-    providers: z7.array(
-      z7.enum([
+  z5.object({
+    type: z5.literal("firebase"),
+    apiKey: z5.string(),
+    authDomain: z5.string(),
+    projectId: z5.string(),
+    storageBucket: z5.string().optional(),
+    messagingSenderId: z5.string().optional(),
+    appId: z5.string(),
+    measurementId: z5.string().optional(),
+    providers: z5.array(
+      z5.enum([
         "google",
         "facebook",
         "twitter",
@@ -3680,65 +3660,65 @@ var AuthenticationSchema = z7.discriminatedUnion("type", [
         "emailLink"
       ])
     ).optional(),
-    disableSignUp: z7.boolean().optional(),
-    redirectToAfterSignUp: z7.string().optional(),
-    redirectToAfterSignIn: z7.string().optional(),
-    redirectToAfterSignOut: z7.string().optional(),
+    disableSignUp: z5.boolean().optional(),
+    redirectToAfterSignUp: z5.string().optional(),
+    redirectToAfterSignIn: z5.string().optional(),
+    redirectToAfterSignOut: z5.string().optional(),
     signUp: SignUpUrlSchema.optional()
   }),
-  z7.object({
-    type: z7.literal("openid"),
-    basePath: z7.string().optional(),
-    clientId: z7.string(),
-    issuer: z7.string(),
-    audience: z7.string().optional(),
-    scopes: z7.array(z7.string()).optional(),
-    allowInsecureRequests: z7.boolean().optional(),
-    redirectToAfterSignUp: z7.string().optional(),
-    redirectToAfterSignIn: z7.string().optional(),
-    redirectToAfterSignOut: z7.string().optional(),
+  z5.object({
+    type: z5.literal("openid"),
+    basePath: z5.string().optional(),
+    clientId: z5.string(),
+    issuer: z5.string(),
+    audience: z5.string().optional(),
+    scopes: z5.array(z5.string()).optional(),
+    allowInsecureRequests: z5.boolean().optional(),
+    redirectToAfterSignUp: z5.string().optional(),
+    redirectToAfterSignIn: z5.string().optional(),
+    redirectToAfterSignOut: z5.string().optional(),
     signUp: SignUpOpenIdSchema.optional(),
-    disableSignUp: z7.boolean().optional(),
-    authorizationParams: z7.record(z7.string(), z7.string()).optional(),
-    forwardAuthorizationParams: z7.array(z7.string()).optional()
+    disableSignUp: z5.boolean().optional(),
+    authorizationParams: z5.record(z5.string(), z5.string()).optional(),
+    forwardAuthorizationParams: z5.array(z5.string()).optional()
   }),
-  z7.object({
-    type: z7.literal("entra"),
-    basePath: z7.string().optional(),
-    clientId: z7.string(),
+  z5.object({
+    type: z5.literal("entra"),
+    basePath: z5.string().optional(),
+    clientId: z5.string(),
     // Tenant id or one of Entra's multi-tenant authorities
     // (common/organizations/consumers). Defaults to "common".
-    tenantId: z7.string().optional(),
+    tenantId: z5.string().optional(),
     // Full issuer override, e.g. for CIAM tenants on *.ciamlogin.com.
-    issuer: z7.string().optional(),
-    audience: z7.string().optional(),
-    scopes: z7.array(z7.string()).optional(),
-    redirectToAfterSignUp: z7.string().optional(),
-    redirectToAfterSignIn: z7.string().optional(),
-    redirectToAfterSignOut: z7.string().optional(),
+    issuer: z5.string().optional(),
+    audience: z5.string().optional(),
+    scopes: z5.array(z5.string()).optional(),
+    redirectToAfterSignUp: z5.string().optional(),
+    redirectToAfterSignIn: z5.string().optional(),
+    redirectToAfterSignOut: z5.string().optional(),
     signUp: SignUpOpenIdSchema.optional(),
-    disableSignUp: z7.boolean().optional(),
-    authorizationParams: z7.record(z7.string(), z7.string()).optional(),
-    forwardAuthorizationParams: z7.array(z7.string()).optional()
+    disableSignUp: z5.boolean().optional(),
+    authorizationParams: z5.record(z5.string(), z5.string()).optional(),
+    forwardAuthorizationParams: z5.array(z5.string()).optional()
   }),
-  z7.object({
-    type: z7.literal("azureb2c"),
-    basePath: z7.string().optional(),
-    clientId: z7.string(),
-    tenantName: z7.string(),
-    policyName: z7.string(),
-    scopes: z7.array(z7.string()).optional(),
-    issuer: z7.string(),
-    redirectToAfterSignUp: z7.string().optional(),
-    redirectToAfterSignIn: z7.string().optional(),
-    redirectToAfterSignOut: z7.string().optional(),
+  z5.object({
+    type: z5.literal("azureb2c"),
+    basePath: z5.string().optional(),
+    clientId: z5.string(),
+    tenantName: z5.string(),
+    policyName: z5.string(),
+    scopes: z5.array(z5.string()).optional(),
+    issuer: z5.string(),
+    redirectToAfterSignUp: z5.string().optional(),
+    redirectToAfterSignIn: z5.string().optional(),
+    redirectToAfterSignOut: z5.string().optional(),
     signUp: SignUpUrlSchema.optional(),
-    disableSignUp: z7.boolean().optional()
+    disableSignUp: z5.boolean().optional()
   }),
-  z7.object({
-    type: z7.literal("auth0"),
-    clientId: z7.string(),
-    domain: z7.string().refine(
+  z5.object({
+    type: z5.literal("auth0"),
+    clientId: z5.string(),
+    domain: z5.string().refine(
       (val) => {
         if (val.startsWith("http://") || val.startsWith("https://")) {
           return false;
@@ -3752,133 +3732,133 @@ var AuthenticationSchema = z7.discriminatedUnion("type", [
         message: "Domain must be a host only (e.g., 'example.com') without protocol or slashes"
       }
     ),
-    audience: z7.string().optional(),
-    scopes: z7.array(z7.string()).optional(),
-    redirectToAfterSignUp: z7.string().optional(),
-    redirectToAfterSignIn: z7.string().optional(),
-    redirectToAfterSignOut: z7.string().optional(),
-    authorizationParams: z7.record(z7.string(), z7.string()).optional(),
-    forwardAuthorizationParams: z7.array(z7.string()).optional(),
-    options: z7.object({
-      alwaysPromptLogin: z7.boolean().optional(),
-      prompt: z7.string().optional()
+    audience: z5.string().optional(),
+    scopes: z5.array(z5.string()).optional(),
+    redirectToAfterSignUp: z5.string().optional(),
+    redirectToAfterSignIn: z5.string().optional(),
+    redirectToAfterSignOut: z5.string().optional(),
+    authorizationParams: z5.record(z5.string(), z5.string()).optional(),
+    forwardAuthorizationParams: z5.array(z5.string()).optional(),
+    options: z5.object({
+      alwaysPromptLogin: z5.boolean().optional(),
+      prompt: z5.string().optional()
     }).optional(),
     signUp: SignUpOpenIdSchema.optional(),
-    disableSignUp: z7.boolean().optional()
+    disableSignUp: z5.boolean().optional()
   }),
-  z7.object({
-    type: z7.literal("supabase"),
-    basePath: z7.string().optional(),
-    supabaseUrl: z7.string(),
-    supabaseKey: z7.string(),
-    provider: z7.string().optional(),
-    providers: z7.array(z7.string()).optional(),
-    onlyThirdPartyProviders: z7.boolean().optional(),
-    disableSignUp: z7.boolean().optional(),
-    redirectToAfterSignUp: z7.string().optional(),
-    redirectToAfterSignIn: z7.string().optional(),
-    redirectToAfterSignOut: z7.string().optional(),
+  z5.object({
+    type: z5.literal("supabase"),
+    basePath: z5.string().optional(),
+    supabaseUrl: z5.string(),
+    supabaseKey: z5.string(),
+    provider: z5.string().optional(),
+    providers: z5.array(z5.string()).optional(),
+    onlyThirdPartyProviders: z5.boolean().optional(),
+    disableSignUp: z5.boolean().optional(),
+    redirectToAfterSignUp: z5.string().optional(),
+    redirectToAfterSignIn: z5.string().optional(),
+    redirectToAfterSignOut: z5.string().optional(),
     signUp: SignUpUrlSchema.optional()
   })
 ]);
-var MetadataSchema = z7.object({
-  title: z7.string(),
-  defaultTitle: z7.string().optional(),
-  description: z7.string(),
-  logo: z7.string(),
-  favicon: z7.string(),
-  generator: z7.string(),
-  applicationName: z7.string(),
-  referrer: z7.string(),
-  keywords: z7.array(z7.string()),
-  authors: z7.array(z7.string()),
-  creator: z7.string(),
-  publisher: z7.string(),
-  robots: z7.string().describe(
+var MetadataSchema = z5.object({
+  title: z5.string(),
+  defaultTitle: z5.string().optional(),
+  description: z5.string(),
+  logo: z5.string(),
+  favicon: z5.string(),
+  generator: z5.string(),
+  applicationName: z5.string(),
+  referrer: z5.string(),
+  keywords: z5.array(z5.string()),
+  authors: z5.array(z5.string()),
+  creator: z5.string(),
+  publisher: z5.string(),
+  robots: z5.string().describe(
     'Sets the contents of the `meta[name="robots"]` tag. For example: `noindex, nofollow`.'
   )
 }).partial();
-var FontConfigSchema = z7.union([
-  z7.enum(GOOGLE_FONTS),
-  z7.object({
-    url: z7.string(),
-    fontFamily: z7.string().optional()
+var FontConfigSchema = z5.union([
+  z5.enum(GOOGLE_FONTS),
+  z5.object({
+    url: z5.string(),
+    fontFamily: z5.string().optional()
   })
 ]);
-var FontsConfigSchema = z7.object({
+var FontsConfigSchema = z5.object({
   sans: FontConfigSchema.optional(),
   serif: FontConfigSchema.optional(),
   mono: FontConfigSchema.optional()
 });
-var CssObject = z7.record(
-  z7.string(),
-  z7.lazy(
-    () => z7.union([
-      z7.string(),
-      z7.record(
-        z7.string(),
-        z7.union([z7.string(), z7.record(z7.string(), z7.string())])
+var CssObject = z5.record(
+  z5.string(),
+  z5.lazy(
+    () => z5.union([
+      z5.string(),
+      z5.record(
+        z5.string(),
+        z5.union([z5.string(), z5.record(z5.string(), z5.string())])
       )
     ])
   )
 );
-var ThemeConfigSchema = z7.object({
-  registryUrl: z7.url().optional(),
+var ThemeConfigSchema = z5.object({
+  registryUrl: z5.url().optional(),
   /**
    * @deprecated Import a `.css` file from your `zudoku.config.ts` instead.
    * Inline CSS via this option still works but requires a dev server restart
    * on every change and provides no editor tooling.
    */
-  customCss: z7.union([z7.string(), CssObject]).optional(),
+  customCss: z5.union([z5.string(), CssObject]).optional(),
   light: ThemeSchema.optional(),
   dark: ThemeSchema.optional(),
   fonts: FontsConfigSchema.optional(),
-  noDefaultTheme: z7.boolean().optional()
+  noDefaultTheme: z5.boolean().optional()
 });
-var SiteSchema = z7.object({
-  title: z7.string(),
-  logoUrl: z7.string(),
-  dir: z7.enum(["ltr", "rtl"]).optional(),
+var SiteSchema = z5.object({
+  title: z5.string(),
+  logoUrl: z5.string(),
+  dir: z5.enum(["ltr", "rtl"]).optional(),
   logo: LogoSchema,
-  showPoweredBy: z7.boolean().optional(),
-  sidebar: z7.object({
-    collapsible: z7.boolean().optional(),
-    toggleVisibility: z7.enum(["always", "hover"]).optional(),
-    togglePosition: z7.enum(["top", "center", "bottom"]).optional()
+  showPoweredBy: z5.boolean().optional(),
+  sidebar: z5.object({
+    collapsible: z5.boolean().optional(),
+    toggleVisibility: z5.enum(["always", "hover"]).optional(),
+    togglePosition: z5.enum(["top", "center", "bottom"]).optional()
   }).optional(),
-  notFoundPage: z7.custom(),
-  banner: z7.object({
-    message: z7.custom(),
-    color: z7.custom(
+  notFoundPage: z5.custom(),
+  banner: z5.object({
+    message: z5.custom(),
+    color: z5.custom(
       (val) => typeof val === "string"
     ).optional(),
-    dismissible: z7.boolean().optional()
+    dismissible: z5.boolean().optional()
   }),
   footer: FooterSchema
 }).partial();
-var PlacementPosition = z7.enum(["start", "center", "end"]);
-var HeaderConfigSchema = z7.object({
+var PlacementPosition = z5.enum(["start", "center", "end"]);
+var HeaderConfigSchema = z5.object({
   navigation: HeaderNavigationSchema,
-  themeSwitcher: z7.object({
-    enabled: z7.boolean()
+  themeSwitcher: z5.object({
+    enabled: z5.boolean()
   }).partial().optional(),
-  placements: z7.object({
+  placements: z5.object({
     navigation: PlacementPosition,
     search: PlacementPosition,
-    auth: z7.enum(["start", "center", "end", "navigation"])
+    auth: z5.enum(["start", "center", "end", "navigation"])
   }).partial().optional()
 }).partial();
-var ApiCatalogSchema = z7.object({
-  path: z7.string(),
-  label: z7.string(),
-  items: z7.array(z7.string()).optional(),
-  filterItems: z7.custom((val) => typeof val === "function").optional()
+var ApiCatalogSchema = z5.object({
+  path: z5.string(),
+  label: z5.string(),
+  items: z5.array(z5.string()).optional(),
+  filterItems: z5.custom((val) => typeof val === "function").optional()
 });
-var CdnUrlSchema = z7.union([
-  z7.string(),
-  z7.object({
-    base: z7.string().optional(),
-    media: z7.string().optional()
+var CdnUrlSchema = z5.union([
+  z5.string(),
+  z5.object({
+    base: z5.string().optional(),
+    media: z5.string().optional()
   })
 ]).transform((val) => {
   if (typeof val === "string") {
@@ -3886,66 +3866,66 @@ var CdnUrlSchema = z7.union([
   }
   return { base: val.base, media: val.media };
 });
-var BaseConfigSchema = z7.object({
-  slots: z7.record(z7.string(), z7.custom()),
+var BaseConfigSchema = z5.object({
+  slots: z5.record(z5.string(), z5.custom()),
   /**
    * @deprecated Use `slots` instead
    */
-  UNSAFE_slotlets: z7.record(z7.string(), z7.custom()),
-  mdx: z7.object({
-    components: z7.custom()
+  UNSAFE_slotlets: z5.record(z5.string(), z5.custom()),
+  mdx: z5.object({
+    components: z5.custom()
   }).partial(),
-  customPages: z7.array(
-    z7.object({
-      path: z7.string(),
-      element: z7.custom().optional(),
-      render: z7.custom().optional(),
-      prose: z7.boolean().optional()
+  customPages: z5.array(
+    z5.object({
+      path: z5.string(),
+      element: z5.custom().optional(),
+      render: z5.custom().optional(),
+      prose: z5.boolean().optional()
     })
   ),
-  plugins: z7.array(z7.custom()),
-  build: z7.custom(),
+  plugins: z5.array(z5.custom()),
+  build: z5.custom(),
   protectedRoutes: ProtectedRoutesSchema,
-  basePath: z7.string().optional(),
-  canonicalUrlOrigin: z7.string().optional(),
+  basePath: z5.string().optional(),
+  canonicalUrlOrigin: z5.string().optional(),
   cdnUrl: CdnUrlSchema.optional(),
-  port: z7.number().optional(),
-  https: z7.object({
-    key: z7.string(),
-    cert: z7.string(),
-    ca: z7.string().optional()
+  port: z5.number().optional(),
+  https: z5.object({
+    key: z5.string(),
+    cert: z5.string(),
+    ca: z5.string().optional()
   }).optional(),
   site: SiteSchema,
   header: HeaderConfigSchema.optional(),
   navigation: InputNavigationSchema,
   navigationRules: NavigationRulesSchema.optional(),
   theme: ThemeConfigSchema,
-  syntaxHighlighting: z7.object({
-    languages: z7.array(z7.custom()),
-    themes: z7.object({
-      light: z7.custom(),
-      dark: z7.custom()
+  syntaxHighlighting: z5.object({
+    languages: z5.array(z5.custom()),
+    themes: z5.object({
+      light: z5.custom(),
+      dark: z5.custom()
     })
   }).partial().optional(),
   metadata: MetadataSchema,
   authentication: AuthenticationSchema,
   search: SearchSchema,
-  apis: z7.union([ApiSchema, z7.array(ApiSchema)]),
-  catalogs: z7.union([ApiCatalogSchema, z7.array(ApiCatalogSchema)]),
+  apis: z5.union([ApiSchema, z5.array(ApiSchema)]),
+  catalogs: z5.union([ApiCatalogSchema, z5.array(ApiCatalogSchema)]),
   apiKeys: ApiKeysSchema,
   aiAssistants: AiAssistantsSchema,
-  redirects: z7.array(Redirect),
+  redirects: z5.array(Redirect),
   sitemap: SiteMapSchema,
-  enableStatusPages: z7.boolean().optional(),
-  defaults: z7.object({
+  enableStatusPages: z5.boolean().optional(),
+  defaults: z5.object({
     apis: ApiOptionsSchema,
     /**
      * @deprecated Use `apis.examplesLanguage` or `defaults.apis.examplesLanguage` instead
      */
-    examplesLanguage: z7.string().optional()
+    examplesLanguage: z5.string().optional()
   }),
   // Internal: populated by plugins via `transformConfig` to track plugin directories
-  __pluginDirs: z7.array(z7.string())
+  __pluginDirs: z5.array(z5.string())
 });
 var ZudokuConfig = BaseConfigSchema.partial().extend({
   docs: DocsConfigSchema
@@ -3956,7 +3936,7 @@ function validateConfig(config, configPath) {
   if (validationResult.success) {
     return validationResult.data;
   }
-  const prettyErrors = z7.prettifyError(validationResult.error);
+  const prettyErrors = z5.prettifyError(validationResult.error);
   const location = configPath ? ` at ${configPath}` : "";
   if (process.env.NODE_ENV === "production") {
     throw new Error(
@@ -4236,9 +4216,9 @@ var getIssuer = async (config) => {
 init_joinUrl();
 
 // src/vite/config.ts
-import path18 from "node:path";
+import path19 from "node:path";
 import dotenv from "dotenv";
-import colors4 from "picocolors";
+import colors5 from "picocolors";
 import {
   loadConfigFromFile,
   mergeConfig as mergeConfig2
@@ -4402,21 +4382,6 @@ function invalidateModule(server, id) {
   }
 }
 
-// src/vite/zuplo.ts
-import bs58 from "bs58";
-var getZuploSystemConfigurations = (string) => {
-  if (!string) return void 0;
-  try {
-    const zuploSystemConfigurations = JSON.parse(
-      Buffer.from(bs58.decode(string)).toString("utf8")
-    );
-    return zuploSystemConfigurations;
-  } catch (error) {
-    console.error(error);
-    return void 0;
-  }
-};
-
 // src/vite/plugin-api-keys.ts
 var viteApiKeysPlugin = () => {
   const virtualModuleId4 = "virtual:zudoku-api-keys-plugin";
@@ -4434,7 +4399,7 @@ var viteApiKeysPlugin = () => {
         if (!config.apiKeys?.enabled || config.__meta.mode === "standalone") {
           return `export const configuredApiKeysPlugin = undefined;`;
         }
-        const deploymentName = ZuploEnv.buildConfig?.deploymentName || getZuploSystemConfigurations(process.env.ZUPLO_SYSTEM_CONFIGURATIONS)?.__ZUPLO_DEPLOYMENT_NAME;
+        const deploymentName = ZuploEnv.deploymentName;
         const code = [
           `import config from "virtual:zudoku-config";`,
           `import { apiKeyPlugin } from "zudoku/plugins/api-keys";`,
@@ -4464,18 +4429,18 @@ import { parse as parseYaml } from "yaml";
 // src/config/validators/BuildSchema.ts
 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");
-var PluginConfigSchema = z8.custom().or(
-  z8.custom(
+import { z as z6 } from "zod";
+var BuildProcessorSchema = z6.custom((val) => typeof val === "function");
+var PluginConfigSchema = z6.custom().or(
+  z6.custom(
     (val) => typeof val === "function"
   )
 );
-var BuildConfigSchema2 = z8.object({
-  processors: z8.array(BuildProcessorSchema).optional(),
+var BuildConfigSchema = z6.object({
+  processors: z6.array(BuildProcessorSchema).optional(),
   remarkPlugins: PluginConfigSchema.optional(),
   rehypePlugins: PluginConfigSchema.optional(),
-  prerender: z8.object({ workers: z8.number().optional() }).optional()
+  prerender: z6.object({ workers: z6.number().optional() }).optional()
 });
 var zudokuBuildConfigFiles = [
   "zudoku.build.js",
@@ -4505,13 +4470,13 @@ var getBuildConfig = async () => {
   return validateBuildConfig(buildModule);
 };
 function validateBuildConfig(config) {
-  const validationResult = BuildConfigSchema2.safeParse(config);
+  const validationResult = BuildConfigSchema.safeParse(config);
   if (!validationResult.success) {
     if (process.env.NODE_ENV === "production") {
-      throw new Error(z8.prettifyError(validationResult.error));
+      throw new Error(z6.prettifyError(validationResult.error));
     }
     console.warn("Build config validation errors:");
-    console.warn(z8.prettifyError(validationResult.error));
+    console.warn(z6.prettifyError(validationResult.error));
     return;
   }
   return validationResult.data;
@@ -4608,14 +4573,14 @@ var flattenAllOf = (schema2) => {
 };
 
 // src/lib/util/traverse.ts
-var traverse = (specification, transform, path32 = []) => {
-  const transformed = transform(specification, path32);
+var traverse = (specification, transform, path33 = []) => {
+  const transformed = transform(specification, path33);
   if (typeof transformed !== "object" || transformed === null) {
     return transformed;
   }
   const result = Array.isArray(transformed) ? [] : {};
   for (const [key, value] of Object.entries(transformed)) {
-    const currentPath = [...path32, key];
+    const currentPath = [...path33, key];
     if (Array.isArray(value)) {
       result[key] = value.map(
         (item, index) => typeof item === "object" && item != null ? traverse(item, transform, [...currentPath, index.toString()]) : item
@@ -4643,9 +4608,9 @@ var resolveLocalRef = (schema2, ref) => {
   if (schemaCache?.has(ref)) {
     return schemaCache.get(ref);
   }
-  const path32 = ref.split("/").slice(1);
+  const path33 = ref.split("/").slice(1);
   let current = schema2;
-  for (const segment of path32) {
+  for (const segment of path33) {
     if (!current || typeof current !== "object") {
       current = null;
     }
@@ -4664,7 +4629,7 @@ var dereference = async (schema2, resolvers = []) => {
   }
   const cloned = structuredClone(schema2);
   const visited = /* @__PURE__ */ new Set();
-  const resolve = async (current, path32) => {
+  const resolve = async (current, path33) => {
     if (isIndexableObject(current)) {
       if (visited.has(current)) {
         return CIRCULAR_REF;
@@ -4672,7 +4637,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], `${path32}/${index}`);
+          current[index] = await resolve(current[index], `${path33}/${index}`);
         }
       } else {
         if ("$ref" in current && typeof current.$ref === "string") {
@@ -4683,13 +4648,13 @@ var dereference = async (schema2, resolvers = []) => {
           for (const resolver of resolvers) {
             const resolved = await resolver($ref);
             if (resolved) {
-              result2 = await resolve(resolved, path32);
+              result2 = await resolve(resolved, path33);
               break;
             }
           }
           if (result2 === void 0) {
             const resolved = await resolveLocalRef(cloned, $ref);
-            result2 = await resolve(resolved, path32);
+            result2 = await resolve(resolved, path33);
           }
           if (hasSiblings) {
             if (result2 === CIRCULAR_REF) {
@@ -4702,7 +4667,7 @@ var dereference = async (schema2, resolvers = []) => {
           return result2;
         }
         for (const key in current) {
-          current[key] = await resolve(current[key], `${path32}/${key}`);
+          current[key] = await resolve(current[key], `${path33}/${key}`);
         }
       }
       visited.delete(current);
@@ -4741,9 +4706,9 @@ var upgradeSchema = (schema2) => {
     }
     return sub;
   });
-  schema2 = traverse(schema2, (sub, path32) => {
+  schema2 = traverse(schema2, (sub, path33) => {
     if (sub.example !== void 0) {
-      if (isSchemaPath(path32 ?? [])) {
+      if (isSchemaPath(path33 ?? [])) {
         sub.examples = [sub.example];
       } else {
         sub.examples = {
@@ -4756,11 +4721,11 @@ var upgradeSchema = (schema2) => {
     }
     return sub;
   });
-  schema2 = traverse(schema2, (schema3, path32) => {
+  schema2 = traverse(schema2, (schema3, path33) => {
     if (schema3.type === "object" && schema3.properties !== void 0) {
-      const parentPath = path32?.slice(0, -1);
+      const parentPath = path33?.slice(0, -1);
       const isMultipart = parentPath?.some((segment, index) => {
-        return segment === "content" && path32?.[index + 1] === "multipart/form-data";
+        return segment === "content" && path33?.[index + 1] === "multipart/form-data";
       });
       if (isMultipart) {
         const entries = Object.entries(schema3.properties);
@@ -4774,8 +4739,8 @@ var upgradeSchema = (schema2) => {
     }
     return schema3;
   });
-  schema2 = traverse(schema2, (schema3, path32) => {
-    if (path32?.includes("content") && path32.includes("application/octet-stream")) {
+  schema2 = traverse(schema2, (schema3, path33) => {
+    if (path33?.includes("content") && path33.includes("application/octet-stream")) {
       return {};
     }
     if (schema3.type === "string" && schema3.format === "binary") {
@@ -4801,11 +4766,11 @@ var upgradeSchema = (schema2) => {
     }
     return sub;
   });
-  schema2 = traverse(schema2, (schema3, path32) => {
+  schema2 = traverse(schema2, (schema3, path33) => {
     if (schema3.type === "string" && schema3.format === "byte") {
-      const parentPath = path32?.slice(0, -1);
+      const parentPath = path33?.slice(0, -1);
       const contentMediaType = parentPath?.find(
-        (_, index) => path32?.[index - 1] === "content"
+        (_, index) => path33?.[index - 1] === "content"
       );
       return {
         type: "string",
@@ -4817,7 +4782,7 @@ var upgradeSchema = (schema2) => {
   });
   return schema2;
 };
-function isSchemaPath(path32) {
+function isSchemaPath(path33) {
   const schemaLocations = [
     ["components", "schemas"],
     "properties",
@@ -4830,10 +4795,10 @@ function isSchemaPath(path32) {
   ];
   return schemaLocations.some((location) => {
     if (Array.isArray(location)) {
-      return location.every((segment, index) => path32[index] === segment);
+      return location.every((segment, index) => path33[index] === segment);
     }
-    return path32.includes(location);
-  }) || path32.includes("schema") || path32.some((segment) => segment.endsWith("Schema"));
+    return path33.includes(location);
+  }) || path33.includes("schema") || path33.some((segment) => segment.endsWith("Schema"));
 }
 
 // src/lib/oas/parser/index.ts
@@ -4925,13 +4890,13 @@ var OPENAPI_PROPS = /* @__PURE__ */ new Set([
   "anyOf",
   "oneOf"
 ]);
-var handleCircularRefs = (obj, currentPath = /* @__PURE__ */ new WeakSet(), refs = /* @__PURE__ */ new WeakMap(), path32 = [], currentRefPaths = /* @__PURE__ */ new Set()) => {
+var handleCircularRefs = (obj, currentPath = /* @__PURE__ */ new WeakSet(), refs = /* @__PURE__ */ new WeakMap(), path33 = [], 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 = path32.find((p) => !OPENAPI_PROPS.has(p)) || path32[0];
+    const circularProp = path33.find((p) => !OPENAPI_PROPS.has(p)) || path33[0];
     return [CIRCULAR_REF, circularProp].filter(Boolean).join(":");
   }
   if (refs.has(obj)) return refs.get(obj);
@@ -4941,7 +4906,7 @@ var handleCircularRefs = (obj, currentPath = /* @__PURE__ */ new WeakSet(), refs
     value,
     currentPath,
     refs,
-    [...path32, key],
+    [...path33, key],
     currentRefPaths
   );
   const result = Array.isArray(obj) ? obj.map((item, i) => recurse(item, i.toString())) : Object.fromEntries(
@@ -4979,7 +4944,7 @@ var resolveExtensions = (obj) => Object.fromEntries(
 var getAllTags = (schema2) => {
   const rootTags = schema2.tags ?? [];
   const operations = Object.values(schema2.paths ?? {}).flatMap(
-    (path32) => HttpMethods.map((k) => path32?.[k]).filter((op) => op != null)
+    (path33) => HttpMethods.map((k) => path33?.[k]).filter((op) => op != null)
   );
   const operationTags = new Set(operations.flatMap((op) => op.tags ?? []));
   const hasUntaggedOperations = operations.some(
@@ -5034,7 +4999,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(
-    ([path32, value]) => HttpMethods.flatMap((method) => {
+    ([path33, value]) => HttpMethods.flatMap((method) => {
       if (!value?.[method]) return [];
       const operation = value[method];
       const pathParameters = value.parameters ?? [];
@@ -5054,7 +5019,7 @@ var getAllOperations = (paths) => {
       return {
         ...operation,
         method,
-        path: path32,
+        path: path33,
         parameters,
         servers,
         tags: operation.tags ?? []
@@ -5583,8 +5548,8 @@ var Schema = builder.objectRef("Schema").implement({
     }),
     paths: t.field({
       type: [PathItem],
-      resolve: (root) => Object.entries(root.paths ?? {}).map(([path32, value]) => ({
-        path: path32,
+      resolve: (root) => Object.entries(root.paths ?? {}).map(([path33, value]) => ({
+        path: path33,
         // biome-ignore lint/style/noNonNullAssertion: value is guaranteed to be defined
         methods: Object.keys(value)
       }))
@@ -5714,9 +5679,9 @@ var removeParameters = ({ names, in: locations, shouldRemove } = {}) => ({ schem
   }
   if (spec.paths) {
     const updatedPaths = {};
-    for (const [path32, pathItem] of Object.entries(spec.paths)) {
+    for (const [path33, pathItem] of Object.entries(spec.paths)) {
       if (typeof pathItem !== "object" || pathItem === null) {
-        updatedPaths[path32] = pathItem;
+        updatedPaths[path33] = pathItem;
         continue;
       }
       let updatedPathItem = { ...pathItem };
@@ -5739,7 +5704,7 @@ var removeParameters = ({ names, in: locations, shouldRemove } = {}) => ({ schem
           updatedPathItem = pathItemWithMethods;
         }
       }
-      updatedPaths[path32] = updatedPathItem;
+      updatedPaths[path33] = updatedPathItem;
     }
     spec = { ...spec, paths: updatedPaths };
   }
@@ -5750,27 +5715,27 @@ var removeParameters = ({ names, in: locations, shouldRemove } = {}) => ({ schem
 var removePaths = ({ paths = {}, shouldRemove }) => ({ schema: schema2 }) => traverse(schema2, (spec) => {
   if (!spec.paths) return spec;
   const updatedPaths = {};
-  for (const [path32, methods] of Object.entries(spec.paths)) {
-    const operations = spec.paths[path32];
-    if (paths[path32] === true) continue;
-    if (shouldRemove?.({ path: path32, method: true, operation: operations }))
+  for (const [path33, methods] of Object.entries(spec.paths)) {
+    const operations = spec.paths[path33];
+    if (paths[path33] === true) continue;
+    if (shouldRemove?.({ path: path33, method: true, operation: operations }))
       continue;
     if (typeof methods === "object" && methods !== null) {
       const filteredPath = Object.fromEntries(
         Object.entries(methods).filter(([method]) => {
-          const operations2 = spec.paths[path32][method];
-          const isMethodToRemove = Array.isArray(paths[path32]) && paths[path32].includes(method);
+          const operations2 = spec.paths[path33][method];
+          const isMethodToRemove = Array.isArray(paths[path33]) && paths[path33].includes(method);
           const isMethodFiltered = shouldRemove?.({
-            path: path32,
+            path: path33,
             method,
             operation: operations2
           });
           return !isMethodToRemove && !isMethodFiltered;
         })
       );
-      updatedPaths[path32] = filteredPath;
+      updatedPaths[path33] = filteredPath;
     } else {
-      updatedPaths[path32] = methods;
+      updatedPaths[path33] = methods;
     }
   }
   return { ...spec, paths: updatedPaths };
@@ -5905,7 +5870,6 @@ var writeOpenApiPublications = async (outputDir, publications) => {
 import fs2 from "node:fs/promises";
 import path9 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
@@ -6123,7 +6087,7 @@ var formatAgentQualityReport = (apiPath, issues) => [
 
 // src/vite/api/schema-codegen.ts
 var unescapeJsonPointer = (uri) => decodeURIComponent(uri.replace(/~1/g, "/").replace(/~0/g, "~"));
-var getSegmentsFromPath = (path32) => path32.split("/").slice(1).map(unescapeJsonPointer);
+var getSegmentsFromPath = (path33) => path33.split("/").slice(1).map(unescapeJsonPointer);
 var createLocalRefMap = (obj) => {
   const refMap = /* @__PURE__ */ new Map();
   const siblingsMap = /* @__PURE__ */ new Map();
@@ -6154,16 +6118,16 @@ var replaceMarkers = (code, mergedRefs) => code.replace(/"__refMap:(.*?)"/g, '__
   /"__refMap\+Siblings:(.*?)"/g,
   (_, key) => mergedRefs.get(key) ?? `__refMap["${key}"]`
 );
-var lookup = (schema2, path32, filePath) => {
-  const parts = getSegmentsFromPath(path32);
+var lookup = (schema2, path33, filePath) => {
+  const parts = getSegmentsFromPath(path33);
   let val = schema2;
   for (const part of parts) {
     while (val.$ref?.startsWith("#/")) {
-      val = val.$ref === path32 ? val : lookup(schema2, val.$ref, filePath);
+      val = val.$ref === path33 ? 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: ${path32}`
+        `Error in ${filePath ?? "code generation"}: Could not find path segment ${part} in path: ${path33}`
       );
     }
     val = val[part];
@@ -6216,6 +6180,72 @@ var generateCode = (schema2, filePath) => {
   return lines.join("\n");
 };
 
+// src/vite/api/upgradeOpenApi.ts
+import { upgrade } from "@scalar/openapi-parser";
+var httpMethods2 = new Set(HttpMethods);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var mapValues = (record, fn) => Object.fromEntries(
+  Object.entries(record).map(([key, value]) => [key, fn(value)])
+);
+var upgradeResponse = (response) => upgrade({
+  openapi: "3.0.3",
+  info: { title: "", version: "" },
+  paths: { "/": { get: { responses: { "200": response } } } }
+}).specification?.paths?.["/"]?.get?.responses?.["200"] ?? response;
+var upgradeDefaultResponse = (responses) => isRecord(responses) && isRecord(responses.default) ? { ...responses, default: upgradeResponse(responses.default) } : responses;
+var upgradePathItem = (pathItem) => {
+  if (!isRecord(pathItem)) return pathItem;
+  return Object.fromEntries(
+    Object.entries(pathItem).map(([method, operation]) => {
+      if (!httpMethods2.has(method) || !isRecord(operation)) {
+        return [method, operation];
+      }
+      return [
+        method,
+        {
+          ...operation,
+          ...operation.responses && {
+            responses: upgradeDefaultResponse(operation.responses)
+          },
+          ...isRecord(operation.callbacks) && {
+            callbacks: mapValues(operation.callbacks, upgradeCallback)
+          }
+        }
+      ];
+    })
+  );
+};
+var upgradeCallback = (callback) => isRecord(callback) ? mapValues(callback, upgradePathItem) : callback;
+var upgradeDefaultResponses = (document) => ({
+  ...document,
+  ...isRecord(document.paths) && {
+    paths: mapValues(document.paths, upgradePathItem)
+  },
+  ...isRecord(document.webhooks) && {
+    webhooks: mapValues(document.webhooks, upgradePathItem)
+  },
+  ...isRecord(document.components) && {
+    components: {
+      ...document.components,
+      ...isRecord(document.components.responses) && {
+        responses: upgradeDefaultResponse(document.components.responses)
+      },
+      ...isRecord(document.components.callbacks) && {
+        callbacks: mapValues(document.components.callbacks, upgradeCallback)
+      }
+    }
+  }
+});
+var upgradeOpenApi = (schema2) => {
+  const isUpgraded = typeof schema2.swagger === "string" || typeof schema2.openapi === "string" && schema2.openapi.startsWith("3.0");
+  const upgraded = upgrade(schema2).specification;
+  const document = isUpgraded && isRecord(upgraded) ? upgradeDefaultResponses(upgraded) : upgraded;
+  if (document?.info && typeof document.info.version !== "string") {
+    document.info.version = "0.0.1";
+  }
+  return document;
+};
+
 // src/vite/api/SchemaManager.ts
 var FALLBACK_VERSION = "default";
 var parseInputString = (input) => {
@@ -6256,13 +6286,7 @@ var SchemaManager = class {
     this.storeDir = storeDir;
     this.config = config;
     this.processors = [
-      ({ schema: schema2 }) => {
-        const upgraded = upgrade(schema2).specification;
-        if (upgraded?.info && typeof upgraded.info.version !== "string") {
-          upgraded.info.version = "0.0.1";
-        }
-        return upgraded;
-      },
+      ({ schema: schema2 }) => upgradeOpenApi(schema2),
       flattenAllOfProcessor,
       ...processors
     ];
@@ -6429,8 +6453,8 @@ var SchemaManager = class {
     }
     this.getPublishedSchemas();
   };
-  getLatestSchema = (path32) => this.processedSchemas[path32]?.at(0);
-  getSchemasForPath = (path32) => this.processedSchemas[path32];
+  getLatestSchema = (path33) => this.processedSchemas[path33]?.at(0);
+  getSchemasForPath = (path33) => this.processedSchemas[path33];
   getSchemaImports = () => Object.values(this.processedSchemas).flat().filter((s) => s.importKey);
   getPublishedSchemas = () => {
     if (this.publishedSchemas) return this.publishedSchemas;
@@ -7148,6 +7172,457 @@ var viteAuthPlugin = () => {
 };
 var plugin_auth_default = viteAuthPlugin;
 
+// src/vite/plugin-blog.ts
+import { spawnSync } from "node:child_process";
+import { stat as stat3 } from "node:fs/promises";
+import path14 from "node:path";
+import { glob as glob2 } from "glob";
+import globParent from "glob-parent";
+import { fromMarkdown as fromMarkdown2 } from "mdast-util-from-markdown";
+import { mdxFromMarkdown as mdxFromMarkdown2 } from "mdast-util-mdx";
+import { mdxjs as mdxjs2 } from "micromark-extension-mdxjs";
+import colors4 from "picocolors";
+
+// src/lib/core/plugin-config.ts
+var PLUGIN_CONFIG = /* @__PURE__ */ Symbol.for("zudoku.pluginConfig");
+var selectPluginConfigs = (plugins, name) => plugins.flatMap((plugin) => {
+  const tag = plugin && typeof plugin === "object" ? plugin[PLUGIN_CONFIG] : void 0;
+  return tag?.name === name ? [tag.config] : [];
+});
+
+// src/lib/plugins/blog/options.ts
+init_joinUrl();
+var BLOG_PLUGIN_NAME = "zudoku-blog";
+var resolveBlogOptions = (options = {}) => ({
+  files: typeof options.files === "string" ? [options.files] : options.files ?? ["/blog/**/*.{md,mdx}"],
+  path: joinUrl(options.path ?? "/blog"),
+  title: options.title ?? "Blog",
+  description: options.description,
+  postsPerPage: Math.max(1, Math.floor(options.postsPerPage ?? 10)),
+  showReadingTime: options.showReadingTime ?? true,
+  authors: options.authors ?? {},
+  sidebar: options.sidebar === false ? false : {
+    title: options.sidebar?.title ?? "Recent posts",
+    count: options.sidebar?.count ?? 5
+  },
+  feed: options.feed
+});
+
+// src/vite/plugin-blog.ts
+init_joinUrl();
+var WORDS_PER_MINUTE = 200;
+var DATE_PREFIX = /^(\d{4}-\d{2}-\d{2})(?:[-_]|$)/;
+var warn2 = (message) => logger.warn(colors4.yellow(`[blog] ${message}`), { timestamp: true });
+var parsePostPath = (relativePath) => {
+  const segments = relativePath.replace(/\.mdx?$/, "").split("/");
+  if (segments.length > 1 && segments.at(-1) === "index") segments.pop();
+  const name = segments.pop() ?? "";
+  const date = name.match(DATE_PREFIX)?.[1];
+  const slugName = date ? name.slice(date.length).replace(/^[-_]/, "") : name;
+  return { slug: [...segments, slugName || name].join("/"), date };
+};
+var toArray = (value) => value === void 0 || value === null ? [] : Array.isArray(value) ? value : [value];
+var nonEmptyString = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+var parseDate = (value) => {
+  if (!(value instanceof Date) && typeof value !== "string") return;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? void 0 : date;
+};
+var PHRASING_PARENTS = /* @__PURE__ */ new Set([
+  "paragraph",
+  "heading",
+  "emphasis",
+  "strong",
+  "delete",
+  "link",
+  "linkReference",
+  "tableCell",
+  "mdxJsxTextElement"
+]);
+var toText = (node) => {
+  if ("children" in node) {
+    const separator = PHRASING_PARENTS.has(node.type) ? "" : " ";
+    return node.children.map(toText).join(separator);
+  }
+  if (node.type === "html" || node.type.startsWith("mdx")) return "";
+  return "value" in node ? node.value : "";
+};
+var collapseWhitespace = (text) => text.replace(/\s+/g, " ").trim();
+var parseMarkdown = (content, isMdx) => {
+  let withoutComments = content;
+  for (let previous = ""; previous !== withoutComments; ) {
+    previous = withoutComments;
+    withoutComments = withoutComments.replace(/<!--[\s\S]*?-->/g, "");
+  }
+  try {
+    return isMdx ? fromMarkdown2(withoutComments, {
+      extensions: [mdxjs2()],
+      mdastExtensions: [mdxFromMarkdown2()]
+      // biome-ignore lint/suspicious/noExplicitAny: mdast-util-from-markdown has type incompatibilities between versions
+    }) : fromMarkdown2(withoutComments);
+  } catch {
+    return void 0;
+  }
+};
+var isAbsoluteUrl = (url) => /^([a-z][a-z\d+.-]*:|\/\/)/i.test(url);
+var withBasePath = (config, url) => url && !isAbsoluteUrl(url) ? joinUrl(config.basePath, url) : url;
+var resolveAuthor = (config, blog, entry, file) => {
+  if (typeof entry === "string") {
+    const author = blog.authors[entry];
+    if (author) {
+      return { ...author, imageUrl: withBasePath(config, author.imageUrl) };
+    }
+    warn2(
+      `Unknown author "${entry}" in ${file}. Add it to the \`authors\` of \`blogPlugin()\`.`
+    );
+    return { name: entry };
+  }
+  if (typeof entry !== "object" || entry === null) return;
+  const record = entry;
+  const name = nonEmptyString(record.name);
+  if (!name) return;
+  return {
+    name,
+    title: nonEmptyString(record.title),
+    url: nonEmptyString(record.url),
+    imageUrl: withBasePath(config, nonEmptyString(record.imageUrl))
+  };
+};
+var resolveTags = (value) => {
+  const tags = /* @__PURE__ */ new Map();
+  for (const entry of toArray(value)) {
+    const label = nonEmptyString(
+      typeof entry === "number" ? `${entry}` : entry
+    );
+    if (!label) continue;
+    const slug = slugify(label);
+    if (slug && !tags.has(slug)) tags.set(slug, { label, slug });
+  }
+  return [...tags.values()];
+};
+var getGitCreatedDate = (absolutePath) => {
+  const result = spawnSync(
+    "git",
+    ["log", "--diff-filter=A", "--follow", "--format=%cI", "--", absolutePath],
+    {
+      cwd: path14.dirname(absolutePath),
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }
+  );
+  if (result.status !== 0) return;
+  return parseDate(result.stdout.trim().split("\n").at(-1));
+};
+var readPost = async (config, blog, file, globRoot) => {
+  const absolutePath = path14.resolve(config.__meta.rootDir, file);
+  const { data, content } = await readFrontmatter(absolutePath);
+  const draft = data.draft === true;
+  if (draft && process.env.NODE_ENV !== "development") return;
+  const fromPath = parsePostPath(path14.posix.relative(globRoot, file));
+  const slug = nonEmptyString(data.slug)?.replace(/^\/+|\/+$/g, "");
+  const tree = parseMarkdown(content, file.endsWith(".mdx"));
+  const contentTitle = tree?.children.find(
+    (node) => node.type === "heading" && node.depth === 1
+  );
+  const firstParagraph = tree?.children.filter((node) => node.type === "paragraph").map((node) => collapseWhitespace(toText(node))).find(Boolean);
+  const words = collapseWhitespace(tree ? toText(tree) : content).split(" ").filter(Boolean).length;
+  let date = parseDate(data.date);
+  if (data.date !== void 0 && !date) {
+    warn2(`Invalid date "${data.date}" in ${file}.`);
+  }
+  date ??= parseDate(fromPath.date) ?? getGitCreatedDate(absolutePath) ?? (await stat3(absolutePath)).mtime;
+  return {
+    file,
+    path: joinUrl(blog.path, slug ?? fromPath.slug),
+    title: nonEmptyString(data.title) ?? (contentTitle ? collapseWhitespace(toText(contentTitle)) : void 0) ?? fromPath.slug,
+    description: nonEmptyString(data.description) ?? firstParagraph,
+    date: date.toISOString(),
+    authors: toArray(data.authors).flatMap(
+      (entry) => resolveAuthor(config, blog, entry, file) ?? []
+    ),
+    tags: resolveTags(data.tags),
+    readingTime: Math.max(1, Math.round(words / WORDS_PER_MINUTE)),
+    image: resolveImage(config, nonEmptyString(data.image)),
+    ...draft ? { draft } : {}
+  };
+};
+var isIndexFile = (file) => /(^|\/)index\.mdx?$/.test(file);
+var filterPostFiles = (files) => {
+  const postFolders = new Set(
+    files.filter((file) => isIndexFile(file) && file.includes("/")).map((file) => path14.posix.dirname(file))
+  );
+  return files.filter((file) => {
+    const segments = file.split("/");
+    if (segments.some((segment) => segment.startsWith("_"))) return false;
+    if (isIndexFile(file)) return true;
+    return !segments.slice(0, -1).some((_, i) => postFolders.has(segments.slice(0, i + 1).join("/")));
+  });
+};
+var isReservedPath = (blog, postPath) => {
+  const subPath = postPath.slice(blog.path.length).replace(/^\//, "");
+  return subPath === "" || subPath === "tags" || subPath === "rss.xml" || subPath.startsWith("tags/") || subPath.startsWith("page/");
+};
+var loadBlogPosts = async (config, blog) => {
+  const posts = await Promise.all(
+    blog.files.map(async (pattern) => {
+      const files = await glob2(pattern, {
+        root: config.__meta.rootDir,
+        cwd: config.__meta.rootDir,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
+        absolute: false,
+        posix: true
+      });
+      const globRoot = globParent(pattern).replace(/^\.?\//, "");
+      const postFiles = filterPostFiles(
+        files.map((file) => path14.posix.relative(globRoot, file))
+      );
+      return Promise.all(
+        postFiles.map(
+          (file) => readPost(config, blog, path14.posix.join(globRoot, file), globRoot)
+        )
+      );
+    })
+  );
+  const sorted = posts.flat().filter((post) => post !== void 0).sort(
+    (a, b) => b.date.localeCompare(a.date) || a.title.localeCompare(b.title)
+  );
+  const byPath = /* @__PURE__ */ new Map();
+  for (const post of sorted) {
+    if (isReservedPath(blog, post.path)) {
+      warn2(
+        `${post.file} resolves to ${post.path}, which is used by the blog's own pages. Rename it or set a different \`slug\`.`
+      );
+      continue;
+    }
+    const existing = byPath.get(post.path);
+    if (!existing) {
+      byPath.set(post.path, post);
+    } else if (existing.file !== post.file) {
+      warn2(
+        `${post.file} and ${existing.file} both resolve to ${post.path}. Only ${existing.file} is used.`
+      );
+    }
+  }
+  return [...byPath.values()];
+};
+var getBlogSiteUrl = (config) => config.canonicalUrlOrigin ?? config.sitemap?.siteUrl;
+var resolveImage = (config, image) => {
+  const siteUrl = getBlogSiteUrl(config);
+  if (!image || isAbsoluteUrl(image) || !siteUrl) {
+    return withBasePath(config, image);
+  }
+  return joinUrl(siteUrl, config.basePath, image);
+};
+var isFeedEnabled = (config, blog) => Boolean((blog.feed ?? true) && getBlogSiteUrl(config));
+var getFeedPath = (blog) => joinUrl(blog.path, "rss.xml");
+var escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+var generateRssFeed = ({
+  siteUrl,
+  basePath,
+  blog,
+  posts
+}) => {
+  const url = (routePath) => joinUrl(siteUrl, basePath, routePath);
+  const tag = (name, value) => value ? `<${name}>${escapeXml(value)}</${name}>` : "";
+  const items = posts.map(
+    (post) => [
+      "    <item>",
+      `      ${tag("title", post.title)}`,
+      `      ${tag("link", url(post.path))}`,
+      `      <guid isPermaLink="true">${escapeXml(url(post.path))}</guid>`,
+      `      ${tag("pubDate", new Date(post.date).toUTCString())}`,
+      post.description && `      ${tag("description", post.description)}`,
+      ...post.authors.map((a) => `      ${tag("dc:creator", a.name)}`),
+      ...post.tags.map((t) => `      ${tag("category", t.label)}`),
+      "    </item>"
+    ].filter(Boolean).join("\n")
+  );
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">',
+    "  <channel>",
+    `    ${tag("title", blog.title)}`,
+    `    ${tag("link", url(blog.path))}`,
+    `    ${tag("description", blog.description ?? blog.title)}`,
+    `    <atom:link href="${escapeXml(url(getFeedPath(blog)))}" rel="self" type="application/rss+xml"/>`,
+    ...items,
+    "  </channel>",
+    "</rss>",
+    ""
+  ].join("\n");
+};
+var getBlogs = (config) => {
+  if (config.__meta.mode === "standalone") return [];
+  const blogs = selectPluginConfigs(
+    config.plugins ?? [],
+    BLOG_PLUGIN_NAME
+  ).map((options) => resolveBlogOptions(options));
+  const duplicate = blogs.find(
+    (blog, index) => blogs.findIndex((b) => b.path === blog.path) !== index
+  );
+  if (duplicate) {
+    throw new ZudokuError(
+      `Multiple blogs are configured with the path "${duplicate.path}".`,
+      {
+        title: "Conflicting blog paths",
+        developerHint: "Give each `blogPlugin()` in `plugins` its own `path`, e.g. `/blog` and `/changelog`."
+      }
+    );
+  }
+  return blogs;
+};
+var postsCache = /* @__PURE__ */ new Map();
+var getBlogPosts = (config, blog) => {
+  const key = JSON.stringify([
+    config.__meta.rootDir,
+    config.basePath,
+    getBlogSiteUrl(config),
+    blog
+  ]);
+  const cached = postsCache.get(key);
+  if (cached) return cached;
+  const posts = loadBlogPosts(config, blog);
+  postsCache.set(key, posts);
+  posts.catch(() => postsCache.delete(key));
+  return posts;
+};
+var getBlogRoutesByFile = async (config) => {
+  const posts = await Promise.all(
+    getBlogs(config).map((blog) => getBlogPosts(config, blog))
+  );
+  return new Map(
+    posts.flat().map((post) => [
+      path14.resolve(config.__meta.rootDir, post.file).replace(/\.mdx?$/, ""),
+      post.path
+    ])
+  );
+};
+var isInBlogFolder = (config, filePath) => getBlogs(config).flatMap((blog) => blog.files).map((pattern) => globParent(pattern).replace(/^\.?\//, "")).some((folder) => {
+  const relative = path14.relative(
+    path14.resolve(config.__meta.rootDir, folder),
+    filePath
+  );
+  return relative !== ".." && !relative.startsWith(`..${path14.sep}`) && !path14.isAbsolute(relative);
+});
+var manifestModuleId = "virtual:zudoku-blog";
+var postsModulePrefix = "virtual:zudoku-blog/posts";
+var generateManifest = async (config) => {
+  const entries = await Promise.all(
+    getBlogs(config).map(async (blog) => {
+      const posts = await getBlogPosts(config, blog);
+      const tags = /* @__PURE__ */ new Map();
+      for (const tag of posts.flatMap((post) => post.tags)) {
+        if (!tags.has(tag.slug)) tags.set(tag.slug, tag);
+      }
+      const data = {
+        tags: [...tags.values()].sort((a, b) => a.label.localeCompare(b.label)),
+        feedUrl: isFeedEnabled(config, blog) ? joinUrl(config.basePath, getFeedPath(blog)) : void 0
+      };
+      return [
+        `  ${JSON.stringify(blog.path)}: {`,
+        `    ...${JSON.stringify(data)},`,
+        `    postImports: {`,
+        ...posts.map(
+          (post) => `      ${JSON.stringify(post.path)}: () => import(${JSON.stringify(joinUrl(post.file))}),`
+        ),
+        `    },`,
+        `    loadPosts: () => import(${JSON.stringify(postsModulePrefix + blog.path)}).then((m) => m.posts),`,
+        `  },`
+      ];
+    })
+  );
+  return [`export const blogs = {`, ...entries.flat(), `};`];
+};
+var viteBlogPlugin = () => {
+  const resolvedManifestId = `\0${manifestModuleId}`;
+  const resolvedPostsPrefix = `\0${postsModulePrefix}`;
+  return {
+    name: "zudoku-blog-plugin",
+    resolveId(id) {
+      if (id === manifestModuleId || id.startsWith(`${postsModulePrefix}/`)) {
+        return `\0${id}`;
+      }
+    },
+    async load(id) {
+      if (id === resolvedManifestId) {
+        const config = getCurrentConfig();
+        const code = await generateManifest(config);
+        await writePluginDebugCode(config.__meta.rootDir, "blog-plugin", code);
+        return code.join("\n");
+      }
+      if (id.startsWith(`${resolvedPostsPrefix}/`)) {
+        const config = getCurrentConfig();
+        const blogPath = id.slice(resolvedPostsPrefix.length);
+        const blog = getBlogs(config).find((b) => b.path === blogPath);
+        const posts = blog ? await getBlogPosts(config, blog) : [];
+        return `export const posts = ${JSON.stringify(
+          posts.map(({ file: _file, ...post }) => post)
+        )};`;
+      }
+    },
+    async generateBundle() {
+      if (this.environment.name !== "client") return;
+      const config = getCurrentConfig();
+      const siteUrl = getBlogSiteUrl(config);
+      for (const blog of getBlogs(config)) {
+        if (!siteUrl || !isFeedEnabled(config, blog)) {
+          if (blog.feed) {
+            warn2(
+              `Skipping the RSS feed of ${blog.path}: set \`canonicalUrlOrigin\` or \`sitemap.siteUrl\` so the feed can link to posts.`
+            );
+          }
+          continue;
+        }
+        this.emitFile({
+          type: "asset",
+          fileName: getFeedPath(blog).slice(1),
+          source: generateRssFeed({
+            siteUrl,
+            basePath: config.basePath,
+            blog,
+            posts: await getBlogPosts(config, blog)
+          })
+        });
+      }
+    },
+    async configureServer(server) {
+      const loadAll = (config) => Promise.all(
+        getBlogs(config).map((blog) => getBlogPosts(config, blog))
+      ).then((posts) => JSON.stringify(posts));
+      let snapshot = await loadAll(getCurrentConfig());
+      server.middlewares.use(async (req, res, next) => {
+        const config = getCurrentConfig();
+        const siteUrl = getBlogSiteUrl(config);
+        const pathname = req.url?.split(/[?#]/)[0];
+        const blog = getBlogs(config).find(
+          (b) => joinUrl(config.basePath, getFeedPath(b)) === pathname
+        );
+        if (!blog || !siteUrl || !isFeedEnabled(config, blog)) return next();
+        res.setHeader("Content-Type", "application/rss+xml; charset=utf-8");
+        res.end(
+          generateRssFeed({
+            siteUrl,
+            basePath: config.basePath,
+            blog,
+            posts: await getBlogPosts(config, blog)
+          })
+        );
+      });
+      server.watcher.on("all", async (event, filePath) => {
+        if (!["add", "change", "unlink"].includes(event)) return;
+        if (!/\.mdx?$/.test(filePath)) return;
+        const config = getCurrentConfig();
+        if (!isInBlogFolder(config, filePath)) return;
+        postsCache.clear();
+        const previous = snapshot;
+        snapshot = await loadAll(config);
+        if (previous !== snapshot) reload(server);
+      });
+    }
+  };
+};
+var plugin_blog_default = viteBlogPlugin;
+
 // src/vite/plugin-config.ts
 import { normalizePath } from "vite";
 var virtualModuleId3 = "virtual:zudoku-config";
@@ -7237,7 +7712,7 @@ var viteCustomPagesPlugin = () => {
 var plugin_custom_pages_default = viteCustomPagesPlugin;
 
 // src/vite/plugin-doc-metadata.ts
-import { glob as glob2 } from "glob";
+import { glob as glob3 } from "glob";
 var serializeMetadata = async (filePath) => {
   const fm = await readFrontmatter(filePath);
   const h1 = fm.content.match(/^#\s+(.*)$/m)?.[1];
@@ -7248,7 +7723,7 @@ var viteDocMetadataPlugin = () => ({
   name: "zudoku-doc-metadata-plugin",
   configureServer: async (server) => {
     const config = getCurrentConfig();
-    const files = await glob2("**/*.{md,mdx}", {
+    const files = await glob3("**/*.{md,mdx}", {
       cwd: config.__meta.rootDir,
       ignore: ["node_modules", "dist"],
       absolute: true
@@ -7273,9 +7748,9 @@ var viteDocMetadataPlugin = () => ({
 });
 
 // src/vite/plugin-docs.ts
-import path14 from "node:path";
-import { glob as glob3 } from "glob";
-import globParent from "glob-parent";
+import path15 from "node:path";
+import { glob as glob4 } from "glob";
+import globParent2 from "glob-parent";
 
 // src/lib/components/navigation/utils.ts
 import { cva } from "class-variance-authority";
@@ -7328,19 +7803,19 @@ var ensureLeadingSlash = joinUrl;
 var globMarkdownFiles = async (config, options = { absolute: false }) => {
   const fileMapping = {};
   for (const globPattern of config.docs.files) {
-    const globbedFiles = await glob3(globPattern, {
+    const globbedFiles = await glob4(globPattern, {
       root: config.__meta.rootDir,
       ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
       // Always glob with relative paths to avoid issues on different OS
       absolute: false,
       posix: true
     });
-    const parent = globParent(globPattern).replace(/^\.?\//, "");
+    const parent = globParent2(globPattern).replace(/^\.?\//, "");
     let draftFiles = /* @__PURE__ */ new Set();
     if (process.env.NODE_ENV !== "development") {
       const draftStatuses = await Promise.all(
         globbedFiles.map(async (file) => {
-          const absolutePath = path14.resolve(config.__meta.rootDir, file);
+          const absolutePath = path15.resolve(config.__meta.rootDir, file);
           const { data } = await readFrontmatter(absolutePath);
           return { file, isDraft: data.draft === true };
         })
@@ -7353,9 +7828,9 @@ var globMarkdownFiles = async (config, options = { absolute: false }) => {
       if (draftFiles.has(file)) {
         continue;
       }
-      const relativePath = path14.posix.relative(parent, file);
+      const relativePath = path15.posix.relative(parent, file);
       const routePath = ensureLeadingSlash(relativePath.replace(/\.mdx?$/, ""));
-      const filePath = options.absolute ? path14.resolve(config.__meta.rootDir, file) : file;
+      const filePath = options.absolute ? path15.resolve(config.__meta.rootDir, file) : file;
       fileMapping[routePath] = filePath;
     }
   }
@@ -7439,7 +7914,7 @@ var plugin_docs_default = viteDocsPlugin;
 
 // src/vite/plugin-markdown-export.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import path15 from "node:path";
+import path16 from "node:path";
 
 // src/lib/util/contentNegotiation.ts
 var representations = [
@@ -7611,15 +8086,15 @@ ${markdownContent}`;
   return {
     content: finalMarkdown,
     title: frontmatter.title,
-    description: frontmatter.description
+    description: frontmatter.seo?.description ?? frontmatter.description
   };
 };
 var getMarkdownOutputPath = (distDir, routePath) => {
   const segments = routePath === "/" ? ["index"] : routePath.split("/").filter(Boolean);
-  return `${path15.join(distDir, ...segments)}.md`;
+  return `${path16.join(distDir, ...segments)}.md`;
 };
 var writeMarkdownInfo = async (markdownInfoPath, markdownFileInfos) => {
-  await mkdir2(path15.dirname(markdownInfoPath), { recursive: true });
+  await mkdir2(path16.dirname(markdownInfoPath), { recursive: true });
   await writeFile2(
     markdownInfoPath,
     JSON.stringify(markdownFileInfos, null, 2),
@@ -7748,7 +8223,7 @@ var viteMarkdownExportPlugin = () => {
       if (process.env.NODE_ENV !== "production" || !needsMdFiles(config)) {
         return;
       }
-      const distDir = path15.join(
+      const distDir = path16.join(
         config.__meta.rootDir,
         "dist",
         config.basePath ?? ""
@@ -7769,14 +8244,14 @@ var viteMarkdownExportPlugin = () => {
             content: finalMarkdown
           });
           const outputPath = getMarkdownOutputPath(distDir, routePath);
-          await mkdir2(path15.dirname(outputPath), { recursive: true });
+          await mkdir2(path16.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 || isContentNegotiationEnabled(config)) {
-        const markdownInfoPath = path15.join(
+        const markdownInfoPath = path16.join(
           config.__meta.rootDir,
           "node_modules/.zudoku/markdown-info.json"
         );
@@ -8079,28 +8554,28 @@ var remarkCodeTabs = () => (tree) => {
 };
 
 // src/vite/mdx/remark-inject-filepath.ts
-import path16 from "node:path";
+import path17 from "node:path";
 var remarkInjectFilepath = (rootDir) => (tree, vfile) => {
-  const relativePath = path16.relative(rootDir, vfile.path).split(path16.sep).join(path16.posix.sep);
+  const relativePath = path17.relative(rootDir, vfile.path).split(path17.sep).join(path17.posix.sep);
   tree.children.unshift(exportMdxjsConst("__filepath", relativePath));
 };
 
 // src/vite/mdx/remark-last-modified.ts
-import { spawnSync } from "node:child_process";
-import { stat as stat3 } from "node:fs/promises";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { stat as stat4 } from "node:fs/promises";
 import { visit as visit4 } from "unist-util-visit";
 import { parse as parse2, stringify as stringify4 } from "yaml";
 var isGitAvailable;
 var hasWarnedShallowClone = false;
 var checkGitAvailable = () => {
   if (isGitAvailable !== void 0) return isGitAvailable;
-  const result = spawnSync("git", ["--version"], { stdio: "ignore" });
+  const result = spawnSync2("git", ["--version"], { stdio: "ignore" });
   isGitAvailable = result.status === 0;
   return isGitAvailable;
 };
 var isShallowRepository = () => {
   if (!checkGitAvailable()) return false;
-  const result = spawnSync("git", ["rev-parse", "--is-shallow-repository"], {
+  const result = spawnSync2("git", ["rev-parse", "--is-shallow-repository"], {
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "ignore"]
   });
@@ -8125,7 +8600,7 @@ var warnShallowClone = () => {
 };
 var getLastModifiedDate = async (filePath) => {
   if (checkGitAvailable()) {
-    const result = spawnSync(
+    const result = spawnSync2(
       "git",
       ["log", "-1", "--format=%cI", "--", filePath],
       { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
@@ -8136,7 +8611,7 @@ var getLastModifiedDate = async (filePath) => {
     }
   }
   try {
-    const stats = await stat3(filePath);
+    const stats = await stat4(filePath);
     return stats.mtime;
   } catch {
   }
@@ -8168,7 +8643,7 @@ var remarkLastModified = () => {
 };
 
 // src/vite/mdx/remark-link-rewrite.ts
-import path17 from "node:path";
+import path18 from "node:path";
 import { visit as visit5 } from "unist-util-visit";
 var markdownExtension = /\.mdx?$/;
 var resolveToRoute = (url, filePath, routesByFile) => {
@@ -8176,7 +8651,7 @@ var resolveToRoute = (url, filePath, routesByFile) => {
   if (!markdownExtension.test(pathname) || pathname.startsWith("/")) {
     return void 0;
   }
-  const targetFile = path17.resolve(path17.dirname(filePath), pathname).replace(markdownExtension, "");
+  const targetFile = path18.resolve(path18.dirname(filePath), pathname).replace(markdownExtension, "");
   const route = routesByFile.get(targetFile);
   if (route === void 0) return void 0;
   return `${route}${suffix}`;
@@ -8191,11 +8666,11 @@ var remarkLinkRewrite = (basePath = "", routesByFile = /* @__PURE__ */ new Map()
       node.url = resolved;
       return;
     }
-    const base = path17.posix.join(basePath);
+    const base = path18.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 = path17.posix.join("..", node.url);
+      node.url = path18.posix.join("..", node.url);
     }
     node.url = node.url.replace(/\.mdx?(#.*)?$/, "$1");
   });
@@ -8408,6 +8883,9 @@ var viteMdxPlugin = async () => {
   for (const [route, filePath] of Object.entries(fileMapping)) {
     routesByFile.set(filePath.replace(/\.mdx?$/, ""), route);
   }
+  for (const [filePath, route] of await getBlogRoutesByFile(config)) {
+    routesByFile.set(filePath, route);
+  }
   const defaultRemarkPlugins = [
     remarkStaticGeneration,
     [remarkInjectFilepath, config.__meta.rootDir],
@@ -8567,6 +9045,7 @@ function vitePlugin() {
     plugin_custom_pages_default(),
     plugin_auth_default(),
     plugin_docs_default(),
+    plugin_blog_default(),
     viteDocMetadataPlugin(),
     viteNavigationPlugin(),
     plugin_api_default(),
@@ -8829,12 +9308,12 @@ var protectedAnnotatorPlugin = () => ({
 });
 
 // src/vite/config.ts
-var getAppClientEntryPath = () => path18.posix.join(getZudokuRootDir(), "src/app/entry.client.tsx");
-var getAppServerEntryPath = () => path18.posix.join(getZudokuRootDir(), "src/app/entry.server.tsx");
+var getAppClientEntryPath = () => path19.posix.join(getZudokuRootDir(), "src/app/entry.client.tsx");
+var getAppServerEntryPath = () => path19.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 getDepScanEntries = () => {
-  const src = path18.posix.join(getZudokuRootDir(), "src");
+  const src = path19.posix.join(getZudokuRootDir(), "src");
   return [
     `${src}/{app,lib}/**/*.{ts,tsx}`,
     // Client-environment scan: `entry.server.tsx` imports
@@ -8864,9 +9343,9 @@ async function getViteConfig(dir, configEnv, options = {}) {
   const cdnUrl = config.cdnUrl;
   const base = cdnUrl?.base ? joinUrl(cdnUrl.base, config.basePath) : config.basePath;
   if (cdnUrl && !hasLoggedCdnInfo) {
-    logger.info(colors4.blue(`Using CDN URL:`));
-    logger.info(colors4.blue(`  base:  `) + colors4.dim(cdnUrl.base));
-    logger.info(colors4.blue(`  media: `) + colors4.dim(cdnUrl.media));
+    logger.info(colors5.blue(`Using CDN URL:`));
+    logger.info(colors5.blue(`  base:  `) + colors5.dim(cdnUrl.base));
+    logger.info(colors5.blue(`  media: `) + colors5.dim(cdnUrl.media));
     hasLoggedCdnInfo = true;
   }
   const publicVarsProcessEnvDefine = Object.fromEntries(
@@ -8877,11 +9356,11 @@ async function getViteConfig(dir, configEnv, options = {}) {
   );
   if (ZuploEnv.isZuplo) {
     dotenv.config({
-      path: path18.resolve(config.__meta.rootDir, "../.env.zuplo"),
+      path: path19.resolve(config.__meta.rootDir, "../.env.zuplo"),
       quiet: true
     });
   }
-  const deploymentName = ZuploEnv.buildConfig?.deploymentName || getZuploSystemConfigurations(process.env.ZUPLO_SYSTEM_CONFIGURATIONS)?.__ZUPLO_DEPLOYMENT_NAME;
+  const deploymentName = ZuploEnv.deploymentName;
   const viteConfig = {
     root: dir,
     base,
@@ -8909,10 +9388,13 @@ async function getViteConfig(dir, configEnv, options = {}) {
       "import.meta.env.IS_ZUPLO": ZuploEnv.isZuplo,
       "import.meta.env.ZUDOKU_HAS_SERVER": JSON.stringify(options.ssr === true),
       "import.meta.env.ZUPLO_PUBLIC_DEPLOYMENT_NAME": JSON.stringify(deploymentName),
+      // Derived value only; the raw env var is read at build time.
+      "import.meta.env.ZUPLO_DEV_PORTAL_ZUPLO_BRANDING": JSON.stringify(
+        ZuploEnv.devPortalZuploBranding
+      ),
       ...defineEnvVars([
         "SENTRY_DSN",
         "ZUPLO_BUILD_ID",
-        "ZUPLO_BUILD_CONFIG",
         "ZUPLO_ENVIRONMENT_TYPE",
         "ZUPLO_SERVER_URL",
         "ZUPLO_GATEWAY_SERVICE_URL"
@@ -8937,7 +9419,7 @@ async function getViteConfig(dir, configEnv, options = {}) {
       sourcemap: true,
       target: "es2022",
       chunkSizeWarningLimit: 1500,
-      outDir: path18.resolve(path18.join(dir, "dist", config.basePath ?? "")),
+      outDir: path19.resolve(path19.join(dir, "dist", config.basePath ?? "")),
       emptyOutDir: false,
       rolldownOptions: {
         external: [joinUrl(config.basePath, "/pagefind/pagefind.js")],
@@ -8967,8 +9449,8 @@ async function getViteConfig(dir, configEnv, options = {}) {
           external: ["@shikijs/themes", "@shikijs/langs"]
         },
         build: {
-          outDir: path18.resolve(
-            path18.join(dir, "dist", config.basePath ?? "", "server")
+          outDir: path19.resolve(
+            path19.join(dir, "dist", config.basePath ?? "", "server")
           ),
           copyPublicDir: false,
           rolldownOptions: {
@@ -8983,7 +9465,7 @@ async function getViteConfig(dir, configEnv, options = {}) {
         if (filename.startsWith(`${PROTECTED_CHUNK_DIR}/`)) {
           return joinUrl(config.basePath, `/${filename}`);
         }
-        if (cdnUrl?.base && [".js", ".css"].includes(path18.extname(filename))) {
+        if (cdnUrl?.base && [".js", ".css"].includes(path19.extname(filename))) {
           return joinUrl(cdnUrl.base, filename);
         }
         if (cdnUrl?.media && MEDIA_REGEX.test(filename)) {
@@ -9037,7 +9519,7 @@ async function getViteConfig(dir, configEnv, options = {}) {
     if (!loaded) continue;
     mergedViteConfig = mergeConfig2(mergedViteConfig, loaded.config, true);
     if (root === dir) {
-      logger.info(colors4.blue(`merged with custom user Vite config`), {
+      logger.info(colors5.blue(`merged with custom user Vite config`), {
         timestamp: true
       });
     }
@@ -9090,10 +9572,10 @@ ${cssLinks}
 
 // src/vite/manifest.ts
 import { writeFile as writeFile3 } from "node:fs/promises";
-import path19 from "node:path";
+import path20 from "node:path";
 var writeManifest = async (distDir, config) => {
   await writeFile3(
-    path19.join(distDir, MANIFEST_FILENAME),
+    path20.join(distDir, MANIFEST_FILENAME),
     `${JSON.stringify(buildManifest(config), null, 2)}
 `,
     "utf-8"
@@ -9104,8 +9586,100 @@ var writeManifest = async (distDir, config) => {
 import assert from "node:assert";
 import { existsSync } from "node:fs";
 import { cp, mkdir as mkdir3, readdir, rm, writeFile as writeFile4 } from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
+init_joinUrl();
+
+// src/lib/util/redirectPattern.ts
 init_joinUrl();
+var SPLAT = "*";
+var ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|[\\/]{2})/i;
+var TOKEN_REGEX = /\/(?::([\w-]+)|\*)(?=[/?#]|$)/g;
+var parseSegments = (path33) => {
+  const parts = path33.split("/").filter(Boolean);
+  return parts.map((part, index) => {
+    if (part === SPLAT && index === parts.length - 1) return { type: "splat" };
+    const match = part.match(/^:([\w-]+)(\?)?$/);
+    if (!match?.[1]) return { type: "static", value: part };
+    return { type: "param", name: match[1], optional: match[2] === "?" };
+  });
+};
+var getParamNames = (from) => parseSegments(from).flatMap((segment) => {
+  if (segment.type === "param") return [segment.name];
+  if (segment.type === "splat") return [SPLAT];
+  return [];
+});
+var isDynamicRedirect = (redirect) => getParamNames(redirect.from).length > 0;
+var replaceTokens = (to, names, replace) => {
+  const target = to.replace(TOKEN_REGEX, (token, name) => {
+    const key = name ?? SPLAT;
+    return names.includes(key) ? replace(key) : token;
+  });
+  const lostPath = target === "" || /^[?#]/.test(target);
+  return target !== to && lostPath ? `/${target}` : target;
+};
+var rankPath = (path33) => {
+  const segments = joinUrl(path33).split("/");
+  return segments.reduce(
+    (score, segment) => {
+      if (segment === SPLAT) return score;
+      if (segment.startsWith(":")) return score + 3;
+      return score + (segment === "" ? 1 : 10);
+    },
+    segments.length - (segments.includes(SPLAT) ? 2 : 0)
+  );
+};
+var segmentToPath = (segment) => {
+  if (segment.type === "static") return segment.value;
+  if (segment.type === "splat") return SPLAT;
+  return `:${segment.name}`;
+};
+var explodeOptional = (segments) => {
+  const [first, ...rest] = segments;
+  if (!first) return [[]];
+  const variants = explodeOptional(rest);
+  const withFirst = variants.map((variant) => [first, ...variant]);
+  return first.type === "param" && first.optional ? [...withFirst, ...variants] : withFirst;
+};
+var escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var toBuildOutputRedirects = (redirects, basePath) => {
+  const base = joinUrl(basePath);
+  const prefix = base === "/" ? "" : escapeRegex(base);
+  return redirects.flatMap((redirect) => {
+    const names = getParamNames(redirect.from);
+    const to = ABSOLUTE_URL_REGEX.test(redirect.to) ? redirect.to : joinUrl(basePath, redirect.to);
+    const toRoute = (segments) => {
+      const captured = segments.flatMap((segment) => {
+        if (segment.type === "param") return [segment.name];
+        if (segment.type === "splat") return [SPLAT];
+        return [];
+      });
+      const pattern = segments.map((segment) => {
+        if (segment.type === "static") {
+          return `/${escapeRegex(segment.value)}`;
+        }
+        return segment.type === "splat" ? "(/.+)" : "(/[^/]+)";
+      }).join("");
+      const endsWithSplat = segments.at(-1)?.type === "splat";
+      return {
+        // React Router accepts any number of trailing slashes
+        src: `^${prefix}${pattern}${endsWithSplat ? "" : "/*"}$`,
+        // Like React Router, a repeated param name takes the last value
+        location: replaceTokens(
+          to,
+          names,
+          (name) => captured.includes(name) ? `$${captured.lastIndexOf(name) + 1}` : ""
+        )
+      };
+    };
+    return explodeOptional(parseSegments(redirect.from)).flatMap(
+      (segments) => {
+        const rank = rankPath(`/${segments.map(segmentToPath).join("/")}`);
+        const variants = segments.at(-1)?.type === "splat" ? [segments, segments.slice(0, -1)] : [segments];
+        return variants.map((variant) => ({ rank, ...toRoute(variant) }));
+      }
+    );
+  }).toSorted((a, b) => b.rank - a.rank).map(({ src, location }) => ({ src, location }));
+};
 
 // src/vite/vercel-markdown-middleware.ts
 var normalizePath2 = (value) => {
@@ -9478,12 +10052,12 @@ var listStaticFiles = async (rootDir, currentDir = rootDir) => {
   const entries = await readdir(currentDir, { withFileTypes: true });
   const files = await Promise.all(
     entries.map(async (entry) => {
-      const entryPath = path20.join(currentDir, entry.name);
+      const entryPath = path21.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         return listStaticFiles(rootDir, entryPath);
       }
       if (!entry.isFile()) return [];
-      return [path20.relative(rootDir, entryPath).split(path20.sep).join("/")];
+      return [path21.relative(rootDir, entryPath).split(path21.sep).join("/")];
     })
   );
   return files.flat().sort();
@@ -9513,7 +10087,7 @@ var getCleanUrlOverrides = (staticHtmlFiles) => {
 };
 var cleanVercelOutput = async (dir) => {
   if (!process.env.VERCEL) return;
-  await rm(path20.join(dir, ".vercel/output"), {
+  await rm(path21.join(dir, ".vercel/output"), {
     recursive: true,
     force: true
   });
@@ -9575,8 +10149,20 @@ function generateOutput({
       continue: true
     });
   }
-  if (rewrites.length > 0) {
+  const dynamicRedirects = toBuildOutputRedirects(
+    (config.redirects ?? []).filter(isDynamicRedirect),
+    config.basePath
+  );
+  if (rewrites.length > 0 || dynamicRedirects.length > 0) {
     routes.push({ handle: "filesystem" });
+    for (const { src, location } of dynamicRedirects) {
+      routes.push({
+        src,
+        dest: location,
+        status: 301,
+        headers: { Location: location }
+      });
+    }
     for (const rewrite of rewrites) {
       routes.push({
         src: joinUrl(config.basePath, rewrite.source),
@@ -9602,12 +10188,12 @@ async function writeOutput(dir, {
   markdownNegotiation
 }) {
   const vercelMarkdownNegotiation = process.env.VERCEL ? markdownNegotiation : void 0;
-  const staticFiles = process.env.VERCEL ? await listStaticFiles(path20.join(dir, ".vercel/output/static")) : [];
+  const staticFiles = process.env.VERCEL ? await listStaticFiles(path21.join(dir, ".vercel/output/static")) : [];
   const staticHtmlFiles = staticFiles.filter(
     (filename) => filename.endsWith(HTML_EXTENSION)
   );
   const staticPassthroughPaths = staticFiles.filter((filename) => {
-    const basename = path20.posix.basename(filename);
+    const basename = path21.posix.basename(filename);
     return !basename.includes(".") || basename.endsWith(".md") || basename.endsWith(".mdx");
   }).map((filename) => `/${filename}`);
   const output = generateOutput({
@@ -9617,13 +10203,13 @@ async function writeOutput(dir, {
     markdownNegotiation: vercelMarkdownNegotiation,
     staticHtmlFiles
   });
-  const outputDir = process.env.VERCEL ? path20.join(dir, ".vercel/output") : path20.join(dir, "dist/.output");
+  const outputDir = process.env.VERCEL ? path21.join(dir, ".vercel/output") : path21.join(dir, "dist/.output");
   await mkdir3(outputDir, { recursive: true });
-  const outputFile = path20.join(outputDir, "config.json");
+  const outputFile = path21.join(outputDir, "config.json");
   await writeFile4(outputFile, JSON.stringify(output, null, 2), "utf-8");
   if (process.env.VERCEL) {
     if (vercelMarkdownNegotiation) {
-      const functionDir = path20.join(
+      const functionDir = path21.join(
         outputDir,
         "functions",
         `${MARKDOWN_MIDDLEWARE_PATH}.func`
@@ -9631,7 +10217,7 @@ async function writeOutput(dir, {
       await mkdir3(functionDir, { recursive: true });
       await Promise.all([
         writeFile4(
-          path20.join(functionDir, "index.js"),
+          path21.join(functionDir, "index.js"),
           generateVercelMarkdownMiddleware({
             basePath: config.basePath,
             ...vercelMarkdownNegotiation,
@@ -9640,7 +10226,7 @@ async function writeOutput(dir, {
           "utf-8"
         ),
         writeFile4(
-          path20.join(functionDir, ".vc-config.json"),
+          path21.join(functionDir, ".vc-config.json"),
           JSON.stringify({ runtime: "edge", entrypoint: "index.js" }, null, 2),
           "utf-8"
         )
@@ -9654,10 +10240,10 @@ async function writeOutput(dir, {
 import { readFileSync as readFileSync2 } from "node:fs";
 import { readFile as readFile3, rm as rm2 } from "node:fs/promises";
 import os from "node:os";
-import path23 from "node:path";
+import path24 from "node:path";
 import { pathToFileURL } from "node:url";
 import { createIndex } from "pagefind";
-import colors7 from "picocolors";
+import colors8 from "picocolors";
 import PiscinaImport from "piscina";
 init_markdown_representation();
 
@@ -9694,8 +10280,8 @@ function throttle(fn) {
 init_joinUrl();
 import { createWriteStream, existsSync as existsSync2 } from "node:fs";
 import { mkdir as mkdir4 } from "node:fs/promises";
-import path21 from "node:path";
-import colors5 from "picocolors";
+import path22 from "node:path";
+import colors6 from "picocolors";
 import { SitemapStream } from "sitemap";
 async function generateSitemap({
   outputUrls,
@@ -9708,11 +10294,11 @@ async function generateSitemap({
     return;
   }
   const sitemap = new SitemapStream({ hostname: config.siteUrl });
-  const outputDir = path21.resolve(baseOutputDir, config.outDir ?? "");
+  const outputDir = path22.resolve(baseOutputDir, config.outDir ?? "");
   if (!existsSync2(outputDir)) {
     await mkdir4(outputDir, { recursive: true });
   }
-  const sitemapOutputPath = path21.join(outputDir, "sitemap.xml");
+  const sitemapOutputPath = path22.join(outputDir, "sitemap.xml");
   const writeStream = createWriteStream(sitemapOutputPath);
   sitemap.pipe(writeStream);
   let lastmod;
@@ -9736,20 +10322,20 @@ async function generateSitemap({
     writeStream.on("error", reject);
   });
   console.debug(
-    colors5.blue(`\u2713 wrote sitemap to ${colors5.bold(sitemapOutputPath)}`)
+    colors6.blue(`\u2713 wrote sitemap to ${colors6.bold(sitemapOutputPath)}`)
   );
 }
 
 // src/vite/prerender/utils.ts
 init_joinUrl();
-var resolveRoutePath2 = (path32) => {
-  const segments = path32.split("/");
+var resolveRoutePath2 = (path33) => {
+  const segments = path33.split("/");
   if (segments.some((s) => s.startsWith(":") && !s.endsWith("?"))) {
     return void 0;
   }
   return segments.filter((s) => !s.startsWith(":")).join("/") || void 0;
 };
-var isSkipped = (path32) => path32.includes("*") || /^\d+$/.test(path32);
+var isSkipped = (path33) => path33.includes("*") || /^\d+$/.test(path33);
 var resolveRoutes = (routes, parentPath = "") => routes.flatMap((route) => {
   if (route.path && isSkipped(route.path)) return [];
   const routePath = route.path ? resolveRoutePath2(route.path) : void 0;
@@ -9778,10 +10364,16 @@ var collectRewrites = (resolved) => resolved.flatMap((r) => [
   ...collectRewrites(r.children)
 ]);
 var routesToPaths = (routes) => collectPaths(resolveRoutes(routes), "");
+var withoutDynamicRedirectRoutes = (routes, redirects = []) => {
+  const paths = new Set(
+    redirects.filter(isDynamicRedirect).map(({ from }) => joinUrl(from))
+  );
+  return routes.filter((route) => !route.path || !paths.has(route.path));
+};
 var routesToPrerenderPaths = (routes, redirects = []) => Array.from(
   /* @__PURE__ */ new Set([
     ...routesToPaths(routes),
-    ...redirects.map(({ from }) => joinUrl(from))
+    ...redirects.filter((redirect) => !isDynamicRedirect(redirect)).map(({ from }) => joinUrl(from))
   ])
 );
 var routesToRewrites = (routes) => collectRewrites(resolveRoutes(routes));
@@ -9814,19 +10406,22 @@ var prerender = async ({
   serverConfigFilename,
   writeRedirects = true
 }) => {
-  const distDir = path23.join(dir, "dist", basePath);
+  const distDir = path24.join(dir, "dist", basePath);
   const serverConfigPath = pathToFileURL(
-    path23.join(distDir, "server", serverConfigFilename)
+    path24.join(distDir, "server", serverConfigFilename)
   ).href;
   const entryServerPath = pathToFileURL(
-    path23.join(distDir, "server/entry.server.js")
+    path24.join(distDir, "server/entry.server.js")
   ).href;
   const rawConfig = await import(serverConfigPath).then((m) => m.default);
   const config = validateConfig(await runPluginTransformConfig(rawConfig));
   const buildConfig = await getBuildConfig();
   const module = await import(entryServerPath);
   const getRoutes = module.getRoutesByConfig;
-  const routes = getRoutes(config);
+  const routes = withoutDynamicRedirectRoutes(
+    getRoutes(config),
+    config.redirects
+  );
   const paths = routesToPrerenderPaths(routes, config.redirects);
   const rewrites = routesToRewrites(routes);
   const { maxThreads, maxOldGenerationSizeMb } = getWorkerScaling(
@@ -9837,12 +10432,12 @@ var prerender = async ({
   let lastLogTime = start;
   const writeProgress = throttle(
     (count, total, urlPath) => {
-      writeLine(`prerendering (${count}/${total}) ${colors7.dim(urlPath)}`);
+      writeLine(`prerendering (${count}/${total}) ${colors8.dim(urlPath)}`);
     }
   );
   if (!isTTY()) {
     logger.info(
-      colors7.dim(
+      colors8.dim(
         `prerendering ${paths.length} routes using ${maxThreads} workers...`
       )
     );
@@ -9884,7 +10479,7 @@ var prerender = async ({
         const now = performance.now();
         if (now - lastLogTime >= LOG_INTERVAL_MS) {
           logger.info(
-            colors7.blue(
+            colors8.blue(
               `prerendered ${completedCount}/${paths.length} routes using ${maxThreads} workers`
             )
           );
@@ -9897,10 +10492,10 @@ var prerender = async ({
   const seconds = ((performance.now() - start) / 1e3).toFixed(1);
   const message = `\u2713 finished prerendering ${paths.length} routes in ${seconds} seconds using ${maxThreads} workers`;
   if (isTTY()) {
-    writeLine(colors7.blue(`${message}
+    writeLine(colors8.blue(`${message}
 `));
   } else {
-    logger.info(colors7.blue(message));
+    logger.info(colors8.blue(message));
   }
   if (pagefindIndex) {
     const { include: pagesToIndex, exclude } = selectPagesToIndex(
@@ -9910,7 +10505,7 @@ var prerender = async ({
     if (exclude.length > 0) {
       const details = exclude.map(({ url, status }) => `${url} (${status})`).join(", ");
       logger.warn(
-        colors7.yellow(
+        colors8.yellow(
           `\u26A0 ${exclude.length} route(s) excluded from the search index (render status >= 400): ${details}`
         )
       );
@@ -9927,18 +10522,18 @@ var prerender = async ({
       if (isTTY()) {
         const done = offset + batch.length;
         writeLine(
-          `pagefind indexing (${done}/${pagesToIndex.length}) ${colors7.dim(batch.at(-1)?.url ?? "")}`
+          `pagefind indexing (${done}/${pagesToIndex.length}) ${colors8.dim(batch.at(-1)?.url ?? "")}`
         );
       }
     }
     if (isTTY()) writeLine("");
     const { outputPath } = await pagefindIndex.writeFiles({
-      outputPath: path23.join(distDir, "pagefind")
+      outputPath: path24.join(distDir, "pagefind")
     });
     if (outputPath) {
       const duration = (performance.now() - pagefindStart) / 1e3;
       logger.info(
-        colors7.blue(
+        colors8.blue(
           `\u2713 pagefind index built in ${duration.toFixed(1)} seconds: ${outputPath}`
         )
       );
@@ -9953,7 +10548,7 @@ var prerender = async ({
     redirectUrls
   });
   const llmsConfig = config.docs.llms;
-  const markdownInfoPath = path23.join(
+  const markdownInfoPath = path24.join(
     dir,
     "node_modules/.zudoku/markdown-info.json"
   );
@@ -9989,7 +10584,7 @@ var prerender = async ({
     await Promise.all(
       markdownFileInfos.map((info) => {
         const outputPath = getMarkdownOutputPath(distDir, info.routePath);
-        if (!path23.resolve(outputPath).startsWith(path23.resolve(distDir))) {
+        if (!path24.resolve(outputPath).startsWith(path24.resolve(distDir))) {
           return;
         }
         return rm2(outputPath).catch(() => {
@@ -10054,7 +10649,7 @@ var getContainerMemoryLimitMb = () => {
 
 // src/vite/protected/build.ts
 import { mkdir as mkdir5, readdir as readdir2, readFile as readFile4, rename, rm as rm3 } from "node:fs/promises";
-import path24 from "node:path";
+import path25 from "node:path";
 init_joinUrl();
 var assertProtectedPatternsCovered = (config) => {
   const { patterns } = getProtectedSourceMatcher(config);
@@ -10076,11 +10671,11 @@ var findProtectedLeaks = (output) => {
     const visited = /* @__PURE__ */ new Set();
     const stack = [{ fileName: entry.fileName, path: [entry.fileName] }];
     while (stack.length > 0) {
-      const { fileName, path: path32 } = stack.pop();
+      const { fileName, path: path33 } = stack.pop();
       if (visited.has(fileName)) continue;
       visited.add(fileName);
       for (const imp of byFileName.get(fileName)?.imports ?? []) {
-        const next = [...path32, imp];
+        const next = [...path33, imp];
         if (isProtected(imp)) {
           leaks.push(next.join(" -> "));
           continue;
@@ -10111,17 +10706,17 @@ This eagerly pulls gated content into the public bundle. Check that nothing in n
   );
 };
 var moveProtectedChunks = async (clientOutDir, serverOutDir) => {
-  const srcDir = path24.join(clientOutDir, PROTECTED_CHUNK_DIR);
+  const srcDir = path25.join(clientOutDir, PROTECTED_CHUNK_DIR);
   const files = await readdir2(srcDir).catch((err) => {
     if (err.code === "ENOENT") return null;
     throw err;
   });
   if (!files) return;
-  const destDir = path24.join(serverOutDir, PROTECTED_CHUNK_DIR);
+  const destDir = path25.join(serverOutDir, PROTECTED_CHUNK_DIR);
   await mkdir5(destDir, { recursive: true });
   await Promise.all(
     files.map(
-      (file) => rename(path24.join(srcDir, file), path24.join(destDir, file))
+      (file) => rename(path25.join(srcDir, file), path25.join(destDir, file))
     )
   );
   const leftover = await readdir2(srcDir).catch(() => []);
@@ -10139,7 +10734,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 readFile4(path24.join(dir, name), "utf-8").catch(
+    const file = await readFile4(path25.join(dir, name), "utf-8").catch(
       () => void 0
     );
     if (file === void 0) continue;
@@ -10195,7 +10790,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 = path25.resolve(path25.join(dir, "dist"));
+  const distDir = path26.resolve(path26.join(dir, "dist"));
   await Promise.all([
     rm4(distDir, { recursive: true, force: true }),
     cleanVercelOutput(dir)
@@ -10254,13 +10849,13 @@ async function runBuild(options) {
       await assertCloudflareWranglerGatesProtected(dir, config);
     }
     await writeFile6(
-      path25.join(distDir, "package.json"),
+      path26.join(distDir, "package.json"),
       `${JSON.stringify({ type: "module" }, null, 2)}
 `,
       "utf-8"
     );
     await writeManifest(distDir, config);
-    await rm4(path25.join(clientOutDir, "index.html"), { force: true });
+    await rm4(path26.join(clientOutDir, "index.html"), { force: true });
   } else {
     await runPrerender({
       dir,
@@ -10297,25 +10892,25 @@ var runPrerender = async (options) => {
       serverConfigFilename,
       writeRedirects: process.env.VERCEL === void 0
     });
-    const indexHtml = path25.join(clientOutDir, "index.html");
+    const indexHtml = path26.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(path25.basename(r.outputPath)) ? r.outputPath : []
+      (r) => /^(400|404|500)\.html$/.test(path26.basename(r.outputPath)) ? r.outputPath : []
     );
     for (const statusPage of statusPages) {
       await rename2(
         statusPage,
-        path25.join(dir, DIST_DIR, path25.basename(statusPage))
+        path26.join(dir, DIST_DIR, path26.basename(statusPage))
       );
     }
     await rm4(serverOutDir, { recursive: true, force: true });
     if (process.env.VERCEL) {
-      await mkdir6(path25.join(dir, ".vercel/output/static"), { recursive: true });
+      await mkdir6(path26.join(dir, ".vercel/output/static"), { recursive: true });
       await rename2(
-        path25.join(dir, DIST_DIR),
-        path25.join(dir, ".vercel/output/static")
+        path26.join(dir, DIST_DIR),
+        path26.join(dir, ".vercel/output/static")
       );
     }
     await writeOutput(dir, {
@@ -10331,7 +10926,7 @@ var runPrerender = async (options) => {
     if (ZuploEnv.isZuplo && issuer) {
       const provider = config.authentication?.type;
       await writeFile6(
-        path25.join(dir, DIST_DIR, ".output/zuplo.json"),
+        path26.join(dir, DIST_DIR, ".output/zuplo.json"),
         JSON.stringify({ issuer, provider }, null, 2),
         "utf-8"
       );
@@ -10343,7 +10938,7 @@ var runPrerender = async (options) => {
 };
 var findUserEntry = (dir) => {
   for (const ext of ["ts", "tsx", "js", "mjs"]) {
-    const candidate = path25.join(dir, `zudoku.server.${ext}`);
+    const candidate = path26.join(dir, `zudoku.server.${ext}`);
     if (existsSync3(candidate)) return candidate;
   }
 };
@@ -10354,15 +10949,15 @@ var bundleSSREntry = async (options) => {
   let entryPoint = userEntry;
   let tempEntryPath;
   if (!entryPoint) {
-    tempEntryPath = path25.join(dir, "__ssr-entry.ts");
+    tempEntryPath = path26.join(dir, "__ssr-entry.ts");
     const templateContent = await readFile5(
-      path25.join(packageRoot, "src/vite/ssr-templates", `${adapter}.ts`),
+      path26.join(packageRoot, "src/vite/ssr-templates", `${adapter}.ts`),
       "utf-8"
     );
     await writeFile6(tempEntryPath, templateContent, "utf-8");
     entryPoint = tempEntryPath;
   }
-  const frameworkPath = path25.join(serverOutDir, "entry.server.js");
+  const frameworkPath = path26.join(serverOutDir, "entry.server.js");
   try {
     await esbuild({
       entryPoints: [entryPoint],
@@ -10370,9 +10965,9 @@ var bundleSSREntry = async (options) => {
       platform: ["node", "lambda"].includes(adapter) ? "node" : "neutral",
       target: "es2022",
       format: "esm",
-      outfile: path25.join(serverOutDir, "entry.js"),
+      outfile: path26.join(serverOutDir, "entry.js"),
       external: ["./zudoku.config.js"],
-      nodePaths: [path25.join(packageRoot, "node_modules")],
+      nodePaths: [path26.join(packageRoot, "node_modules")],
       banner: { js: "// Bundled SSR entry" },
       define: {
         __ZUDOKU_TEMPLATE__: JSON.stringify(html)
@@ -10391,7 +10986,7 @@ var bundleSSREntry = async (options) => {
     await Promise.all([
       rm4(frameworkPath, { force: true }),
       rm4(`${frameworkPath}.map`, { force: true }),
-      rm4(path25.join(serverOutDir, "assets"), {
+      rm4(path26.join(serverOutDir, "assets"), {
         recursive: true,
         force: true
       })
@@ -10402,20 +10997,20 @@ var bundleSSREntry = async (options) => {
 };
 
 // src/cli/common/output.ts
-import colors8 from "picocolors";
+import colors9 from "picocolors";
 function printDiagnosticsToConsole(message) {
-  console.error(colors8.bold(colors8.blue(message)));
+  console.error(colors9.bold(colors9.blue(message)));
 }
 function printWarningToConsole(message) {
   console.error(message);
 }
 
 // src/cli/preview/handler.ts
-import path26 from "node:path";
+import path27 from "node:path";
 import { preview as vitePreview } from "vite";
 var DEFAULT_PREVIEW_PORT = 4e3;
 async function preview(argv) {
-  const dir = path26.resolve(process.cwd(), argv.dir);
+  const dir = path27.resolve(process.cwd(), argv.dir);
   const viteConfig = await getViteConfig(dir, {
     command: "serve",
     mode: "production",
@@ -10453,7 +11048,7 @@ async function build(argv) {
   printDiagnosticsToConsole(`Starting Zudoku build v${packageJson2.version}`);
   printDiagnosticsToConsole("");
   printDiagnosticsToConsole("");
-  const dir = path27.resolve(process.cwd(), argv.dir);
+  const dir = path28.resolve(process.cwd(), argv.dir);
   try {
     await runBuild({
       dir,
@@ -10612,13 +11207,13 @@ var build_default = {
 
 // src/cli/dev/handler.ts
 init_joinUrl();
-import path30 from "node:path";
+import path31 from "node:path";
 
 // src/vite/dev-server.ts
 import fs4 from "node:fs/promises";
 import http from "node:http";
 import https from "node:https";
-import path29 from "node:path";
+import path30 from "node:path";
 import { stripVTControlCharacters } from "node:util";
 import { createHttpTerminator } from "http-terminator";
 import {
@@ -10650,7 +11245,7 @@ async function findAvailablePort(startPort) {
 init_joinUrl();
 
 // src/vite/pagefind-dev-index.ts
-import path28 from "node:path";
+import path29 from "node:path";
 import { createIndex as createIndex2 } from "pagefind";
 import { isRunnableDevEnvironment } from "vite";
 init_joinUrl();
@@ -10704,7 +11299,7 @@ async function* buildPagefindDevIndex(vite, config) {
       path: urlPath
     };
   }
-  const outputPath = path28.join(vite.config.publicDir, "pagefind");
+  const outputPath = path29.join(vite.config.publicDir, "pagefind");
   await pagefindIndex.writeFiles({ outputPath });
   yield { type: "complete", success: true, indexed };
 }
@@ -10724,9 +11319,9 @@ var DevServer = class {
     this.protocol = "https";
     const { dir } = this.#options;
     const [key, cert, ca] = await Promise.all([
-      fs4.readFile(path29.resolve(dir, config.https.key)),
-      fs4.readFile(path29.resolve(dir, config.https.cert)),
-      config.https.ca ? fs4.readFile(path29.resolve(dir, config.https.ca)) : void 0
+      fs4.readFile(path30.resolve(dir, config.https.key)),
+      fs4.readFile(path30.resolve(dir, config.https.cert)),
+      config.https.ca ? fs4.readFile(path30.resolve(dir, config.https.ca)) : void 0
     ]);
     return https.createServer({ key, cert, ca });
   }
@@ -10754,7 +11349,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 = path29.posix.join(
+            const entryPath = path30.posix.join(
               server2.config.base,
               "/__z/entry.client.tsx"
             );
@@ -10866,13 +11461,13 @@ var DevServer = class {
       `Server-side rendering ${this.#options.ssr ? "enabled" : "disabled"}`
     );
     if (config.search?.type === "pagefind") {
-      const pagefindPath = path29.join(
+      const pagefindPath = path30.join(
         vite.config.publicDir,
         "pagefind/pagefind.js"
       );
       const exists = await fs4.stat(pagefindPath).catch(() => false);
       if (!exists) {
-        await fs4.mkdir(path29.dirname(pagefindPath), { recursive: true });
+        await fs4.mkdir(path30.dirname(pagefindPath), { recursive: true });
         await fs4.writeFile(pagefindPath, 'throw new Error("NOT_BUILT_YET");');
       }
     }
@@ -10974,7 +11569,7 @@ var DevServer = class {
 async function dev(argv) {
   const packageJson2 = getZudokuPackageJson();
   process.env.NODE_ENV = "development";
-  const dir = path30.resolve(process.cwd(), argv.dir);
+  const dir = path31.resolve(process.cwd(), argv.dir);
   const server = new DevServer({
     dir,
     argPort: argv.port,
@@ -11082,11 +11677,11 @@ var preview_default = previewCommand;
 import { existsSync as existsSync4, mkdirSync } from "node:fs";
 import { readFile as readFile6, writeFile as writeFile7 } from "node:fs/promises";
 import { join } from "node:path";
-import colors10 from "picocolors";
+import colors11 from "picocolors";
 import { gt } from "semver";
 
 // src/cli/common/utils/box.ts
-import colors9 from "picocolors";
+import colors10 from "picocolors";
 import stripAnsi from "strip-ansi";
 var border = ["\u2500", "\u256D", "\u256E", "\u2502", "\u2502", "\u2570", "\u256F"];
 var nothing = ["\u2500", "", "", "", "", "", ""];
@@ -11098,7 +11693,7 @@ function box(message, {
 } = {}) {
   const lines = message.split(/\r?\n/).map((line) => [line, stripAnsi(line).length]);
   const maxLine = lines.reduce((p, [, len]) => Math.max(p, len), 0);
-  const borderColorFn = borderColor && colors9[borderColor] || colors9.yellow;
+  const borderColorFn = borderColor && colors10[borderColor] || colors10.yellow;
   const clampedSidePadding = Math.max(1, padding * 3);
   const narrowMode = maxLine + 2 + clampedSidePadding * 2 > cols;
   const sidePadding = narrowMode ? 0 : clampedSidePadding;
@@ -11130,12 +11725,12 @@ function box(message, {
 
 // src/cli/common/xdg/lib.ts
 import { homedir } from "node:os";
-import path31 from "node:path";
+import path32 from "node:path";
 function defineDirectoryWithFallback(xdgName, fallback) {
   if (process.env[xdgName]) {
     return process.env[xdgName];
   } else {
-    return path31.join(homedir(), fallback);
+    return path32.join(homedir(), fallback);
   }
 }
 var XDG_CONFIG_HOME = defineDirectoryWithFallback(
@@ -11150,15 +11745,15 @@ var XDG_STATE_HOME = defineDirectoryWithFallback(
   "XDG_DATA_HOME",
   ".local/state"
 );
-var ZUDOKU_XDG_CONFIG_HOME = path31.join(
+var ZUDOKU_XDG_CONFIG_HOME = path32.join(
   XDG_CONFIG_HOME,
   CLI_XDG_FOLDER_NAME
 );
-var ZUDOKU_XDG_DATA_HOME = path31.join(
+var ZUDOKU_XDG_DATA_HOME = path32.join(
   XDG_DATA_HOME,
   CLI_XDG_FOLDER_NAME
 );
-var ZUDOKU_XDG_STATE_HOME = path31.join(
+var ZUDOKU_XDG_STATE_HOME = path32.join(
   XDG_STATE_HOME,
   CLI_XDG_FOLDER_NAME
 );
@@ -11176,12 +11771,12 @@ async function warnIfOutdatedVersion(currentVersion) {
   if (shouldWarn) {
     printWarningToConsole(
       box(
-        `Update available! ${colors10.gray(`v${currentVersion}`)} \u226B ${colors10.green(
+        `Update available! ${colors11.gray(`v${currentVersion}`)} \u226B ${colors11.green(
           `v${versionCheckInfo.latestVersion}`
         )}
-Run ${colors10.cyan("npm install zudoku@latest")} to update.
+Run ${colors11.cyan("npm install zudoku@latest")} to update.
 
-${colors10.gray("Upgrade to receive the latest features and fixes.")}`
+${colors11.gray("Upgrade to receive the latest features and fixes.")}`
       )
     );
   }
@@ -11242,7 +11837,7 @@ async function getVersionCheckInfo() {
 }
 
 // src/cli/common/version-check.ts
-import colors11 from "picocolors";
+import colors12 from "picocolors";
 import { minVersion, satisfies } from "semver";
 var getPkgManager = () => {
   const userAgent = process.env.npm_config_user_agent ?? "";
@@ -11276,16 +11871,16 @@ var warnPackageVersionMismatch = () => {
     return;
   }
   const pkgManager = getPkgManager();
-  const message = `${colors11.yellow("React version mismatch detected!")}
+  const message = `${colors12.yellow("React version mismatch detected!")}
 
 Zudoku requires specific versions of React
 and React DOM to function correctly.
 
-Installed: ${colors11.bold(`react@${installed.react}, react-dom@${installed["react-dom"]}`)}
-Required:  ${colors11.green(`react@${required.react}, react-dom@${required["react-dom"]}`)}
+Installed: ${colors12.bold(`react@${installed.react}, react-dom@${installed["react-dom"]}`)}
+Required:  ${colors12.green(`react@${required.react}, react-dom@${required["react-dom"]}`)}
 
 To fix, run:
-  ${colors11.cyan(`${pkgManager} install react@${minVersion(required.react)} react-dom@${minVersion(required["react-dom"])}`)}`;
+  ${colors12.cyan(`${pkgManager} install react@${minVersion(required.react)} react-dom@${minVersion(required["react-dom"])}`)}`;
   printWarningToConsole(box(message));
   process.exit(1);
 };