@lukoweb/apitogo 0.1.50 → 0.1.53

package/dist/cli/cli.js

@@ -52,6 +52,54 @@ var init_logger = __esm({
   }
 });
 
+// src/lib/authentication/auth-header-nav.ts
+function withoutLoginNavigation(navigation) {
+  return navigation.filter(
+    (item) => !("to" in item && item.to === LOGIN_NAV_PATH)
+  );
+}
+function applyAuthenticationHeaderNav(config2) {
+  if (!config2.authentication) {
+    return config2;
+  }
+  const authNavEnabled = config2.__meta?.authenticationEnabled === true;
+  const navigation = config2.header?.navigation ?? [];
+  if (!authNavEnabled) {
+    const filtered = withoutLoginNavigation(navigation);
+    if (filtered.length === navigation.length) {
+      return config2;
+    }
+    return {
+      ...config2,
+      header: {
+        ...config2.header,
+        navigation: filtered
+      }
+    };
+  }
+  if (navigation.some((item) => "to" in item && item.to === LOGIN_NAV_PATH)) {
+    return config2;
+  }
+  return {
+    ...config2,
+    header: {
+      ...config2.header,
+      navigation: [...navigation, LOGIN_HEADER_NAV_ITEM]
+    }
+  };
+}
+var LOGIN_NAV_PATH, LOGIN_HEADER_NAV_ITEM;
+var init_auth_header_nav = __esm({
+  "src/lib/authentication/auth-header-nav.ts"() {
+    LOGIN_NAV_PATH = "/signin";
+    LOGIN_HEADER_NAV_ITEM = {
+      label: "Login",
+      to: LOGIN_NAV_PATH,
+      display: "anon"
+    };
+  }
+});
+
 // src/lib/core/plugins.ts
 var isTransformConfigPlugin;
 var init_plugins = __esm({
@@ -126,95 +174,577 @@ var init_invariant = __esm({
   }
 });
 
+// src/config/apitogo-config-core.ts
+function parseEnvValue(raw) {
+  if (raw === void 0) {
+    return raw;
+  }
+  const trimmed = raw.trim();
+  if (trimmed === "true") {
+    return true;
+  }
+  if (trimmed === "false") {
+    return false;
+  }
+  if (trimmed === "null") {
+    return null;
+  }
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+    return Number(trimmed);
+  }
+  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return trimmed;
+    }
+  }
+  return trimmed;
+}
+function setNestedValue(target, pathParts, value) {
+  if (pathParts.length === 0) {
+    return;
+  }
+  let current = target;
+  for (let index = 0; index < pathParts.length - 1; index += 1) {
+    const key = pathParts[index];
+    if (!key) {
+      return;
+    }
+    const next = current[key];
+    if (next === void 0 || next === null || typeof next !== "object" || Array.isArray(next)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const leafKey = pathParts[pathParts.length - 1];
+  if (!leafKey) {
+    return;
+  }
+  current[leafKey] = value;
+}
+function stripRuntimeConfigFields(config2) {
+  const { plugins: _plugins, ...jsonOnly } = config2;
+  return jsonOnly;
+}
+function applyEnvOverrides(config2, env = process.env) {
+  const result = structuredClone(stripRuntimeConfigFields(config2));
+  for (const [key, value] of Object.entries(env)) {
+    if (!key.startsWith(ENV_PREFIX) || value === void 0) {
+      continue;
+    }
+    const pathParts = key.slice(ENV_PREFIX.length).split("__").filter(Boolean);
+    if (pathParts.length === 0) {
+      continue;
+    }
+    setNestedValue(result, pathParts, parseEnvValue(value));
+  }
+  return result;
+}
+function asRecord(value) {
+  return value !== void 0 && value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readSiteTitle(config2) {
+  const site = asRecord(config2.site);
+  const branding = asRecord(config2.branding);
+  const siteTitle = site?.title;
+  const brandingTitle = branding?.title;
+  const legacySiteName = config2.siteName;
+  if (typeof siteTitle === "string" && siteTitle.trim()) {
+    return siteTitle.trim();
+  }
+  if (typeof brandingTitle === "string" && brandingTitle.trim()) {
+    return brandingTitle.trim();
+  }
+  if (typeof legacySiteName === "string" && legacySiteName.trim()) {
+    return legacySiteName.trim();
+  }
+  return void 0;
+}
+function readLogoUrl(config2) {
+  const site = asRecord(config2.site);
+  const logo = asRecord(site?.logo);
+  const src = asRecord(logo?.src);
+  const branding = asRecord(config2.branding);
+  const fromSite = typeof src?.light === "string" && src.light || typeof src?.dark === "string" && src.dark || typeof logo?.logoUrl === "string" && logo.logoUrl || typeof site?.logoUrl === "string" && site.logoUrl;
+  if (fromSite) {
+    return fromSite;
+  }
+  return typeof branding?.logoUrl === "string" ? branding.logoUrl : void 0;
+}
+function firstApiInput(config2) {
+  const apis = config2.apis;
+  const list = Array.isArray(apis) ? apis : apis ? [apis] : [];
+  for (const entry of list) {
+    const api = asRecord(entry);
+    if (typeof api?.input === "string" && api.input.trim()) {
+      return api.input.trim();
+    }
+  }
+  return void 0;
+}
+function mergeAuthenticationGateway(config2) {
+  const authentication = asRecord(config2.authentication);
+  if (!authentication) {
+    return void 0;
+  }
+  const authGateway = asRecord(authentication.gateway);
+  const rootGateway = asRecord(config2.gateway);
+  if (!authGateway && !rootGateway) {
+    return authentication;
+  }
+  return {
+    ...authentication,
+    gateway: {
+      ...rootGateway,
+      ...authGateway
+    }
+  };
+}
+function ensureModules(config2) {
+  const modules = asRecord(config2.modules) ?? {};
+  config2.modules = modules;
+  return modules;
+}
+function mergePlansBySku(existing, patch) {
+  const bySku = /* @__PURE__ */ new Map();
+  for (const plan of existing) {
+    if (typeof plan.sku === "string") {
+      bySku.set(plan.sku, plan);
+    }
+  }
+  for (const plan of patch) {
+    if (typeof plan.sku !== "string") {
+      continue;
+    }
+    const prior = bySku.get(plan.sku);
+    bySku.set(plan.sku, prior ? { ...prior, ...plan } : plan);
+  }
+  return Array.from(bySku.values());
+}
+function readPlanCatalogItems(config2) {
+  const normalized = normalizeApitogoConfig(config2);
+  const items = asRecord(
+    asRecord(asRecord(normalized.modules)?.userPanel)?.plans
+  )?.items;
+  return Array.isArray(items) ? items : [];
+}
+function migratePlanCatalog(normalized) {
+  const modules = ensureModules(normalized);
+  const userPanel = asRecord(modules.userPanel) ?? {};
+  const plansModule = asRecord(userPanel.plans) ?? {};
+  const rootList = Array.isArray(normalized.plans) ? normalized.plans : [];
+  const existingItems = Array.isArray(plansModule.items) ? plansModule.items : [];
+  if (rootList.length) {
+    plansModule.items = mergePlansBySku(existingItems, rootList);
+    if (plansModule.enabled === void 0) {
+      plansModule.enabled = true;
+    }
+    userPanel.plans = plansModule;
+    modules.userPanel = userPanel;
+  }
+  delete normalized.plans;
+}
+function normalizeApitogoConfig(config2) {
+  const normalized = structuredClone(stripRuntimeConfigFields(config2));
+  const title = readSiteTitle(normalized);
+  const logoUrl = readLogoUrl(normalized);
+  const site = asRecord(normalized.site) ?? {};
+  if (title) {
+    site.title = title;
+  }
+  if (logoUrl && !asRecord(site.logo)?.src) {
+    site.logo = {
+      ...asRecord(site.logo) ?? {},
+      src: { light: logoUrl, dark: logoUrl }
+    };
+  }
+  normalized.site = site;
+  const authentication = mergeAuthenticationGateway(normalized);
+  if (authentication) {
+    normalized.authentication = authentication;
+  }
+  delete normalized.gateway;
+  const modules = ensureModules(normalized);
+  const legacyDocs = asRecord(normalized.docs);
+  const moduleDocs = asRecord(modules.docs) ?? {};
+  if (legacyDocs) {
+    modules.docs = { ...legacyDocs, ...moduleDocs };
+  }
+  delete normalized.docs;
+  const legacyApiKeys = asRecord(normalized.apiKeys);
+  const userPanel = asRecord(modules.userPanel) ?? {};
+  const apiKeys = asRecord(userPanel.apiKeys) ?? {};
+  if (legacyApiKeys?.enabled === true && apiKeys.enabled === void 0) {
+    userPanel.apiKeys = { ...apiKeys, enabled: true };
+    modules.userPanel = userPanel;
+  }
+  delete normalized.apiKeys;
+  const apiInput = firstApiInput(normalized);
+  if (apiInput) {
+    const backend = asRecord(normalized.backend) ?? {};
+    if (!backend.openApiPath) {
+      backend.openApiPath = apiInput;
+    }
+    normalized.backend = backend;
+  }
+  delete normalized.siteName;
+  delete normalized.branding;
+  delete normalized.projectName;
+  migratePlanCatalog(normalized);
+  syncBillingEnabled(normalized);
+  return normalized;
+}
+function isBillingEnabled(config2) {
+  const normalized = normalizeApitogoConfig(config2);
+  const plans = asRecord(
+    asRecord(asRecord(normalized.modules)?.userPanel)?.plans
+  );
+  return plans?.enabled === true;
+}
+function syncBillingEnabled(normalized) {
+  const legacyPricing = asRecord(normalized.pricing);
+  const modules = ensureModules(normalized);
+  const userPanel = asRecord(modules.userPanel) ?? {};
+  const plans = asRecord(userPanel.plans) ?? {};
+  const enabled = plans.enabled === true || legacyPricing?.enabled === true;
+  if (enabled) {
+    userPanel.plans = { ...plans, enabled: true };
+    modules.userPanel = userPanel;
+  }
+  delete normalized.pricing;
+}
+function deriveManifestFields(config2) {
+  const normalized = normalizeApitogoConfig(config2);
+  const manifest = {};
+  const title = readSiteTitle(normalized);
+  if (title) {
+    manifest.siteName = title;
+    const logoUrl = readLogoUrl(normalized);
+    manifest.branding = logoUrl ? { title, logoUrl } : { title };
+  }
+  for (const key of DERIVED_MANIFEST_KEYS) {
+    if (key === "siteName" || key === "branding") {
+      continue;
+    }
+    if (key === "authentication") {
+      const authentication2 = asRecord(normalized.authentication);
+      if (authentication2) {
+        const {
+          gateway: _gateway,
+          oidc: _oidc,
+          stripe: _stripe,
+          ...authPublic
+        } = authentication2;
+        manifest.authentication = authPublic;
+      }
+      continue;
+    }
+    if (key === "gateway") {
+      continue;
+    }
+    if (key === "pricing") {
+      if (isBillingEnabled(config2)) {
+        manifest.pricing = { enabled: true };
+      }
+      continue;
+    }
+    if (key === "plans") {
+      const items = readPlanCatalogItems(normalized);
+      if (items.length) {
+        manifest.plans = items;
+      }
+      continue;
+    }
+    if (normalized[key] !== void 0) {
+      manifest[key] = normalized[key];
+    }
+  }
+  const authentication = asRecord(normalized.authentication);
+  if (authentication?.gateway) {
+    manifest.gateway = authentication.gateway;
+  }
+  return manifest;
+}
+function extractManifest(config2) {
+  if (!config2 || typeof config2 !== "object") {
+    return null;
+  }
+  const manifest = deriveManifestFields(config2);
+  return Object.keys(manifest).length > 0 ? manifest : null;
+}
+var APITOGO_CONFIG_FILENAME, ENV_PREFIX, DERIVED_MANIFEST_KEYS;
+var init_apitogo_config_core = __esm({
+  "src/config/apitogo-config-core.ts"() {
+    APITOGO_CONFIG_FILENAME = "apitogo.config.json";
+    ENV_PREFIX = "APITOGO_CONFIG_";
+    DERIVED_MANIFEST_KEYS = [
+      "siteName",
+      "branding",
+      "pricing",
+      "authentication",
+      "plans",
+      "backend",
+      "gateway",
+      "projectId"
+    ];
+  }
+});
+
+// src/config/apitogo-config-loader.node.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import path2 from "node:path";
+function loadApitogoConfig(rootDir = process.cwd()) {
+  const configPath = path2.join(path2.resolve(rootDir), APITOGO_CONFIG_FILENAME);
+  if (!existsSync(configPath)) {
+    throw new Error(
+      `Missing ${APITOGO_CONFIG_FILENAME} in ${path2.resolve(rootDir)}`
+    );
+  }
+  const raw = readFileSync2(configPath, "utf8");
+  const parsed = JSON.parse(raw);
+  return normalizeApitogoConfig(applyEnvOverrides(parsed, process.env));
+}
+var init_apitogo_config_loader_node = __esm({
+  "src/config/apitogo-config-loader.node.ts"() {
+    init_apitogo_config_core();
+  }
+});
+
+// src/config/apitogo-config-loader.ts
+var init_apitogo_config_loader = __esm({
+  "src/config/apitogo-config-loader.ts"() {
+    init_apitogo_config_core();
+    init_apitogo_config_loader_node();
+  }
+});
+
 // src/config/file-exists.ts
 import { stat } from "node:fs/promises";
 var fileExists;
 var init_file_exists = __esm({
   "src/config/file-exists.ts"() {
-    fileExists = (path38) => stat(path38).then(() => true).catch(() => false);
+    fileExists = (path39) => stat(path39).then(() => true).catch(() => false);
   }
 });
 
-// src/config/validators/ModulesSchema.ts
+// src/config/local-manifest.ts
+import path3 from "node:path";
 import { z as z3 } from "zod";
-var ModuleToggleSchema, DocsModuleSchema, LandingLinkSchema, LandingFeatureSchema, LandingHeroSchema, LandingContentSchema, DashboardContentSchema, ProfileContentSchema, PlanTierSchema, PlansContentSchema, SubmodulePageFields, LandingModuleSchema, UserManagementModuleSchema, ApiKeysModuleSchema, PlansModuleSchema, DashboardModuleSchema, UserPanelModuleSchema, ModulesSchema;
+function isPricingEnabled(manifest) {
+  return manifest?.pricing?.enabled === true;
+}
+function isAuthenticationEnabled(manifest) {
+  return manifest?.authentication?.enabled === true;
+}
+function manifestToPreviewCatalog(manifest) {
+  const plans = manifest?.plans;
+  const catalog = plansToPreviewCatalog(plans);
+  return {
+    pricingEnabled: isPricingEnabled(manifest),
+    authenticationEnabled: isAuthenticationEnabled(manifest),
+    plans: catalog.plans
+  };
+}
+function normalizeBillingPeriod(period) {
+  if (!period) {
+    return "monthly";
+  }
+  const normalized = period.toLowerCase();
+  if (normalized === "month") {
+    return "monthly";
+  }
+  if (normalized === "year") {
+    return "annual";
+  }
+  return normalized;
+}
+function plansToPreviewCatalog(plans) {
+  if (!plans?.length) {
+    return { plans: [] };
+  }
+  return {
+    plans: plans.map((plan) => ({
+      sku: plan.sku,
+      displayName: plan.displayName,
+      priceAmount: plan.priceAmount ?? 0,
+      priceCurrency: plan.priceCurrency ?? "usd",
+      billingPeriod: normalizeBillingPeriod(plan.billingPeriod),
+      limitsJson: plan.limitsJson ?? null,
+      includedActionKeys: plan.includedActionKeys ?? []
+    }))
+  };
+}
+function resolveManifestEnv(viteMode) {
+  return viteMode === "production" ? "production" : "development";
+}
+function manifestPathsForEnv(rootDir, _env) {
+  const resolvedRoot = path3.resolve(rootDir);
+  const configPath = path3.join(resolvedRoot, APITOGO_CONFIG_FILENAME);
+  return {
+    basePath: configPath,
+    overridePath: configPath,
+    watchPaths: [configPath]
+  };
+}
+function parseManifestRecord(manifest) {
+  if (!manifest) {
+    return null;
+  }
+  const result = DevPortalLocalManifestSchema.safeParse(manifest);
+  return result.success ? result.data : null;
+}
+async function readEffectiveManifest(rootDir, _env) {
+  try {
+    const config2 = loadApitogoConfig(rootDir);
+    const manifest = parseManifestRecord(extractManifest(config2));
+    if (!manifest) {
+      return null;
+    }
+    if (!manifest.plans?.length) {
+      const items = readPlanCatalogItems(config2);
+      if (items.length) {
+        manifest.plans = items;
+      }
+    }
+    return {
+      ...manifest,
+      pricing: { ...manifest.pricing, enabled: isBillingEnabled(config2) }
+    };
+  } catch {
+    return null;
+  }
+}
+var BillingPeriodSchema, ManifestPlanInputSchema, DevPortalLocalManifestSchema;
+var init_local_manifest = __esm({
+  "src/config/local-manifest.ts"() {
+    init_apitogo_config_loader();
+    BillingPeriodSchema = z3.enum(["month", "year", "monthly", "annual"]);
+    ManifestPlanInputSchema = z3.object({
+      sku: z3.string().min(1),
+      displayName: z3.string().min(1),
+      priceAmount: z3.number().default(0),
+      priceCurrency: z3.string().optional(),
+      billingPeriod: BillingPeriodSchema.optional(),
+      limitsJson: z3.string().optional(),
+      includedActionKeys: z3.array(z3.string()).optional()
+    });
+    DevPortalLocalManifestSchema = z3.object({
+      siteName: z3.string().optional(),
+      branding: z3.object({
+        title: z3.string().optional(),
+        logoUrl: z3.string().optional()
+      }).optional(),
+      pricing: z3.object({
+        enabled: z3.boolean().optional()
+      }).optional(),
+      authentication: z3.object({
+        enabled: z3.boolean().optional(),
+        type: z3.string().optional(),
+        apiBaseUrl: z3.string().optional()
+      }).optional(),
+      plans: z3.array(ManifestPlanInputSchema).optional(),
+      backend: z3.object({
+        sourceDirectory: z3.string().optional(),
+        publishDirectory: z3.string().optional(),
+        openApiPath: z3.string().optional(),
+        runtime: z3.string().optional(),
+        runtimeVersion: z3.string().optional(),
+        deployed: z3.boolean().optional()
+      }).optional(),
+      gateway: z3.object({
+        authMode: z3.enum(["platformManagedEntra", "bringYourOwnOidc"]).optional(),
+        oidcMetadataUrl: z3.string().optional(),
+        oidcAllowedIssuers: z3.array(z3.string()).optional(),
+        oidcAudiences: z3.array(z3.string()).optional(),
+        limitsJson: z3.string().optional(),
+        publicHealthActionKey: z3.string().optional()
+      }).optional(),
+      projectId: z3.string().optional()
+    });
+  }
+});
+
+// src/config/validators/ModulesSchema.ts
+import { z as z4 } from "zod";
+var ModuleToggleSchema, DocsModuleSchema, LandingLinkSchema, LandingFeatureSchema, LandingHeroSchema, LandingContentSchema, DashboardContentSchema, ProfileContentSchema, PlanTierSchema, PlansContentSchema, SubmodulePageFields, LandingModuleSchema, UserManagementModuleSchema, ApiKeysModuleSchema, PlanCatalogItemSchema, PlansModuleSchema, DashboardModuleSchema, UserPanelModuleSchema, ModulesSchema;
 var init_ModulesSchema = __esm({
   "src/config/validators/ModulesSchema.ts"() {
-    ModuleToggleSchema = z3.object({
-      enabled: z3.boolean().describe("Whether this module is active in the application.")
+    ModuleToggleSchema = z4.object({
+      enabled: z4.boolean().describe("Whether this module is active in the application.")
     }).partial();
     DocsModuleSchema = ModuleToggleSchema.extend({
-      files: z3.union([z3.string(), z3.array(z3.string())]).optional(),
-      publishMarkdown: z3.boolean().optional(),
-      defaultOptions: z3.object({
-        toc: z3.boolean(),
-        copyPage: z3.boolean().optional(),
-        disablePager: z3.boolean(),
-        showLastModified: z3.boolean(),
-        suggestEdit: z3.object({
-          url: z3.string(),
-          text: z3.string().optional()
+      files: z4.union([z4.string(), z4.array(z4.string())]).optional(),
+      publishMarkdown: z4.boolean().optional(),
+      defaultOptions: z4.object({
+        toc: z4.boolean(),
+        copyPage: z4.boolean().optional(),
+        disablePager: z4.boolean(),
+        showLastModified: z4.boolean(),
+        suggestEdit: z4.object({
+          url: z4.string(),
+          text: z4.string().optional()
         }).optional()
       }).partial().optional(),
-      llms: z3.object({
-        llmsTxt: z3.boolean().optional(),
-        llmsTxtFull: z3.boolean().optional(),
-        includeProtected: z3.boolean().optional()
+      llms: z4.object({
+        llmsTxt: z4.boolean().optional(),
+        llmsTxtFull: z4.boolean().optional(),
+        includeProtected: z4.boolean().optional()
       }).optional()
     });
-    LandingLinkSchema = z3.object({
-      label: z3.string(),
-      href: z3.string()
+    LandingLinkSchema = z4.object({
+      label: z4.string(),
+      href: z4.string()
     });
-    LandingFeatureSchema = z3.object({
-      title: z3.string(),
-      description: z3.string()
+    LandingFeatureSchema = z4.object({
+      title: z4.string(),
+      description: z4.string()
     });
-    LandingHeroSchema = z3.object({
-      title: z3.string().optional(),
-      subtitle: z3.string().optional(),
-      description: z3.string().optional()
+    LandingHeroSchema = z4.object({
+      title: z4.string().optional(),
+      subtitle: z4.string().optional(),
+      description: z4.string().optional()
     }).optional();
-    LandingContentSchema = z3.object({
+    LandingContentSchema = z4.object({
       hero: LandingHeroSchema,
-      features: z3.array(LandingFeatureSchema).optional(),
+      features: z4.array(LandingFeatureSchema).optional(),
       primaryAction: LandingLinkSchema.optional(),
       secondaryAction: LandingLinkSchema.optional(),
-      showPoweredBy: z3.boolean().optional()
+      showPoweredBy: z4.boolean().optional()
     }).optional();
-    DashboardContentSchema = z3.object({
-      title: z3.string().optional(),
-      subtitle: z3.string().optional(),
-      description: z3.string().optional(),
-      quickLinks: z3.array(LandingLinkSchema).optional()
+    DashboardContentSchema = z4.object({
+      title: z4.string().optional(),
+      subtitle: z4.string().optional(),
+      description: z4.string().optional(),
+      quickLinks: z4.array(LandingLinkSchema).optional()
     }).optional();
-    ProfileContentSchema = z3.object({
-      title: z3.string().optional(),
-      description: z3.string().optional()
+    ProfileContentSchema = z4.object({
+      title: z4.string().optional(),
+      description: z4.string().optional()
     }).optional();
-    PlanTierSchema = z3.object({
-      name: z3.string(),
-      price: z3.string().optional(),
-      description: z3.string().optional()
+    PlanTierSchema = z4.object({
+      name: z4.string(),
+      price: z4.string().optional(),
+      description: z4.string().optional()
     });
-    PlansContentSchema = z3.object({
-      title: z3.string().optional(),
-      description: z3.string().optional(),
-      tiers: z3.array(PlanTierSchema).optional()
+    PlansContentSchema = z4.object({
+      title: z4.string().optional(),
+      description: z4.string().optional(),
+      tiers: z4.array(PlanTierSchema).optional()
     }).optional();
     SubmodulePageFields = {
-      page: z3.string().optional().describe(
+      page: z4.string().optional().describe(
         "Path to a custom page component file, relative to the project root."
       ),
-      component: z3.custom().optional().describe("Custom React component for this sub-module page.")
+      component: z4.custom().optional().describe("Custom React component for this sub-module page.")
     };
     LandingModuleSchema = ModuleToggleSchema.extend({
-      path: z3.string().default("/").describe("Route path for the landing page."),
-      component: z3.custom().optional().describe("Custom React component for the landing page."),
-      page: z3.string().optional().describe(
+      path: z4.string().default("/").describe("Route path for the landing page."),
+      component: z4.custom().optional().describe("Custom React component for the landing page."),
+      page: z4.string().optional().describe(
         "Path to a custom landing page component file, relative to the project root."
       ),
-      layout: z3.enum(["default", "landing", "none"]).default("landing").describe(
+      layout: z4.enum(["default", "landing", "none"]).default("landing").describe(
         "Layout wrapper: landing (header + footer), default (docs layout), or none."
       ),
       content: LandingContentSchema.describe(
@@ -222,11 +752,11 @@ var init_ModulesSchema = __esm({
       )
     });
     UserManagementModuleSchema = ModuleToggleSchema.extend({
-      routes: z3.object({
-        login: z3.string().default("/signin"),
-        register: z3.string().default("/signup"),
-        profile: z3.string().default("profile"),
-        logout: z3.string().default("/signout")
+      routes: z4.object({
+        login: z4.string().default("/signin"),
+        register: z4.string().default("/signup"),
+        profile: z4.string().default("profile"),
+        logout: z4.string().default("/signout")
       }).partial().optional(),
       page: SubmodulePageFields.page,
       component: SubmodulePageFields.component,
@@ -235,18 +765,30 @@ var init_ModulesSchema = __esm({
       )
     });
     ApiKeysModuleSchema = ModuleToggleSchema.extend({
-      path: z3.string().default("settings/api-keys").describe("Route path for API key management.")
+      path: z4.string().default("settings/api-keys").describe("Route path for API key management.")
+    });
+    PlanCatalogItemSchema = z4.object({
+      sku: z4.string(),
+      displayName: z4.string(),
+      priceAmount: z4.number().default(0),
+      priceCurrency: z4.string().optional(),
+      billingPeriod: z4.string().optional(),
+      limitsJson: z4.string().optional(),
+      includedActionKeys: z4.array(z4.string()).optional()
     });
     PlansModuleSchema = ModuleToggleSchema.extend({
-      path: z3.string().default("plans").describe("Route path for plans and subscription management."),
+      path: z4.string().default("plans").describe("Route path for plans and subscription management."),
       page: SubmodulePageFields.page,
       component: SubmodulePageFields.component,
       content: PlansContentSchema.describe(
         "Default plans page content when no custom component is provided."
+      ),
+      items: z4.array(PlanCatalogItemSchema).optional().describe(
+        "Gateway plan catalog for /pricing preview and publish (canonical storage)."
       )
     });
     DashboardModuleSchema = ModuleToggleSchema.extend({
-      path: z3.string().default("dashboard").describe("Route path for the user dashboard."),
+      path: z4.string().default("dashboard").describe("Route path for the user dashboard."),
       page: SubmodulePageFields.page,
       component: SubmodulePageFields.component,
       content: DashboardContentSchema.describe(
@@ -254,13 +796,13 @@ var init_ModulesSchema = __esm({
       )
     });
     UserPanelModuleSchema = ModuleToggleSchema.extend({
-      basePath: z3.string().default("/account").describe("Base path prefix for user panel routes."),
+      basePath: z4.string().default("/account").describe("Base path prefix for user panel routes."),
       dashboard: DashboardModuleSchema.optional(),
       userManagement: UserManagementModuleSchema.optional(),
       apiKeys: ApiKeysModuleSchema.optional(),
       plans: PlansModuleSchema.optional()
     });
-    ModulesSchema = z3.object({
+    ModulesSchema = z4.object({
       docs: DocsModuleSchema.optional().describe(
         "Documentation module \u2014 MD/MDX pages and OpenAPI reference."
       ),
@@ -359,17 +901,18 @@ var init_resolve_modules = __esm({
       const plansConfig = userPanelModule?.plans;
       const dashboardEnabled = dashboardConfig?.enabled ?? (explicit ? false : false);
       const userManagementEnabled = explicit ? userManagementConfig?.enabled ?? !!config2.authentication : !!config2.authentication;
-      const apiKeysEnabled = explicit ? apiKeysModuleConfig?.enabled ?? config2.apiKeys?.enabled ?? false : config2.apiKeys?.enabled ?? false;
-      const plansEnabled = plansConfig?.enabled ?? false;
+      const apiKeysEnabled = explicit ? apiKeysModuleConfig?.enabled ?? false : false;
+      const billingEnabled = config2.__meta?.pricingEnabled === true || plansConfig?.enabled === true;
+      const plansEnabled = billingEnabled;
       const userPanelEnabled = userPanelModule?.enabled ?? (dashboardEnabled || userManagementEnabled || apiKeysEnabled || plansEnabled);
       const basePath = userPanelModule?.basePath ?? "/account";
       return {
         docs: {
           enabled: docsEnabled,
-          files: docsModule?.files ?? config2.docs?.files,
-          publishMarkdown: docsModule?.publishMarkdown ?? config2.docs?.publishMarkdown,
-          defaultOptions: docsModule?.defaultOptions ?? config2.docs?.defaultOptions,
-          llms: docsModule?.llms ?? config2.docs?.llms
+          files: docsModule?.files,
+          publishMarkdown: docsModule?.publishMarkdown,
+          defaultOptions: docsModule?.defaultOptions,
+          llms: docsModule?.llms
         },
         landing: {
           enabled: landingEnabled,
@@ -409,7 +952,8 @@ var init_resolve_modules = __esm({
           plans: {
             enabled: plansEnabled,
             path: joinPanelPath(basePath, plansConfig?.path ?? "plans"),
-            content: resolvePlansContent(plansConfig?.content)
+            content: resolvePlansContent(plansConfig?.content),
+            items: plansConfig?.items
           }
         }
       };
@@ -563,30 +1107,30 @@ var init_objectEntries = __esm({
 });
 
 // src/vite/shadcn-registry.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var registryItemCssSchema, registryItemSchema, fetchShadcnRegistryItem;
 var init_shadcn_registry = __esm({
   "src/vite/shadcn-registry.ts"() {
-    registryItemCssSchema = z4.record(
-      z4.string(),
-      z4.lazy(
-        () => z4.union([
-          z4.string(),
-          z4.record(
-            z4.string(),
-            z4.union([z4.string(), z4.record(z4.string(), z4.string())])
+    registryItemCssSchema = z5.record(
+      z5.string(),
+      z5.lazy(
+        () => z5.union([
+          z5.string(),
+          z5.record(
+            z5.string(),
+            z5.union([z5.string(), z5.record(z5.string(), z5.string())])
           )
         ])
       )
     );
-    registryItemSchema = z4.object({
-      $schema: z4.literal("https://ui.shadcn.com/schema/registry-item.json"),
-      name: z4.string(),
-      type: z4.enum(["registry:theme", "registry:style"]),
-      cssVars: z4.object({
-        theme: z4.record(z4.string(), z4.string()).optional(),
-        light: z4.record(z4.string(), z4.string()).optional(),
-        dark: z4.record(z4.string(), z4.string()).optional()
+    registryItemSchema = z5.object({
+      $schema: z5.literal("https://ui.shadcn.com/schema/registry-item.json"),
+      name: z5.string(),
+      type: z5.enum(["registry:theme", "registry:style"]),
+      cssVars: z5.object({
+        theme: z5.record(z5.string(), z5.string()).optional(),
+        light: z5.record(z5.string(), z5.string()).optional(),
+        dark: z5.record(z5.string(), z5.string()).optional()
       }).optional(),
       css: registryItemCssSchema.optional()
     });
@@ -603,7 +1147,7 @@ var init_shadcn_registry = __esm({
 });
 
 // src/vite/plugin-theme.ts
-import path2 from "node:path";
+import path4 from "node:path";
 import { normalizeTheme } from "shiki";
 var THEME_VARIABLES, uncamelize, processColorValue, generateCss, generateRegistryCss, processCustomCss, MAIN_REPLACE, DEFAULT_THEME_REPLACE, GOOGLE_FONTS, getGoogleFontUrl, processFont, processFontConfig, processFonts, virtualModuleId, resolvedVirtualModuleId, viteThemePlugin;
 var init_plugin_theme = __esm({
@@ -891,7 +1435,7 @@ ${rootVars.join("\n")}
               config2.__meta.rootDir,
               ...config2.__meta.dependencies,
               ...config2.__pluginDirs ?? []
-            ].map((file) => path2.relative(path2.dirname(id), file))
+            ].map((file) => path4.relative(path4.dirname(id), file))
           );
           const code = [...files].map((file) => `@source "${file}";`);
           code.push("@theme inline {");
@@ -2915,65 +3459,65 @@ var init_icon_types = __esm({
 });
 
 // src/config/validators/InputNavigationSchema.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var IconSchema, BadgeSchema, InputNavigationCategoryLinkDocSchema, DisplaySchema, NavigationModifyRuleSchema, NavigationInsertRuleSchema, NavigationRemoveRuleSchema, NavigationSortRuleSchema, NavigationMoveRuleSchema, NavigationRuleSchema, NavigationRulesSchema, InputNavigationDocSchema, InputNavigationLinkSchema, InputNavigationCustomPageSchema, InputNavigationSeparatorSchema, InputNavigationSectionSchema, InputNavigationFilterSchema, BaseInputNavigationCategorySchema, InputNavigationCategorySchema, InputNavigationItemSchema, InputNavigationSchema;
 var init_InputNavigationSchema = __esm({
   "src/config/validators/InputNavigationSchema.ts"() {
-    IconSchema = z5.custom((f) => typeof f === "string");
-    BadgeSchema = z5.object({
-      label: z5.string(),
+    IconSchema = z6.custom((f) => typeof f === "string");
+    BadgeSchema = z6.object({
+      label: z6.string(),
       // prettier-ignore
-      color: z5.enum(["green", "blue", "yellow", "red", "purple", "indigo", "gray", "outline"]),
-      invert: z5.boolean().optional(),
-      className: z5.string().optional()
+      color: z6.enum(["green", "blue", "yellow", "red", "purple", "indigo", "gray", "outline"]),
+      invert: z6.boolean().optional(),
+      className: z6.string().optional()
     });
-    InputNavigationCategoryLinkDocSchema = z5.union([
-      z5.string(),
-      z5.object({
-        type: z5.literal("doc"),
-        file: z5.string(),
-        label: z5.string().optional(),
-        path: z5.string().optional()
+    InputNavigationCategoryLinkDocSchema = z6.union([
+      z6.string(),
+      z6.object({
+        type: z6.literal("doc"),
+        file: z6.string(),
+        label: z6.string().optional(),
+        path: z6.string().optional()
       })
     ]);
-    DisplaySchema = z5.union([
-      z5.enum(["auth", "anon", "always", "hide"]),
-      z5.custom((val) => typeof val === "function")
+    DisplaySchema = z6.union([
+      z6.enum(["auth", "anon", "always", "hide"]),
+      z6.custom((val) => typeof val === "function")
     ]).optional();
-    NavigationModifyRuleSchema = z5.object({
-      type: z5.literal("modify"),
-      match: z5.string(),
-      set: z5.object({
-        label: z5.string().optional(),
+    NavigationModifyRuleSchema = z6.object({
+      type: z6.literal("modify"),
+      match: z6.string(),
+      set: z6.object({
+        label: z6.string().optional(),
         icon: IconSchema.optional(),
         badge: BadgeSchema.optional(),
-        collapsed: z5.boolean().optional(),
-        collapsible: z5.boolean().optional(),
+        collapsed: z6.boolean().optional(),
+        collapsible: z6.boolean().optional(),
         display: DisplaySchema
       })
     });
-    NavigationInsertRuleSchema = z5.object({
-      type: z5.literal("insert"),
-      match: z5.string(),
-      position: z5.enum(["before", "after"]),
-      items: z5.lazy(() => InputNavigationItemSchema.array())
+    NavigationInsertRuleSchema = z6.object({
+      type: z6.literal("insert"),
+      match: z6.string(),
+      position: z6.enum(["before", "after"]),
+      items: z6.lazy(() => InputNavigationItemSchema.array())
     });
-    NavigationRemoveRuleSchema = z5.object({
-      type: z5.literal("remove"),
-      match: z5.string()
+    NavigationRemoveRuleSchema = z6.object({
+      type: z6.literal("remove"),
+      match: z6.string()
     });
-    NavigationSortRuleSchema = z5.object({
-      type: z5.literal("sort"),
-      match: z5.string(),
-      by: z5.custom((val) => typeof val === "function")
+    NavigationSortRuleSchema = z6.object({
+      type: z6.literal("sort"),
+      match: z6.string(),
+      by: z6.custom((val) => typeof val === "function")
     });
-    NavigationMoveRuleSchema = z5.object({
-      type: z5.literal("move"),
-      match: z5.string(),
-      to: z5.string(),
-      position: z5.enum(["before", "after"])
+    NavigationMoveRuleSchema = z6.object({
+      type: z6.literal("move"),
+      match: z6.string(),
+      to: z6.string(),
+      position: z6.enum(["before", "after"])
     });
-    NavigationRuleSchema = z5.discriminatedUnion("type", [
+    NavigationRuleSchema = z6.discriminatedUnion("type", [
       NavigationModifyRuleSchema,
       NavigationInsertRuleSchema,
       NavigationRemoveRuleSchema,
@@ -2981,65 +3525,65 @@ var init_InputNavigationSchema = __esm({
       NavigationMoveRuleSchema
     ]);
     NavigationRulesSchema = NavigationRuleSchema.array();
-    InputNavigationDocSchema = z5.union([
-      z5.string(),
-      z5.object({
-        type: z5.literal("doc"),
-        file: z5.string(),
+    InputNavigationDocSchema = z6.union([
+      z6.string(),
+      z6.object({
+        type: z6.literal("doc"),
+        file: z6.string(),
         // Custom URL path for this document (overrides file-based path)
-        path: z5.string().optional(),
+        path: z6.string().optional(),
         icon: IconSchema.optional(),
-        label: z5.string().optional(),
+        label: z6.string().optional(),
         badge: BadgeSchema.optional(),
         display: DisplaySchema
       })
     ]);
-    InputNavigationLinkSchema = z5.object({
-      type: z5.literal("link"),
-      to: z5.string(),
-      label: z5.string(),
-      target: z5.enum(["_self", "_blank"]).optional(),
+    InputNavigationLinkSchema = z6.object({
+      type: z6.literal("link"),
+      to: z6.string(),
+      label: z6.string(),
+      target: z6.enum(["_self", "_blank"]).optional(),
       icon: IconSchema.optional(),
       badge: BadgeSchema.optional(),
       display: DisplaySchema
     });
-    InputNavigationCustomPageSchema = z5.object({
-      type: z5.literal("custom-page"),
-      path: z5.string(),
-      label: z5.string().optional(),
-      element: z5.any(),
+    InputNavigationCustomPageSchema = z6.object({
+      type: z6.literal("custom-page"),
+      path: z6.string(),
+      label: z6.string().optional(),
+      element: z6.any(),
       icon: IconSchema.optional(),
       badge: BadgeSchema.optional(),
       display: DisplaySchema,
-      layout: z5.enum(["default", "none"]).optional()
+      layout: z6.enum(["default", "none"]).optional()
     });
-    InputNavigationSeparatorSchema = z5.object({
-      type: z5.literal("separator"),
+    InputNavigationSeparatorSchema = z6.object({
+      type: z6.literal("separator"),
       display: DisplaySchema
     });
-    InputNavigationSectionSchema = z5.object({
-      type: z5.literal("section"),
-      label: z5.string(),
+    InputNavigationSectionSchema = z6.object({
+      type: z6.literal("section"),
+      label: z6.string(),
       display: DisplaySchema
     });
-    InputNavigationFilterSchema = z5.object({
-      type: z5.literal("filter"),
-      placeholder: z5.string().optional(),
+    InputNavigationFilterSchema = z6.object({
+      type: z6.literal("filter"),
+      placeholder: z6.string().optional(),
       display: DisplaySchema
     });
-    BaseInputNavigationCategorySchema = z5.object({
-      type: z5.literal("category"),
+    BaseInputNavigationCategorySchema = z6.object({
+      type: z6.literal("category"),
       icon: IconSchema.optional(),
-      label: z5.string(),
-      collapsible: z5.boolean().optional(),
-      collapsed: z5.boolean().optional(),
+      label: z6.string(),
+      collapsible: z6.boolean().optional(),
+      collapsed: z6.boolean().optional(),
       link: InputNavigationCategoryLinkDocSchema.optional(),
       display: DisplaySchema
     });
     InputNavigationCategorySchema = BaseInputNavigationCategorySchema.extend({
-      items: z5.lazy(() => InputNavigationItemSchema.array())
+      items: z6.lazy(() => InputNavigationItemSchema.array())
     });
-    InputNavigationItemSchema = z5.union([
+    InputNavigationItemSchema = z6.union([
       InputNavigationDocSchema,
       InputNavigationLinkSchema,
       InputNavigationCustomPageSchema,
@@ -3053,39 +3597,39 @@ var init_InputNavigationSchema = __esm({
 });
 
 // src/config/validators/HeaderNavigationSchema.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var IconSchema2, HeaderNavLinkItemSchema, HeaderNavGroupSchema, HeaderNavItemSchema, HeaderNavigationSchema;
 var init_HeaderNavigationSchema = __esm({
   "src/config/validators/HeaderNavigationSchema.ts"() {
     init_icon_types();
     init_InputNavigationSchema();
-    IconSchema2 = z6.enum(IconNames);
-    HeaderNavLinkItemSchema = z6.object({
-      label: z6.string(),
+    IconSchema2 = z7.enum(IconNames);
+    HeaderNavLinkItemSchema = z7.object({
+      label: z7.string(),
       icon: IconSchema2.optional(),
-      description: z6.string().optional(),
-      to: z6.string(),
-      target: z6.enum(["_self", "_blank"]).optional(),
+      description: z7.string().optional(),
+      to: z7.string(),
+      target: z7.enum(["_self", "_blank"]).optional(),
       display: DisplaySchema
     });
-    HeaderNavGroupSchema = z6.object({
-      label: z6.string(),
-      items: z6.array(HeaderNavLinkItemSchema)
+    HeaderNavGroupSchema = z7.object({
+      label: z7.string(),
+      items: z7.array(HeaderNavLinkItemSchema)
     });
-    HeaderNavItemSchema = z6.union([
-      z6.object({
-        label: z6.string(),
+    HeaderNavItemSchema = z7.union([
+      z7.object({
+        label: z7.string(),
         icon: IconSchema2.optional(),
-        to: z6.string(),
-        target: z6.enum(["_self", "_blank"]).optional(),
+        to: z7.string(),
+        target: z7.enum(["_self", "_blank"]).optional(),
         display: DisplaySchema
       }),
-      z6.object({
-        label: z6.string(),
-        items: z6.array(z6.union([HeaderNavLinkItemSchema, HeaderNavGroupSchema]))
+      z7.object({
+        label: z7.string(),
+        items: z7.array(z7.union([HeaderNavLinkItemSchema, HeaderNavGroupSchema]))
       })
     ]);
-    HeaderNavigationSchema = z6.array(HeaderNavItemSchema);
+    HeaderNavigationSchema = z7.array(HeaderNavItemSchema);
   }
 });
 
@@ -3150,23 +3694,23 @@ var init_ZudokuContext = __esm({
 });
 
 // src/config/validators/ProtectedRoutesSchema.ts
-import { z as z7 } from "zod/mini";
+import { z as z8 } from "zod/mini";
 var ProtectedRoutesInputSchema, ProtectedRoutesSchema;
 var init_ProtectedRoutesSchema = __esm({
   "src/config/validators/ProtectedRoutesSchema.ts"() {
     init_ZudokuContext();
-    ProtectedRoutesInputSchema = z7.optional(
-      z7.union([
-        z7.array(z7.string()),
-        z7.record(
-          z7.string(),
-          z7.custom((val) => typeof val === "function")
+    ProtectedRoutesInputSchema = z8.optional(
+      z8.union([
+        z8.array(z8.string()),
+        z8.record(
+          z8.string(),
+          z8.custom((val) => typeof val === "function")
         )
       ])
     );
-    ProtectedRoutesSchema = z7.pipe(
+    ProtectedRoutesSchema = z8.pipe(
       ProtectedRoutesInputSchema,
-      z7.transform(normalizeProtectedRoutes)
+      z8.transform(normalizeProtectedRoutes)
     );
   }
 });
@@ -3184,18 +3728,18 @@ __export(ZudokuConfig_exports, {
 });
 import colors from "picocolors";
 import { isValidElement as isValidElement2 } from "react";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function validateConfig(config2, configPath) {
   const validationResult = ZudokuConfig.safeParse(config2);
   if (!validationResult.success) {
     if (process.env.NODE_ENV === "production") {
       throw new Error(
         `Whoops, looks like there's an issue with your ${configPath ?? "config"}:
-${z8.prettifyError(validationResult.error)}`
+${z9.prettifyError(validationResult.error)}`
       );
     }
     console.log(colors.yellow("Validation errors:"));
-    console.log(colors.yellow(z8.prettifyError(validationResult.error)));
+    console.log(colors.yellow(z9.prettifyError(validationResult.error)));
   }
 }
 var ThemeSchema, ApiCatalogCategorySchema, LanguageOption, AiAssistantCustomSchema, AiAssistantPresets, AiAssistantsSchema, ApiOptionsSchema, ApiConfigSchema, VersionConfigSchema, ApiSchema, ApiKeysSchema, LogoSchema, FooterSocialIcons, FooterSocialSchema, FooterSchema, SiteMapSchema, DEFAULT_DOCS_FILES, LlmsConfigSchema, DocsConfigSchema, Redirect, SearchSchema, AuthenticationSchema, MetadataSchema, FontConfigSchema, FontsConfigSchema, CssObject, ThemeConfigSchema, SiteSchema, PlacementPosition, HeaderConfigSchema, ApiCatalogSchema, CdnUrlSchema, BaseConfigSchema, ZudokuConfig;
@@ -3206,114 +3750,114 @@ var init_ZudokuConfig = __esm({
     init_InputNavigationSchema();
     init_ModulesSchema();
     init_ProtectedRoutesSchema();
-    ThemeSchema = z8.object({
-      background: z8.string(),
-      foreground: z8.string(),
-      card: z8.string(),
-      cardForeground: z8.string(),
-      popover: z8.string(),
-      popoverForeground: z8.string(),
-      primary: z8.string(),
-      primaryForeground: z8.string(),
-      secondary: z8.string(),
-      secondaryForeground: z8.string(),
-      muted: z8.string(),
-      mutedForeground: z8.string(),
-      accent: z8.string(),
-      accentForeground: z8.string(),
-      destructive: z8.string(),
-      destructiveForeground: z8.string(),
-      border: z8.string(),
-      input: z8.string(),
-      ring: z8.string(),
-      radius: z8.string()
+    ThemeSchema = z9.object({
+      background: z9.string(),
+      foreground: z9.string(),
+      card: z9.string(),
+      cardForeground: z9.string(),
+      popover: z9.string(),
+      popoverForeground: z9.string(),
+      primary: z9.string(),
+      primaryForeground: z9.string(),
+      secondary: z9.string(),
+      secondaryForeground: z9.string(),
+      muted: z9.string(),
+      mutedForeground: z9.string(),
+      accent: z9.string(),
+      accentForeground: z9.string(),
+      destructive: z9.string(),
+      destructiveForeground: z9.string(),
+      border: z9.string(),
+      input: z9.string(),
+      ring: z9.string(),
+      radius: z9.string()
     }).partial();
-    ApiCatalogCategorySchema = z8.object({
-      label: z8.string(),
-      tags: z8.array(z8.string())
+    ApiCatalogCategorySchema = z9.object({
+      label: z9.string(),
+      tags: z9.array(z9.string())
     });
-    LanguageOption = z8.object({
-      value: z8.string().min(1),
-      label: z8.string().min(1)
+    LanguageOption = z9.object({
+      value: z9.string().min(1),
+      label: z9.string().min(1)
     });
-    AiAssistantCustomSchema = z8.object({
-      label: z8.string(),
-      icon: z8.custom().optional(),
-      url: z8.union([
-        z8.string(),
-        z8.custom((val) => typeof val === "function")
+    AiAssistantCustomSchema = z9.object({
+      label: z9.string(),
+      icon: z9.custom().optional(),
+      url: z9.union([
+        z9.string(),
+        z9.custom((val) => typeof val === "function")
       ])
     });
     AiAssistantPresets = ["claude", "chatgpt"];
-    AiAssistantsSchema = z8.union([
-      z8.literal(false),
-      z8.array(z8.union([z8.enum(AiAssistantPresets), AiAssistantCustomSchema]))
+    AiAssistantsSchema = z9.union([
+      z9.literal(false),
+      z9.array(z9.union([z9.enum(AiAssistantPresets), AiAssistantCustomSchema]))
     ]).optional();
-    ApiOptionsSchema = z8.object({
-      examplesLanguage: z8.string(),
-      supportedLanguages: z8.array(LanguageOption),
-      disablePlayground: z8.boolean(),
-      disableSidecar: z8.boolean(),
-      showVersionSelect: z8.enum(["always", "if-available", "hide"]),
-      expandAllTags: z8.boolean(),
-      showInfoPage: z8.boolean(),
-      schemaDownload: z8.object({ enabled: z8.boolean() }).partial(),
-      transformExamples: z8.custom(
+    ApiOptionsSchema = z9.object({
+      examplesLanguage: z9.string(),
+      supportedLanguages: z9.array(LanguageOption),
+      disablePlayground: z9.boolean(),
+      disableSidecar: z9.boolean(),
+      showVersionSelect: z9.enum(["always", "if-available", "hide"]),
+      expandAllTags: z9.boolean(),
+      showInfoPage: z9.boolean(),
+      schemaDownload: z9.object({ enabled: z9.boolean() }).partial(),
+      transformExamples: z9.custom(
         (val) => typeof val === "function"
       ),
-      generateCodeSnippet: z8.custom(
+      generateCodeSnippet: z9.custom(
         (val) => typeof val === "function"
       )
     }).partial();
-    ApiConfigSchema = z8.object({
-      server: z8.string(),
-      path: z8.string(),
-      categories: z8.array(ApiCatalogCategorySchema),
+    ApiConfigSchema = z9.object({
+      server: z9.string(),
+      path: z9.string(),
+      categories: z9.array(ApiCatalogCategorySchema),
       options: ApiOptionsSchema
     }).partial();
-    VersionConfigSchema = z8.object({
-      path: z8.string(),
-      input: z8.string(),
-      label: z8.string().optional()
+    VersionConfigSchema = z9.object({
+      path: z9.string(),
+      input: z9.string(),
+      label: z9.string().optional()
     });
-    ApiSchema = z8.discriminatedUnion("type", [
-      z8.object({
-        type: z8.literal("url"),
-        input: z8.union([z8.string(), z8.array(VersionConfigSchema)]),
+    ApiSchema = z9.discriminatedUnion("type", [
+      z9.object({
+        type: z9.literal("url"),
+        input: z9.union([z9.string(), z9.array(VersionConfigSchema)]),
         ...ApiConfigSchema.shape
       }),
-      z8.object({
-        type: z8.literal("file"),
-        input: z8.union([
-          z8.string(),
-          z8.array(z8.union([z8.string(), VersionConfigSchema]))
+      z9.object({
+        type: z9.literal("file"),
+        input: z9.union([
+          z9.string(),
+          z9.array(z9.union([z9.string(), VersionConfigSchema]))
         ]),
         ...ApiConfigSchema.shape
       }),
-      z8.object({
-        type: z8.literal("raw"),
-        input: z8.string(),
+      z9.object({
+        type: z9.literal("raw"),
+        input: z9.string(),
         ...ApiConfigSchema.shape
       })
     ]);
-    ApiKeysSchema = z8.object({
-      enabled: z8.boolean(),
-      getConsumers: z8.custom(
+    ApiKeysSchema = z9.object({
+      enabled: z9.boolean(),
+      getConsumers: z9.custom(
         (val) => typeof val === "function"
       ).optional(),
-      rollKey: z8.custom(
+      rollKey: z9.custom(
         (val) => typeof val === "function"
       ).optional(),
-      deleteKey: z8.custom((val) => typeof val === "function").optional(),
-      updateKeyDescription: z8.custom((val) => typeof val === "function").optional(),
-      createKey: z8.custom((val) => typeof val === "function").optional()
+      deleteKey: z9.custom((val) => typeof val === "function").optional(),
+      updateKeyDescription: z9.custom((val) => typeof val === "function").optional(),
+      createKey: z9.custom((val) => typeof val === "function").optional()
     });
-    LogoSchema = z8.object({
-      src: z8.object({ light: z8.string(), dark: z8.string() }),
-      alt: z8.string().optional(),
-      width: z8.string().or(z8.number()).optional(),
-      href: z8.string().optional(),
-      reloadDocument: z8.boolean().optional()
+    LogoSchema = z9.object({
+      src: z9.object({ light: z9.string(), dark: z9.string() }),
+      alt: z9.string().optional(),
+      width: z9.string().or(z9.number()).optional(),
+      href: z9.string().optional(),
+      reloadDocument: z9.boolean().optional()
     });
     FooterSocialIcons = [
       "reddit",
@@ -3331,38 +3875,38 @@ var init_ZudokuConfig = __esm({
       "whatsapp",
       "telegram"
     ];
-    FooterSocialSchema = z8.object({
-      label: z8.string().optional(),
-      href: z8.string(),
-      icon: z8.union([
-        z8.enum(FooterSocialIcons),
-        z8.custom((val) => isValidElement2(val))
+    FooterSocialSchema = z9.object({
+      label: z9.string().optional(),
+      href: z9.string(),
+      icon: z9.union([
+        z9.enum(FooterSocialIcons),
+        z9.custom((val) => isValidElement2(val))
       ]).optional()
     });
-    FooterSchema = z8.object({
-      columns: z8.array(
-        z8.object({
-          position: z8.enum(["start", "center", "end"]).optional(),
-          title: z8.string(),
-          links: z8.array(z8.object({ label: z8.string(), href: z8.string() }))
+    FooterSchema = z9.object({
+      columns: z9.array(
+        z9.object({
+          position: z9.enum(["start", "center", "end"]).optional(),
+          title: z9.string(),
+          links: z9.array(z9.object({ label: z9.string(), href: z9.string() }))
         })
       ).optional(),
-      social: z8.array(FooterSocialSchema).optional(),
-      copyright: z8.string().optional(),
+      social: z9.array(FooterSocialSchema).optional(),
+      copyright: z9.string().optional(),
       logo: LogoSchema.optional(),
-      position: z8.enum(["start", "center", "end"]).optional()
+      position: z9.enum(["start", "center", "end"]).optional()
     }).optional();
-    SiteMapSchema = z8.object({
+    SiteMapSchema = z9.object({
       /**
        * Base url of your website
        */
-      siteUrl: z8.string(),
+      siteUrl: z9.string(),
       /**
        * Change frequency.
        * @default 'daily'
        */
-      changefreq: z8.optional(
-        z8.enum([
+      changefreq: z9.optional(
+        z9.enum([
           "always",
           "hourly",
           "daily",
@@ -3376,101 +3920,101 @@ var init_ZudokuConfig = __esm({
        * Priority
        * @default 0.7
        */
-      priority: z8.optional(z8.number()),
-      outDir: z8.string().optional(),
+      priority: z9.optional(z9.number()),
+      outDir: z9.string().optional(),
       /**
        * Add <lastmod/> property.
        * @default true
        */
-      autoLastmod: z8.boolean().optional(),
+      autoLastmod: z9.boolean().optional(),
       /**
        * Array of relative paths to exclude from listing on sitemap.xml or sitemap-*.xml.
        * @example ['/page-0', '/page/example']
        */
-      exclude: z8.union([
-        z8.custom((val) => typeof val === "function"),
-        z8.array(z8.string())
+      exclude: z9.union([
+        z9.custom((val) => typeof val === "function"),
+        z9.array(z9.string())
       ]).optional()
     }).optional();
     DEFAULT_DOCS_FILES = "/pages/**/*.{md,mdx}";
-    LlmsConfigSchema = z8.object({
-      llmsTxt: z8.boolean().default(false).describe(
+    LlmsConfigSchema = z9.object({
+      llmsTxt: z9.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: z8.boolean().default(false).describe(
+      llmsTxtFull: z9.boolean().default(false).describe(
         "When enabled, generates an llms-full.txt file with the complete content of all markdown documents for LLM consumption."
       ),
-      includeProtected: z8.boolean().default(false).describe(
+      includeProtected: z9.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."
       )
     }).partial();
-    DocsConfigSchema = z8.object({
-      files: z8.union([z8.string(), z8.array(z8.string())]).transform((val) => typeof val === "string" ? [val] : val).default([DEFAULT_DOCS_FILES]),
-      publishMarkdown: z8.boolean().default(false).describe(
+    DocsConfigSchema = z9.object({
+      files: z9.union([z9.string(), z9.array(z9.string())]).transform((val) => typeof val === "string" ? [val] : val).default([DEFAULT_DOCS_FILES]),
+      publishMarkdown: z9.boolean().default(false).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."
       ),
-      defaultOptions: z8.object({
-        toc: z8.boolean(),
-        copyPage: z8.boolean().optional(),
-        disablePager: z8.boolean(),
-        showLastModified: z8.boolean(),
-        suggestEdit: z8.object({
-          url: z8.string(),
-          text: z8.string().optional()
+      defaultOptions: z9.object({
+        toc: z9.boolean(),
+        copyPage: z9.boolean().optional(),
+        disablePager: z9.boolean(),
+        showLastModified: z9.boolean(),
+        suggestEdit: z9.object({
+          url: z9.string(),
+          text: z9.string().optional()
         }).optional()
       }).partial().optional(),
       llms: LlmsConfigSchema.optional()
     });
-    Redirect = z8.object({
-      from: z8.string(),
-      to: z8.string()
+    Redirect = z9.object({
+      from: z9.string(),
+      to: z9.string()
     });
-    SearchSchema = z8.discriminatedUnion("type", [
+    SearchSchema = z9.discriminatedUnion("type", [
       // looseObject to allow additional properties so the
       // user can set other inkeep settings
-      z8.looseObject({
-        type: z8.literal("inkeep"),
-        apiKey: z8.string(),
-        integrationId: z8.string(),
-        organizationId: z8.string(),
-        primaryBrandColor: z8.string(),
-        organizationDisplayName: z8.string()
+      z9.looseObject({
+        type: z9.literal("inkeep"),
+        apiKey: z9.string(),
+        integrationId: z9.string(),
+        organizationId: z9.string(),
+        primaryBrandColor: z9.string(),
+        organizationDisplayName: z9.string()
       }),
-      z8.object({
-        type: z8.literal("pagefind"),
-        ranking: z8.object({
-          termFrequency: z8.number(),
-          pageLength: z8.number(),
-          termSimilarity: z8.number(),
-          termSaturation: z8.number()
+      z9.object({
+        type: z9.literal("pagefind"),
+        ranking: z9.object({
+          termFrequency: z9.number(),
+          pageLength: z9.number(),
+          termSimilarity: z9.number(),
+          termSaturation: z9.number()
         }).optional(),
-        maxResults: z8.number().optional(),
-        maxSubResults: z8.number().optional(),
-        transformResults: z8.custom((val) => typeof val === "function").optional()
+        maxResults: z9.number().optional(),
+        maxSubResults: z9.number().optional(),
+        transformResults: z9.custom((val) => typeof val === "function").optional()
       })
     ]).optional();
-    AuthenticationSchema = z8.discriminatedUnion("type", [
-      z8.object({
-        type: z8.literal("clerk"),
-        clerkPubKey: z8.custom().refine((val) => /^pk_(test|live)_\w+$/.test(val), {
+    AuthenticationSchema = z9.discriminatedUnion("type", [
+      z9.object({
+        type: z9.literal("clerk"),
+        clerkPubKey: z9.custom().refine((val) => /^pk_(test|live)_\w+$/.test(val), {
           message: "Clerk public key invalid, must start with pk_test or pk_live"
         }),
-        jwtTemplateName: z8.string().optional().default("dev-portal"),
-        redirectToAfterSignUp: z8.string().optional(),
-        redirectToAfterSignIn: z8.string().optional(),
-        redirectToAfterSignOut: z8.string().optional()
+        jwtTemplateName: z9.string().optional().default("dev-portal"),
+        redirectToAfterSignUp: z9.string().optional(),
+        redirectToAfterSignIn: z9.string().optional(),
+        redirectToAfterSignOut: z9.string().optional()
       }),
-      z8.object({
-        type: z8.literal("firebase"),
-        apiKey: z8.string(),
-        authDomain: z8.string(),
-        projectId: z8.string(),
-        storageBucket: z8.string().optional(),
-        messagingSenderId: z8.string().optional(),
-        appId: z8.string(),
-        measurementId: z8.string().optional(),
-        providers: z8.array(
-          z8.enum([
+      z9.object({
+        type: z9.literal("firebase"),
+        apiKey: z9.string(),
+        authDomain: z9.string(),
+        projectId: z9.string(),
+        storageBucket: z9.string().optional(),
+        messagingSenderId: z9.string().optional(),
+        appId: z9.string(),
+        measurementId: z9.string().optional(),
+        providers: z9.array(
+          z9.enum([
             "google",
             "facebook",
             "twitter",
@@ -3483,37 +4027,37 @@ var init_ZudokuConfig = __esm({
             "emailLink"
           ])
         ).optional(),
-        redirectToAfterSignUp: z8.string().optional(),
-        redirectToAfterSignIn: z8.string().optional(),
-        redirectToAfterSignOut: z8.string().optional()
+        redirectToAfterSignUp: z9.string().optional(),
+        redirectToAfterSignIn: z9.string().optional(),
+        redirectToAfterSignOut: z9.string().optional()
       }),
-      z8.object({
-        type: z8.literal("openid"),
-        basePath: z8.string().optional(),
-        clientId: z8.string(),
-        issuer: z8.string(),
-        audience: z8.string().optional(),
-        scopes: z8.array(z8.string()).optional(),
-        redirectToAfterSignUp: z8.string().optional(),
-        redirectToAfterSignIn: z8.string().optional(),
-        redirectToAfterSignOut: z8.string().optional()
+      z9.object({
+        type: z9.literal("openid"),
+        basePath: z9.string().optional(),
+        clientId: z9.string(),
+        issuer: z9.string(),
+        audience: z9.string().optional(),
+        scopes: z9.array(z9.string()).optional(),
+        redirectToAfterSignUp: z9.string().optional(),
+        redirectToAfterSignIn: z9.string().optional(),
+        redirectToAfterSignOut: z9.string().optional()
       }),
-      z8.object({
-        type: z8.literal("azureb2c"),
-        basePath: z8.string().optional(),
-        clientId: z8.string(),
-        tenantName: z8.string(),
-        policyName: z8.string(),
-        scopes: z8.array(z8.string()).optional(),
-        issuer: z8.string(),
-        redirectToAfterSignUp: z8.string().optional(),
-        redirectToAfterSignIn: z8.string().optional(),
-        redirectToAfterSignOut: z8.string().optional()
+      z9.object({
+        type: z9.literal("azureb2c"),
+        basePath: z9.string().optional(),
+        clientId: z9.string(),
+        tenantName: z9.string(),
+        policyName: z9.string(),
+        scopes: z9.array(z9.string()).optional(),
+        issuer: z9.string(),
+        redirectToAfterSignUp: z9.string().optional(),
+        redirectToAfterSignIn: z9.string().optional(),
+        redirectToAfterSignOut: z9.string().optional()
       }),
-      z8.object({
-        type: z8.literal("auth0"),
-        clientId: z8.string(),
-        domain: z8.string().refine(
+      z9.object({
+        type: z9.literal("auth0"),
+        clientId: z9.string(),
+        domain: z9.string().refine(
           (val) => {
             if (val.startsWith("http://") || val.startsWith("https://")) {
               return false;
@@ -3527,116 +4071,116 @@ var init_ZudokuConfig = __esm({
             message: "Domain must be a host only (e.g., 'example.com') without protocol or slashes"
           }
         ),
-        audience: z8.string().optional(),
-        scopes: z8.array(z8.string()).optional(),
-        redirectToAfterSignUp: z8.string().optional(),
-        redirectToAfterSignIn: z8.string().optional(),
-        redirectToAfterSignOut: z8.string().optional(),
-        options: z8.object({
-          alwaysPromptLogin: z8.boolean().optional(),
-          prompt: z8.string().optional()
+        audience: z9.string().optional(),
+        scopes: z9.array(z9.string()).optional(),
+        redirectToAfterSignUp: z9.string().optional(),
+        redirectToAfterSignIn: z9.string().optional(),
+        redirectToAfterSignOut: z9.string().optional(),
+        options: z9.object({
+          alwaysPromptLogin: z9.boolean().optional(),
+          prompt: z9.string().optional()
         }).optional()
       }),
-      z8.object({
-        type: z8.literal("supabase"),
-        basePath: z8.string().optional(),
-        supabaseUrl: z8.string(),
-        supabaseKey: z8.string(),
-        provider: z8.string().optional(),
-        providers: z8.array(z8.string()).optional(),
-        onlyThirdPartyProviders: z8.boolean().optional(),
-        redirectToAfterSignUp: z8.string().optional(),
-        redirectToAfterSignIn: z8.string().optional(),
-        redirectToAfterSignOut: z8.string().optional()
+      z9.object({
+        type: z9.literal("supabase"),
+        basePath: z9.string().optional(),
+        supabaseUrl: z9.string(),
+        supabaseKey: z9.string(),
+        provider: z9.string().optional(),
+        providers: z9.array(z9.string()).optional(),
+        onlyThirdPartyProviders: z9.boolean().optional(),
+        redirectToAfterSignUp: z9.string().optional(),
+        redirectToAfterSignIn: z9.string().optional(),
+        redirectToAfterSignOut: z9.string().optional()
       }),
-      z8.object({
-        type: z8.literal("dev-portal"),
-        apiBaseUrl: z8.string().optional(),
-        redirectToAfterSignUp: z8.string().optional(),
-        redirectToAfterSignIn: z8.string().optional(),
-        redirectToAfterSignOut: z8.string().optional()
+      z9.object({
+        type: z9.literal("dev-portal"),
+        apiBaseUrl: z9.string().optional(),
+        redirectToAfterSignUp: z9.string().optional(),
+        redirectToAfterSignIn: z9.string().optional(),
+        redirectToAfterSignOut: z9.string().optional()
       })
     ]);
-    MetadataSchema = z8.object({
-      title: z8.string(),
-      defaultTitle: z8.string().optional(),
-      description: z8.string(),
-      logo: z8.string(),
-      favicon: z8.string(),
-      generator: z8.string(),
-      applicationName: z8.string(),
-      referrer: z8.string(),
-      keywords: z8.array(z8.string()),
-      authors: z8.array(z8.string()),
-      creator: z8.string(),
-      publisher: z8.string()
+    MetadataSchema = z9.object({
+      title: z9.string(),
+      defaultTitle: z9.string().optional(),
+      description: z9.string(),
+      logo: z9.string(),
+      favicon: z9.string(),
+      generator: z9.string(),
+      applicationName: z9.string(),
+      referrer: z9.string(),
+      keywords: z9.array(z9.string()),
+      authors: z9.array(z9.string()),
+      creator: z9.string(),
+      publisher: z9.string()
     }).partial();
-    FontConfigSchema = z8.union([
-      z8.enum(GOOGLE_FONTS),
-      z8.object({
-        url: z8.string(),
-        fontFamily: z8.string().optional()
+    FontConfigSchema = z9.union([
+      z9.enum(GOOGLE_FONTS),
+      z9.object({
+        url: z9.string(),
+        fontFamily: z9.string().optional()
       })
     ]);
-    FontsConfigSchema = z8.object({
+    FontsConfigSchema = z9.object({
       sans: FontConfigSchema.optional(),
       serif: FontConfigSchema.optional(),
       mono: FontConfigSchema.optional()
     });
-    CssObject = z8.record(
-      z8.string(),
-      z8.lazy(
-        () => z8.union([
-          z8.string(),
-          z8.record(
-            z8.string(),
-            z8.union([z8.string(), z8.record(z8.string(), z8.string())])
+    CssObject = z9.record(
+      z9.string(),
+      z9.lazy(
+        () => z9.union([
+          z9.string(),
+          z9.record(
+            z9.string(),
+            z9.union([z9.string(), z9.record(z9.string(), z9.string())])
           )
         ])
       )
     );
-    ThemeConfigSchema = z8.object({
-      registryUrl: z8.string().url().optional(),
-      customCss: z8.union([z8.string(), CssObject]).optional(),
+    ThemeConfigSchema = z9.object({
+      registryUrl: z9.string().url().optional(),
+      customCss: z9.union([z9.string(), CssObject]).optional(),
       light: ThemeSchema.optional(),
       dark: ThemeSchema.optional(),
       fonts: FontsConfigSchema.optional(),
-      noDefaultTheme: z8.boolean().optional()
+      noDefaultTheme: z9.boolean().optional()
     });
-    SiteSchema = z8.object({
-      title: z8.string(),
-      logoUrl: z8.string(),
-      dir: z8.enum(["ltr", "rtl"]).optional(),
+    SiteSchema = z9.object({
+      title: z9.string(),
+      logoUrl: z9.string(),
+      dir: z9.enum(["ltr", "rtl"]).optional(),
       logo: LogoSchema,
-      banner: z8.object({
-        message: z8.custom(),
-        color: z8.custom(
+      banner: z9.object({
+        message: z9.custom(),
+        color: z9.custom(
           (val) => typeof val === "string"
         ).optional(),
-        dismissible: z8.boolean().optional()
+        dismissible: z9.boolean().optional()
       }),
       footer: FooterSchema
     }).partial();
-    PlacementPosition = z8.enum(["start", "center", "end"]);
-    HeaderConfigSchema = z8.object({
+    PlacementPosition = z9.enum(["start", "center", "end"]);
+    HeaderConfigSchema = z9.object({
       navigation: HeaderNavigationSchema,
-      placements: z8.object({
+      placements: z9.object({
         navigation: PlacementPosition,
         search: PlacementPosition,
-        auth: z8.enum(["start", "center", "end", "navigation"])
+        auth: z9.enum(["start", "center", "end", "navigation"])
       }).partial().optional()
     }).partial();
-    ApiCatalogSchema = z8.object({
-      path: z8.string(),
-      label: z8.string(),
-      items: z8.array(z8.string()).optional(),
-      filterItems: z8.custom((val) => typeof val === "function").optional()
+    ApiCatalogSchema = z9.object({
+      path: z9.string(),
+      label: z9.string(),
+      items: z9.array(z9.string()).optional(),
+      filterItems: z9.custom((val) => typeof val === "function").optional()
     });
-    CdnUrlSchema = z8.union([
-      z8.string(),
-      z8.object({
-        base: z8.string().optional(),
-        media: z8.string().optional()
+    CdnUrlSchema = z9.union([
+      z9.string(),
+      z9.object({
+        base: z9.string().optional(),
+        media: z9.string().optional()
       })
     ]).transform((val) => {
       if (typeof val === "string") {
@@ -3644,45 +4188,45 @@ var init_ZudokuConfig = __esm({
       }
       return { base: val.base, media: val.media };
     }).optional();
-    BaseConfigSchema = z8.object({
-      slots: z8.record(z8.string(), z8.custom()),
+    BaseConfigSchema = z9.object({
+      slots: z9.record(z9.string(), z9.custom()),
       /**
        * @deprecated Use `slots` instead
        */
-      UNSAFE_slotlets: z8.record(z8.string(), z8.custom()),
-      mdx: z8.object({
-        components: z8.custom()
+      UNSAFE_slotlets: z9.record(z9.string(), z9.custom()),
+      mdx: z9.object({
+        components: z9.custom()
       }).partial(),
-      customPages: z8.array(
-        z8.object({
-          path: z8.string(),
-          element: z8.custom().optional(),
-          render: z8.custom().optional(),
-          prose: z8.boolean().optional()
+      customPages: z9.array(
+        z9.object({
+          path: z9.string(),
+          element: z9.custom().optional(),
+          render: z9.custom().optional(),
+          prose: z9.boolean().optional()
         })
       ),
-      plugins: z8.array(z8.custom()),
-      build: z8.custom(),
+      plugins: z9.array(z9.custom()),
+      build: z9.custom(),
       protectedRoutes: ProtectedRoutesSchema,
-      basePath: z8.string().optional(),
-      canonicalUrlOrigin: z8.string().optional(),
+      basePath: z9.string().optional(),
+      canonicalUrlOrigin: z9.string().optional(),
       cdnUrl: CdnUrlSchema.optional(),
-      port: z8.number().optional(),
-      https: z8.object({
-        key: z8.string(),
-        cert: z8.string(),
-        ca: z8.string().optional()
+      port: z9.number().optional(),
+      https: z9.object({
+        key: z9.string(),
+        cert: z9.string(),
+        ca: z9.string().optional()
       }).optional(),
       site: SiteSchema,
       header: HeaderConfigSchema.optional(),
       navigation: InputNavigationSchema,
       navigationRules: NavigationRulesSchema.optional(),
       theme: ThemeConfigSchema,
-      syntaxHighlighting: z8.object({
-        languages: z8.array(z8.custom()),
-        themes: z8.object({
-          light: z8.custom(),
-          dark: z8.custom()
+      syntaxHighlighting: z9.object({
+        languages: z9.array(z9.custom()),
+        themes: z9.object({
+          light: z9.custom(),
+          dark: z9.custom()
         })
       }).partial().optional(),
       metadata: MetadataSchema,
@@ -3690,22 +4234,22 @@ var init_ZudokuConfig = __esm({
       search: SearchSchema,
       docs: DocsConfigSchema.optional(),
       modules: ModulesSchema,
-      apis: z8.union([ApiSchema, z8.array(ApiSchema)]),
-      catalogs: z8.union([ApiCatalogSchema, z8.array(ApiCatalogSchema)]),
+      apis: z9.union([ApiSchema, z9.array(ApiSchema)]),
+      catalogs: z9.union([ApiCatalogSchema, z9.array(ApiCatalogSchema)]),
       apiKeys: ApiKeysSchema,
       aiAssistants: AiAssistantsSchema,
-      redirects: z8.array(Redirect),
+      redirects: z9.array(Redirect),
       sitemap: SiteMapSchema,
-      enableStatusPages: z8.boolean().optional(),
-      defaults: z8.object({
+      enableStatusPages: z9.boolean().optional(),
+      defaults: z9.object({
         apis: ApiOptionsSchema,
         /**
          * @deprecated Use `apis.examplesLanguage` or `defaults.apis.examplesLanguage` instead
          */
-        examplesLanguage: z8.string().optional()
+        examplesLanguage: z9.string().optional()
       }),
       // Internal: populated by plugins via `transformConfig` to track plugin directories
-      __pluginDirs: z8.array(z8.string())
+      __pluginDirs: z9.array(z9.string())
     });
     ZudokuConfig = BaseConfigSchema.partial();
   }
@@ -3713,7 +4257,7 @@ var init_ZudokuConfig = __esm({
 
 // src/config/loader.ts
 import { stat as stat2 } from "node:fs/promises";
-import path3 from "node:path";
+import path5 from "node:path";
 import colors2 from "picocolors";
 import {
   runnerImport,
@@ -3721,7 +4265,7 @@ import {
 } from "vite";
 async function getConfigFilePath(rootDir) {
   for (const fileName of zudokuConfigFiles) {
-    const filepath = path3.join(rootDir, fileName);
+    const filepath = path5.join(rootDir, fileName);
     if (await fileExists(filepath)) {
       return filepath;
     }
@@ -3791,8 +4335,16 @@ function isWatchableConfigDependency(depPath) {
   return !depPath.startsWith("\0virtual:") && !depPath.startsWith("virtual:");
 }
 function getWatchableConfigDependencies(config2) {
+  const manifestEnv = resolveManifestEnv(
+    config2.__meta.mode === "production" ? "production" : "development"
+  );
+  const { watchPaths } = manifestPathsForEnv(
+    config2.__meta.rootDir,
+    manifestEnv
+  );
   return [
     config2.__meta.configPath,
+    ...watchPaths,
     ...config2.__meta.dependencies.filter(isWatchableConfigDependency)
   ];
 }
@@ -3802,6 +4354,9 @@ async function hasConfigChanged() {
   try {
     const hasChanged = await Promise.all(
       files.map(async (depPath) => {
+        if (!await fileExists(depPath)) {
+          return false;
+        }
         const depStat = await stat2(depPath);
         const cachedMtime = modifiedTimes?.get(depPath);
         return !cachedMtime || depStat.mtimeMs !== cachedMtime;
@@ -3818,6 +4373,9 @@ async function updateModifiedTimes() {
   modifiedTimes = /* @__PURE__ */ new Map();
   await Promise.all(
     files.map(async (depPath) => {
+      if (!await fileExists(depPath)) {
+        return;
+      }
       const depStat = await stat2(depPath);
       modifiedTimes?.set(depPath, depStat.mtimeMs);
     })
@@ -3831,9 +4389,31 @@ async function loadZudokuConfig(configEnv, rootDir) {
   ({ publicEnv, envPrefix } = loadEnv(configEnv, rootDir));
   try {
     const loadedConfig = await loadZudokuConfigWithMeta(rootDir);
-    const transformedConfig = await runPluginTransformConfig(loadedConfig);
+    const manifestEnv = resolveManifestEnv(configEnv.mode);
+    const manifest = await readEffectiveManifest(rootDir, manifestEnv);
+    const previewCatalog = manifestToPreviewCatalog(manifest);
+    const jsonConfig = loadApitogoConfig(rootDir);
+    const previewPlans = previewCatalog.plans.length ? previewCatalog.plans : plansToPreviewCatalog(
+      readPlanCatalogItems(jsonConfig)
+    ).plans;
+    const configWithManifestMeta = {
+      ...loadedConfig,
+      __meta: {
+        ...loadedConfig.__meta,
+        pricingEnabled: isBillingEnabled(jsonConfig),
+        authenticationEnabled: isAuthenticationEnabled(manifest),
+        previewPlans
+      }
+    };
+    const transformedConfig = applyAuthenticationHeaderNav(
+      await runPluginTransformConfig(configWithManifestMeta)
+    );
     config = {
       ...transformedConfig,
+      __meta: {
+        ...transformedConfig.__meta,
+        ...configWithManifestMeta.__meta
+      },
       __resolvedModules: resolveModulesConfig(transformedConfig)
     };
     if (!process.env.APITOGO_JSON_ONLY) {
@@ -3858,9 +4438,12 @@ var init_loader = __esm({
   "src/config/loader.ts"() {
     init_logger();
     init_package_json();
+    init_auth_header_nav();
     init_transform_config();
     init_invariant();
+    init_apitogo_config_loader();
     init_file_exists();
+    init_local_manifest();
     init_resolve_modules();
     init_ZudokuConfig();
     zudokuConfigFiles = [
@@ -3898,7 +4481,7 @@ __export(llms_exports, {
   generateLlmsTxtFiles: () => generateLlmsTxtFiles
 });
 import { writeFile as writeFile4 } from "node:fs/promises";
-import path25 from "node:path";
+import path26 from "node:path";
 import colors6 from "picocolors";
 async function generateLlmsTxtFiles({
   markdownFileInfos,
@@ -3933,7 +4516,7 @@ async function generateLlmsTxtFiles({
       }
     }
     const llmsTxt2 = llmsTxtParts.join("\n");
-    await writeFile4(path25.join(baseOutputDir, "llms.txt"), llmsTxt2, "utf-8");
+    await writeFile4(path26.join(baseOutputDir, "llms.txt"), llmsTxt2, "utf-8");
     if (process.env.APITOGO_JSON_ONLY !== "1") {
       console.log(colors6.blue("\u2713 generated llms.txt"));
     }
@@ -3961,7 +4544,7 @@ ${info.content}
     }
     const llmsFull = llmsFullParts.join("\n");
     await writeFile4(
-      path25.join(baseOutputDir, "llms-full.txt"),
+      path26.join(baseOutputDir, "llms-full.txt"),
       llmsFull,
       "utf-8"
     );
@@ -3982,11 +4565,11 @@ import { hideBin } from "yargs/helpers";
 import yargs from "yargs/yargs";
 
 // src/cli/build/handler.ts
-import path29 from "node:path";
+import path30 from "node:path";
 
 // src/vite/build.ts
-import { mkdir as mkdir5, readFile as readFile4, rename, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
-import path27 from "node:path";
+import { mkdir as mkdir5, readFile as readFile3, rename, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
+import path28 from "node:path";
 import { build as esbuild } from "esbuild";
 import { build as viteBuild, mergeConfig as mergeConfig3 } from "vite";
 
@@ -4122,7 +4705,7 @@ init_invariant();
 init_joinUrl();
 
 // src/vite/config.ts
-import path22 from "node:path";
+import path23 from "node:path";
 import dotenv from "dotenv";
 import colors4 from "picocolors";
 import {
@@ -4133,7 +4716,7 @@ import {
 // package.json
 var package_default = {
   name: "@lukoweb/apitogo",
-  version: "0.1.50",
+  version: "0.1.53",
   type: "module",
   sideEffects: [
     "**/*.css",
@@ -4202,7 +4785,9 @@ var package_default = {
     "./processors/*": "./src/lib/plugins/openapi/processors/*.ts",
     "./with-zuplo": "./src/zuplo/with-zuplo.ts",
     "./testing": "./src/lib/testing/index.tsx",
-    "./local-manifest": "./src/config/local-manifest.ts"
+    "./local-manifest": "./src/config/local-manifest.ts",
+    "./build-config": "./src/config/build-apitogo-config.ts",
+    "./config-loader": "./src/config/apitogo-config-loader.ts"
   },
   scripts: {
     build: "esbuild src/cli/cli.ts src/vite/prerender/worker.ts --outdir=dist/cli --entry-names=[name] --bundle --format=esm --packages=external --target=node20 --platform=node --log-level=error",
@@ -4516,6 +5101,14 @@ var package_default = {
       "./local-manifest": {
         types: "./dist/declarations/config/local-manifest.d.ts",
         default: "./src/config/local-manifest.ts"
+      },
+      "./build-config": {
+        types: "./dist/declarations/config/build-apitogo-config.d.ts",
+        default: "./src/config/build-apitogo-config.ts"
+      },
+      "./config-loader": {
+        types: "./dist/declarations/config/apitogo-config-loader.d.ts",
+        default: "./src/config/apitogo-config-loader.ts"
       }
     }
   }
@@ -4530,36 +5123,38 @@ init_joinUrl();
 
 // src/vite/dev-portal-env.ts
 import { loadEnv as loadEnv2 } from "vite";
+var AUTHENTICATION_API_BASE_URL_ENV = "VITE_APITOGO_AUTHENTICATION_API_BASE_URL";
+var LEGACY_DEV_PORTAL_API_URL_ENV = "VITE_APITOGO_DEV_PORTAL_API_URL";
 async function loadDevPortalViteDefines(rootDir, mode) {
   const env = loadEnv2(mode, rootDir, "VITE_");
   const defines = {};
-  const apiUrl = env.VITE_APITOGO_DEV_PORTAL_API_URL?.trim();
+  const apiUrl = env[AUTHENTICATION_API_BASE_URL_ENV]?.trim() || env[LEGACY_DEV_PORTAL_API_URL_ENV]?.trim();
   if (apiUrl) {
-    defines.VITE_APITOGO_DEV_PORTAL_API_URL = JSON.stringify(apiUrl);
+    defines[AUTHENTICATION_API_BASE_URL_ENV] = JSON.stringify(apiUrl);
   }
   return defines;
 }
 
 // src/vite/package-root.ts
 init_file_exists();
-import path4 from "node:path";
+import path6 from "node:path";
 var findPackageRoot = async (startDir) => {
   let dir = startDir;
-  while (dir !== path4.dirname(dir)) {
-    if (await fileExists(path4.join(dir, "package.json"))) return dir;
-    dir = path4.dirname(dir);
+  while (dir !== path6.dirname(dir)) {
+    if (await fileExists(path6.join(dir, "package.json"))) return dir;
+    dir = path6.dirname(dir);
   }
 };
 
 // src/vite/pagefind-dev-stub.ts
 import fs from "node:fs/promises";
-import path5 from "node:path";
+import path7 from "node:path";
 var NOT_BUILT_YET = 'throw new Error("NOT_BUILT_YET");';
 async function ensurePagefindDevStub(publicDir) {
-  const pagefindPath = path5.join(publicDir, "pagefind/pagefind.js");
+  const pagefindPath = path7.join(publicDir, "pagefind/pagefind.js");
   const exists = await fs.stat(pagefindPath).catch(() => false);
   if (!exists) {
-    await fs.mkdir(path5.dirname(pagefindPath), { recursive: true });
+    await fs.mkdir(path7.dirname(pagefindPath), { recursive: true });
     await fs.writeFile(pagefindPath, NOT_BUILT_YET);
   }
 }
@@ -4571,7 +5166,7 @@ import react from "@vitejs/plugin-react";
 // src/vite/css/plugin.ts
 init_loader();
 init_plugin_theme();
-import path6 from "node:path";
+import path8 from "node:path";
 import { isCSSRequest as isCSSRequest2 } from "vite";
 
 // src/vite/css/collect.ts
@@ -4606,7 +5201,7 @@ var VIRTUAL_ENTRY = "virtual:ssr-css.css";
 function vitePluginSsrCss(pluginOpts) {
   let server;
   const config2 = getCurrentConfig();
-  const virtualHref = path6.join(
+  const virtualHref = path8.join(
     config2.basePath ?? "",
     `/@id/__x00__${VIRTUAL_ENTRY}?direct`
   );
@@ -4743,7 +5338,7 @@ var plugin_api_keys_default = viteApiKeysPlugin;
 
 // src/vite/plugin-api.ts
 import fs3 from "node:fs/promises";
-import path12 from "node:path";
+import path14 from "node:path";
 import { deepEqual as deepEqual2 } from "fast-equals";
 import { runnerImport as runnerImport3 } from "vite";
 init_package_json();
@@ -4752,20 +5347,20 @@ init_loader();
 // src/config/validators/BuildSchema.ts
 init_file_exists();
 init_loader();
-import path7 from "node:path";
+import path9 from "node:path";
 import { runnerImport as runnerImport2 } from "vite";
-import { z as z9 } from "zod";
-var BuildProcessorSchema = z9.custom((val) => typeof val === "function");
-var PluginConfigSchema = z9.custom().or(
-  z9.custom(
+import { z as z10 } from "zod";
+var BuildProcessorSchema = z10.custom((val) => typeof val === "function");
+var PluginConfigSchema = z10.custom().or(
+  z10.custom(
     (val) => typeof val === "function"
   )
 );
-var BuildConfigSchema2 = z9.object({
-  processors: z9.array(BuildProcessorSchema).optional(),
+var BuildConfigSchema2 = z10.object({
+  processors: z10.array(BuildProcessorSchema).optional(),
   remarkPlugins: PluginConfigSchema.optional(),
   rehypePlugins: PluginConfigSchema.optional(),
-  prerender: z9.object({ workers: z9.number().optional() }).optional()
+  prerender: z10.object({ workers: z10.number().optional() }).optional()
 });
 var buildConfigFiles = [
   "apitogo.build.js",
@@ -4781,7 +5376,7 @@ var buildConfigFiles = [
 ];
 async function getBuildConfigFilePath(rootDir) {
   for (const fileName of buildConfigFiles) {
-    const filepath = path7.join(rootDir, fileName);
+    const filepath = path9.join(rootDir, fileName);
     if (await fileExists(filepath)) {
       return filepath;
     }
@@ -4803,10 +5398,10 @@ function validateBuildConfig(config2) {
   const validationResult = BuildConfigSchema2.safeParse(config2);
   if (!validationResult.success) {
     if (process.env.NODE_ENV === "production") {
-      throw new Error(z9.prettifyError(validationResult.error));
+      throw new Error(z10.prettifyError(validationResult.error));
     }
     console.warn("Build config validation errors:");
-    console.warn(z9.prettifyError(validationResult.error));
+    console.warn(z10.prettifyError(validationResult.error));
     return;
   }
   return validationResult.data;
@@ -4890,14 +5485,14 @@ var flattenAllOf = (schema2) => {
 };
 
 // src/lib/util/traverse.ts
-var traverse = (specification, transform, path38 = []) => {
-  const transformed = transform(specification, path38);
+var traverse = (specification, transform, path39 = []) => {
+  const transformed = transform(specification, path39);
   if (typeof transformed !== "object" || transformed === null) {
     return transformed;
   }
   const result = Array.isArray(transformed) ? [] : {};
   for (const [key, value] of Object.entries(transformed)) {
-    const currentPath = [...path38, key];
+    const currentPath = [...path39, key];
     if (Array.isArray(value)) {
       result[key] = value.map(
         (item, index) => typeof item === "object" && item != null ? traverse(item, transform, [...currentPath, index.toString()]) : item
@@ -4925,9 +5520,9 @@ var resolveLocalRef = (schema2, ref) => {
   if (schemaCache?.has(ref)) {
     return schemaCache.get(ref);
   }
-  const path38 = ref.split("/").slice(1);
+  const path39 = ref.split("/").slice(1);
   let current = schema2;
-  for (const segment of path38) {
+  for (const segment of path39) {
     if (!current || typeof current !== "object") {
       current = null;
     }
@@ -4946,7 +5541,7 @@ var dereference = async (schema2, resolvers = []) => {
   }
   const cloned = structuredClone(schema2);
   const visited = /* @__PURE__ */ new Set();
-  const resolve = async (current, path38) => {
+  const resolve = async (current, path39) => {
     if (isIndexableObject(current)) {
       if (visited.has(current)) {
         return CIRCULAR_REF;
@@ -4954,7 +5549,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], `${path38}/${index}`);
+          current[index] = await resolve(current[index], `${path39}/${index}`);
         }
       } else {
         if ("$ref" in current && typeof current.$ref === "string") {
@@ -4965,13 +5560,13 @@ var dereference = async (schema2, resolvers = []) => {
           for (const resolver of resolvers) {
             const resolved = await resolver($ref);
             if (resolved) {
-              result2 = await resolve(resolved, path38);
+              result2 = await resolve(resolved, path39);
               break;
             }
           }
           if (result2 === void 0) {
             const resolved = await resolveLocalRef(cloned, $ref);
-            result2 = await resolve(resolved, path38);
+            result2 = await resolve(resolved, path39);
           }
           if (hasSiblings) {
             if (result2 === CIRCULAR_REF) {
@@ -4984,7 +5579,7 @@ var dereference = async (schema2, resolvers = []) => {
           return result2;
         }
         for (const key in current) {
-          current[key] = await resolve(current[key], `${path38}/${key}`);
+          current[key] = await resolve(current[key], `${path39}/${key}`);
         }
       }
       visited.delete(current);
@@ -5023,9 +5618,9 @@ var upgradeSchema = (schema2) => {
     }
     return sub;
   });
-  schema2 = traverse(schema2, (sub, path38) => {
+  schema2 = traverse(schema2, (sub, path39) => {
     if (sub.example !== void 0) {
-      if (isSchemaPath(path38 ?? [])) {
+      if (isSchemaPath(path39 ?? [])) {
         sub.examples = [sub.example];
       } else {
         sub.examples = {
@@ -5038,11 +5633,11 @@ var upgradeSchema = (schema2) => {
     }
     return sub;
   });
-  schema2 = traverse(schema2, (schema3, path38) => {
+  schema2 = traverse(schema2, (schema3, path39) => {
     if (schema3.type === "object" && schema3.properties !== void 0) {
-      const parentPath = path38?.slice(0, -1);
+      const parentPath = path39?.slice(0, -1);
       const isMultipart = parentPath?.some((segment, index) => {
-        return segment === "content" && path38?.[index + 1] === "multipart/form-data";
+        return segment === "content" && path39?.[index + 1] === "multipart/form-data";
       });
       if (isMultipart) {
         const entries = Object.entries(schema3.properties);
@@ -5056,8 +5651,8 @@ var upgradeSchema = (schema2) => {
     }
     return schema3;
   });
-  schema2 = traverse(schema2, (schema3, path38) => {
-    if (path38?.includes("content") && path38.includes("application/octet-stream")) {
+  schema2 = traverse(schema2, (schema3, path39) => {
+    if (path39?.includes("content") && path39.includes("application/octet-stream")) {
       return {};
     }
     if (schema3.type === "string" && schema3.format === "binary") {
@@ -5083,11 +5678,11 @@ var upgradeSchema = (schema2) => {
     }
     return sub;
   });
-  schema2 = traverse(schema2, (schema3, path38) => {
+  schema2 = traverse(schema2, (schema3, path39) => {
     if (schema3.type === "string" && schema3.format === "byte") {
-      const parentPath = path38?.slice(0, -1);
+      const parentPath = path39?.slice(0, -1);
       const contentMediaType = parentPath?.find(
-        (_, index) => path38?.[index - 1] === "content"
+        (_, index) => path39?.[index - 1] === "content"
       );
       return {
         type: "string",
@@ -5099,7 +5694,7 @@ var upgradeSchema = (schema2) => {
   });
   return schema2;
 };
-function isSchemaPath(path38) {
+function isSchemaPath(path39) {
   const schemaLocations = [
     ["components", "schemas"],
     "properties",
@@ -5112,10 +5707,10 @@ function isSchemaPath(path38) {
   ];
   return schemaLocations.some((location) => {
     if (Array.isArray(location)) {
-      return location.every((segment, index) => path38[index] === segment);
+      return location.every((segment, index) => path39[index] === segment);
     }
-    return path38.includes(location);
-  }) || path38.includes("schema") || path38.some((segment) => segment.endsWith("Schema"));
+    return path39.includes(location);
+  }) || path39.includes("schema") || path39.some((segment) => segment.endsWith("Schema"));
 }
 
 // src/lib/oas/parser/index.ts
@@ -5197,13 +5792,13 @@ var OPENAPI_PROPS = /* @__PURE__ */ new Set([
   "anyOf",
   "oneOf"
 ]);
-var handleCircularRefs = (obj, currentPath = /* @__PURE__ */ new WeakSet(), refs = /* @__PURE__ */ new WeakMap(), path38 = [], currentRefPaths = /* @__PURE__ */ new Set()) => {
+var handleCircularRefs = (obj, currentPath = /* @__PURE__ */ new WeakSet(), refs = /* @__PURE__ */ new WeakMap(), path39 = [], 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 = path38.find((p) => !OPENAPI_PROPS.has(p)) || path38[0];
+    const circularProp = path39.find((p) => !OPENAPI_PROPS.has(p)) || path39[0];
     return [CIRCULAR_REF, circularProp].filter(Boolean).join(":");
   }
   if (refs.has(obj)) return refs.get(obj);
@@ -5213,7 +5808,7 @@ var handleCircularRefs = (obj, currentPath = /* @__PURE__ */ new WeakSet(), refs
     value,
     currentPath,
     refs,
-    [...path38, key],
+    [...path39, key],
     currentRefPaths
   );
   const result = Array.isArray(obj) ? obj.map((item, i) => recurse(item, i.toString())) : Object.fromEntries(
@@ -5248,7 +5843,7 @@ var resolveExtensions = (obj) => Object.fromEntries(
 var getAllTags = (schema2) => {
   const rootTags = schema2.tags ?? [];
   const operations = Object.values(schema2.paths ?? {}).flatMap(
-    (path38) => HttpMethods.map((k) => path38?.[k]).filter((op) => op != null)
+    (path39) => HttpMethods.map((k) => path39?.[k]).filter((op) => op != null)
   );
   const operationTags = new Set(operations.flatMap((op) => op.tags ?? []));
   const hasUntaggedOperations = operations.some(
@@ -5303,7 +5898,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(
-    ([path38, value]) => HttpMethods.flatMap((method) => {
+    ([path39, value]) => HttpMethods.flatMap((method) => {
       if (!value?.[method]) return [];
       const operation = value[method];
       const pathParameters = value.parameters ?? [];
@@ -5323,7 +5918,7 @@ var getAllOperations = (paths) => {
       return {
         ...operation,
         method,
-        path: path38,
+        path: path39,
         parameters,
         servers,
         tags: operation.tags ?? []
@@ -5681,8 +6276,8 @@ var Schema = builder.objectRef("Schema").implement({
     }),
     paths: t.field({
       type: [PathItem],
-      resolve: (root) => Object.entries(root.paths ?? {}).map(([path38, value]) => ({
-        path: path38,
+      resolve: (root) => Object.entries(root.paths ?? {}).map(([path39, value]) => ({
+        path: path39,
         // biome-ignore lint/style/noNonNullAssertion: value is guaranteed to be defined
         methods: Object.keys(value)
       }))
@@ -5777,7 +6372,7 @@ var ensureArray = (value) => Array.isArray(value) ? value : [value];
 
 // src/vite/api/SchemaManager.ts
 import fs2 from "node:fs/promises";
-import path8 from "node:path";
+import path10 from "node:path";
 import {
   $RefParser as $RefParser2
 } from "@apidevtools/json-schema-ref-parser";
@@ -5829,7 +6424,7 @@ init_joinUrl();
 
 // src/vite/api/schema-codegen.ts
 var unescapeJsonPointer = (uri) => decodeURIComponent(uri.replace(/~1/g, "/").replace(/~0/g, "~"));
-var getSegmentsFromPath = (path38) => path38.split("/").slice(1).map(unescapeJsonPointer);
+var getSegmentsFromPath = (path39) => path39.split("/").slice(1).map(unescapeJsonPointer);
 var createLocalRefMap = (obj) => {
   const refMap = /* @__PURE__ */ new Map();
   const siblingsMap = /* @__PURE__ */ new Map();
@@ -5860,16 +6455,16 @@ var replaceMarkers = (code, mergedRefs) => code.replace(/"__refMap:(.*?)"/g, '__
   /"__refMap\+Siblings:(.*?)"/g,
   (_, key) => mergedRefs.get(key) ?? `__refMap["${key}"]`
 );
-var lookup = (schema2, path38, filePath) => {
-  const parts = getSegmentsFromPath(path38);
+var lookup = (schema2, path39, filePath) => {
+  const parts = getSegmentsFromPath(path39);
   let val = schema2;
   for (const part of parts) {
     while (val.$ref?.startsWith("#/")) {
-      val = val.$ref === path38 ? val : lookup(schema2, val.$ref, filePath);
+      val = val.$ref === path39 ? 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: ${path38}`
+        `Error in ${filePath ?? "code generation"}: Could not find path segment ${part} in path: ${path39}`
       );
     }
     val = val[part];
@@ -5967,18 +6562,18 @@ var SchemaManager = class {
     ];
   }
   getPathForFile = (input, params) => {
-    const filePath = path8.resolve(this.config.__meta.rootDir, input);
+    const filePath = path10.resolve(this.config.__meta.rootDir, input);
     const apis = ensureArray(this.config.apis ?? []);
     for (const apiConfig of apis) {
       if (!apiConfig || apiConfig.type !== "file" || !apiConfig.path) continue;
       const match = normalizeInputs(apiConfig.input).some(
-        (i) => path8.resolve(this.config.__meta.rootDir, i.input) === filePath && deepEqual(i.params, params)
+        (i) => path10.resolve(this.config.__meta.rootDir, i.input) === filePath && deepEqual(i.params, params)
       );
       if (match) return apiConfig.path;
     }
   };
   processSchema = async (input) => {
-    const filePath = path8.resolve(this.config.__meta.rootDir, input.input);
+    const filePath = path10.resolve(this.config.__meta.rootDir, input.input);
     const params = input.params;
     const configuredPath = this.getPathForFile(input.input, params);
     if (!configuredPath) {
@@ -6014,9 +6609,9 @@ var SchemaManager = class {
     const processedTime = Date.now();
     const code = generateCode(processedSchema, filePath);
     const prefixPath = slugify(configuredPath);
-    const processedFilePath = path8.posix.join(
+    const processedFilePath = path10.posix.join(
       this.storeDir,
-      `${prefixPath}-${path8.basename(filePath)}${paramsSuffix(params)}.js`
+      `${prefixPath}-${path10.basename(filePath)}${paramsSuffix(params)}.js`
     );
     const importKey = processedFilePath;
     await fs2.writeFile(processedFilePath, code);
@@ -6065,7 +6660,7 @@ var SchemaManager = class {
   };
   getAllTrackedFiles = () => Array.from(this.referencedBy.keys());
   getFilesToReprocess = (changedFile) => {
-    const resolvedPath = path8.resolve(this.config.__meta.rootDir, changedFile);
+    const resolvedPath = path10.resolve(this.config.__meta.rootDir, changedFile);
     const referencedBy = this.referencedBy.get(resolvedPath);
     if (!referencedBy) return [];
     const filesToProcess = referencedBy.size === 0 ? [resolvedPath] : Array.from(referencedBy);
@@ -6094,7 +6689,7 @@ var SchemaManager = class {
         version: "",
         path: input.path ?? "",
         label: input.label,
-        inputPath: path8.resolve(this.config.__meta.rootDir, input.input),
+        inputPath: path10.resolve(this.config.__meta.rootDir, input.input),
         params: input.params,
         importKey: "",
         downloadUrl: "",
@@ -6114,8 +6709,8 @@ var SchemaManager = class {
       }
     }
   };
-  getLatestSchema = (path38) => this.processedSchemas[path38]?.at(0);
-  getSchemasForPath = (path38) => this.processedSchemas[path38];
+  getLatestSchema = (path39) => this.processedSchemas[path39]?.at(0);
+  getSchemasForPath = (path39) => this.processedSchemas[path39];
   getSchemaImports = () => Object.values(this.processedSchemas).flat().filter((s) => s.importKey);
   getUrlToFilePathMap = () => {
     const map = /* @__PURE__ */ new Map();
@@ -6137,7 +6732,7 @@ var SchemaManager = class {
   };
   createSchemaPath = (inputPath, versionPath, apiPath, params) => {
     const suffix = paramsSuffix(params);
-    const extension = suffix ? ".json" : path8.extname(inputPath);
+    const extension = suffix ? ".json" : path10.extname(inputPath);
     return joinUrl(
       this.config.basePath,
       apiPath,
@@ -6160,7 +6755,7 @@ var SchemaManager = class {
 // src/vite/plugin-config-reload.ts
 init_logger();
 init_loader();
-import path11 from "node:path";
+import path13 from "node:path";
 import colors3 from "picocolors";
 
 // src/vite/plugin-navigation.ts
@@ -6170,7 +6765,7 @@ import { stringify as stringify3 } from "javascript-stringify";
 import { isElement } from "react-is";
 
 // src/config/validators/NavigationSchema.ts
-import path9 from "node:path";
+import path11 from "node:path";
 import { glob } from "glob";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { mdxFromMarkdown } from "mdast-util-mdx";
@@ -6221,7 +6816,7 @@ var extractRichH1 = (content) => {
   }
 };
 var isNavigationItem = (item) => item !== void 0;
-var toPosixPath = (filePath) => filePath.split(path9.win32.sep).join(path9.posix.sep);
+var toPosixPath = (filePath) => filePath.split(path11.win32.sep).join(path11.posix.sep);
 var NavigationResolver = class {
   rootDir;
   globPatterns;
@@ -6354,13 +6949,13 @@ init_invariant();
 
 // src/vite/debug.ts
 import { mkdir, writeFile } from "node:fs/promises";
-import path10 from "node:path";
+import path12 from "node:path";
 async function writePluginDebugCode(rootDir, pluginName, code, extension = "js") {
   if (process.env.ZUDOKU_BUILD_DEBUG) {
-    const debugDir = path10.join(rootDir, "dist", "debug");
+    const debugDir = path12.join(rootDir, "dist", "debug");
     await mkdir(debugDir, { recursive: true });
     await writeFile(
-      path10.join(debugDir, `${pluginName}.${extension}`),
+      path12.join(debugDir, `${pluginName}.${extension}`),
       typeof code === "string" ? code : code.join("\n")
     );
   }
@@ -6471,7 +7066,7 @@ var viteConfigReloadPlugin = () => ({
       });
       logger.info(
         colors3.blue(
-          `Config ${path11.basename(currentConfig.__meta.configPath)} changed. Reloading...`
+          `Config ${path13.basename(currentConfig.__meta.configPath)} changed. Reloading...`
         ),
         { timestamp: true }
       );
@@ -6485,11 +7080,11 @@ var viteApiPlugin = async () => {
   const resolvedVirtualModuleId5 = `\0${virtualModuleId4}`;
   const initialConfig = getCurrentConfig();
   const zuploProcessors = ZuploEnv.isZuplo ? await runnerImport3(
-    path12.resolve(getZudokuRootDir(), "src/zuplo/with-zuplo-processors.ts")
+    path14.resolve(getZudokuRootDir(), "src/zuplo/with-zuplo-processors.ts")
   ).then((m) => m.module.default(initialConfig.__meta.rootDir)) : [];
   const buildConfig = await getBuildConfig();
   const buildProcessors = buildConfig?.processors ?? [];
-  const tmpStoreDir = path12.posix.join(
+  const tmpStoreDir = path14.posix.join(
     initialConfig.__meta.rootDir,
     "node_modules/.apitogo/processed"
   );
@@ -6517,7 +7112,7 @@ var viteApiPlugin = async () => {
         const inputPath = pathMap.get(req.url);
         if (!inputPath) return next();
         const content = await fs3.readFile(inputPath, "utf-8");
-        const mimeType = path12.extname(inputPath).toLowerCase() === ".json" ? "application/json" : "application/x-yaml";
+        const mimeType = path14.extname(inputPath).toLowerCase() === ".json" ? "application/json" : "application/x-yaml";
         res.setHeader("Content-Type", `${mimeType}; charset=utf-8`);
         return res.end(content);
       });
@@ -6705,8 +7300,8 @@ var viteApiPlugin = async () => {
       if (process.env.NODE_ENV !== "production") return;
       for (const [urlPath, inputPath] of pathMap) {
         const content = await fs3.readFile(inputPath, "utf-8");
-        const outputPath = path12.join(config2.__meta.rootDir, "dist", urlPath);
-        await fs3.mkdir(path12.dirname(outputPath), { recursive: true });
+        const outputPath = path14.join(config2.__meta.rootDir, "dist", urlPath);
+        await fs3.mkdir(path14.dirname(outputPath), { recursive: true });
         await fs3.writeFile(outputPath, content, "utf-8");
       }
     }
@@ -6749,7 +7344,7 @@ var plugin_auth_default = viteAuthPlugin;
 
 // src/vite/plugin-component.ts
 init_loader();
-import path13 from "node:path";
+import path15 from "node:path";
 var viteAliasPlugin = () => {
   return {
     name: "zudoku-component-plugin",
@@ -6777,7 +7372,7 @@ var viteAliasPlugin = () => {
       ];
       const aliases = replacements.map(([find, replacement]) => ({
         find,
-        replacement: path13.posix.join(config2.__meta.moduleDir, replacement)
+        replacement: path15.posix.join(config2.__meta.moduleDir, replacement)
       }));
       return config2.__meta.mode === "internal" || config2.__meta.mode === "standalone" ? { resolve: { alias: aliases } } : void 0;
     }
@@ -6801,17 +7396,33 @@ var viteConfigPlugin = () => {
     configResolved(resolvedConfig) {
       viteConfig = resolvedConfig;
     },
-    load(id) {
+    async load(id) {
       if (id !== resolvedVirtualModuleId3) return;
       const configPath = getCurrentConfig().__meta.configPath;
       if (!configPath) {
         return `export default {};`;
       }
+      const { config: loadedConfig } = await loadZudokuConfig(
+        {
+          mode: viteConfig.mode,
+          command: viteConfig.command
+        },
+        viteConfig.root
+      );
+      const clientMeta = {
+        rootDir: loadedConfig.__meta.rootDir,
+        pricingEnabled: loadedConfig.__meta.pricingEnabled,
+        authenticationEnabled: loadedConfig.__meta.authenticationEnabled,
+        previewPlans: loadedConfig.__meta.previewPlans
+      };
       return `
 import rawConfig from "${normalizePath(configPath)}";
 import { runPluginTransformConfig } from "@lukoweb/apitogo/plugins";
 
-const config = await runPluginTransformConfig(rawConfig);
+const config = await runPluginTransformConfig({
+  ...rawConfig,
+  __meta: ${JSON.stringify(clientMeta)},
+});
 export default config;
 `;
     },
@@ -6914,7 +7525,7 @@ var viteDocMetadataPlugin = () => ({
 
 // src/vite/plugin-docs.ts
 init_loader();
-import path14 from "node:path";
+import path16 from "node:path";
 import { glob as glob3 } from "glob";
 import globParent from "glob-parent";
 init_ZudokuConfig();
@@ -6983,7 +7594,7 @@ var globMarkdownFiles = async (config2, options = { absolute: false }) => {
     if (process.env.NODE_ENV !== "development") {
       const draftStatuses = await Promise.all(
         globbedFiles.map(async (file) => {
-          const absolutePath = path14.resolve(config2.__meta.rootDir, file);
+          const absolutePath = path16.resolve(config2.__meta.rootDir, file);
           const { data } = await readFrontmatter(absolutePath);
           return { file, isDraft: data.draft === true };
         })
@@ -6996,9 +7607,9 @@ var globMarkdownFiles = async (config2, options = { absolute: false }) => {
       if (draftFiles.has(file)) {
         continue;
       }
-      const relativePath = path14.posix.relative(parent, file);
+      const relativePath = path16.posix.relative(parent, file);
       const routePath = ensureLeadingSlash(relativePath.replace(/\.mdx?$/, ""));
-      const filePath = options.absolute ? path14.resolve(config2.__meta.rootDir, file) : file;
+      const filePath = options.absolute ? path16.resolve(config2.__meta.rootDir, file) : file;
       fileMapping[routePath] = filePath;
     }
   }
@@ -7062,7 +7673,7 @@ var viteDocsPlugin = () => {
       const globbedDocuments = {};
       for (const [routePath, file] of Object.entries(fileMapping)) {
         const importPath = ensureLeadingSlash(
-          path14.posix.join(globImportBasePath, file)
+          path16.posix.join(globImportBasePath, file)
         );
         globbedDocuments[routePath] = importPath;
       }
@@ -7086,212 +7697,9 @@ var viteDocsPlugin = () => {
 var plugin_docs_default = viteDocsPlugin;
 
 // src/vite/plugin-local-manifest.ts
-import path16 from "node:path";
-
-// src/config/local-manifest.ts
-import { access, readFile as readFile2 } from "node:fs/promises";
-import path15 from "node:path";
-import { z as z10 } from "zod";
-var DEV_PORTAL_MANIFEST_FILENAME = "apitogo.local.json";
-var APITOGO_MANIFEST_BASE_FILENAME = "apitogo.json";
-var APITOGO_MANIFEST_ENV_FILES = {
-  development: "apitogo.local.json",
-  production: "apitogo.prod.json"
-};
-var BillingPeriodSchema = z10.enum(["month", "year", "monthly", "annual"]);
-var ManifestPlanInputSchema = z10.object({
-  sku: z10.string().min(1),
-  displayName: z10.string().min(1),
-  isFree: z10.boolean(),
-  priceAmount: z10.number().optional(),
-  priceCurrency: z10.string().optional(),
-  billingPeriod: BillingPeriodSchema.optional(),
-  limitsJson: z10.string().optional(),
-  includedActionKeys: z10.array(z10.string()).optional()
-});
-var DevPortalLocalManifestSchema = z10.object({
-  siteName: z10.string().optional(),
-  branding: z10.object({
-    title: z10.string().optional(),
-    logoUrl: z10.string().optional()
-  }).optional(),
-  pricing: z10.object({
-    enabled: z10.boolean().optional()
-  }).optional(),
-  plans: z10.array(ManifestPlanInputSchema).optional(),
-  backend: z10.object({
-    sourceDirectory: z10.string().optional(),
-    publishDirectory: z10.string().optional(),
-    openApiPath: z10.string().optional(),
-    runtime: z10.string().optional(),
-    runtimeVersion: z10.string().optional(),
-    deployed: z10.boolean().optional()
-  }).optional(),
-  gateway: z10.object({
-    authMode: z10.enum(["platformManagedEntra", "bringYourOwnOidc"]).optional(),
-    oidcMetadataUrl: z10.string().optional(),
-    oidcAllowedIssuers: z10.array(z10.string()).optional(),
-    oidcAudiences: z10.array(z10.string()).optional(),
-    limitsJson: z10.string().optional(),
-    publicHealthActionKey: z10.string().optional()
-  }).optional(),
-  projectId: z10.string().optional(),
-  projectName: z10.string().optional()
-});
-function isPricingEnabled(manifest) {
-  return manifest?.pricing?.enabled === true;
-}
-function manifestToPreviewCatalog(manifest) {
-  const plans = manifest?.plans;
-  const catalog = plansToPreviewCatalog(plans);
-  return {
-    pricingEnabled: isPricingEnabled(manifest),
-    plans: catalog.plans
-  };
-}
-function normalizeBillingPeriod(period) {
-  if (!period) {
-    return "monthly";
-  }
-  const normalized = period.toLowerCase();
-  if (normalized === "month") {
-    return "monthly";
-  }
-  if (normalized === "year") {
-    return "annual";
-  }
-  return normalized;
-}
-function plansToPreviewCatalog(plans) {
-  if (!plans?.length) {
-    return { plans: [] };
-  }
-  return {
-    plans: plans.map((plan) => ({
-      sku: plan.sku,
-      displayName: plan.displayName,
-      isFree: plan.isFree,
-      priceAmount: plan.priceAmount ?? 0,
-      priceCurrency: plan.priceCurrency ?? "usd",
-      billingPeriod: normalizeBillingPeriod(plan.billingPeriod),
-      limitsJson: plan.limitsJson ?? null,
-      includedActionKeys: plan.includedActionKeys ?? []
-    }))
-  };
-}
-function resolveManifestEnv(viteMode) {
-  return viteMode === "production" ? "production" : "development";
-}
-function mergePlansBySku(existing, patch) {
-  const bySku = /* @__PURE__ */ new Map();
-  for (const plan of existing ?? []) {
-    bySku.set(plan.sku, plan);
-  }
-  for (const plan of patch) {
-    const prior = bySku.get(plan.sku);
-    bySku.set(plan.sku, prior ? { ...prior, ...plan } : plan);
-  }
-  return Array.from(bySku.values());
-}
-function mergeManifest(base, override) {
-  const merged = { ...base, ...override };
-  if (override.branding) {
-    merged.branding = { ...base.branding, ...override.branding };
-  }
-  if (override.pricing) {
-    merged.pricing = { ...base.pricing, ...override.pricing };
-  }
-  if (override.backend) {
-    merged.backend = { ...base.backend, ...override.backend };
-  }
-  if (override.gateway) {
-    merged.gateway = { ...base.gateway, ...override.gateway };
-  }
-  if (override.plans) {
-    merged.plans = mergePlansBySku(base.plans, override.plans);
-  }
-  return merged;
-}
-function manifestFilePath(rootDir, filename) {
-  return path15.join(
-    path15.resolve(rootDir),
-    filename ?? DEV_PORTAL_MANIFEST_FILENAME
-  );
-}
-function manifestPathsForEnv(rootDir, env) {
-  const resolvedRoot = path15.resolve(rootDir);
-  const basePath = path15.join(resolvedRoot, APITOGO_MANIFEST_BASE_FILENAME);
-  const overridePath = path15.join(resolvedRoot, APITOGO_MANIFEST_ENV_FILES[env]);
-  return {
-    basePath,
-    overridePath,
-    watchPaths: [basePath, overridePath]
-  };
-}
-function parseLocalManifestJson(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    const result = DevPortalLocalManifestSchema.safeParse(parsed);
-    if (!result.success) {
-      return null;
-    }
-    return result.data;
-  } catch {
-    return null;
-  }
-}
-async function fileExists2(filePath) {
-  try {
-    await access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function readManifestFile(rootDir, filename) {
-  const filePath = manifestFilePath(rootDir, filename);
-  try {
-    const raw = await readFile2(filePath, "utf8");
-    return parseLocalManifestJson(raw);
-  } catch {
-    return null;
-  }
-}
-async function readEffectiveManifest(rootDir, env) {
-  const { basePath, overridePath } = manifestPathsForEnv(rootDir, env);
-  const hasBase = await fileExists2(basePath);
-  const hasOverride = await fileExists2(overridePath);
-  if (!hasBase) {
-    const legacy = await readManifestFile(
-      rootDir,
-      APITOGO_MANIFEST_ENV_FILES.development
-    );
-    if (legacy) {
-      return legacy;
-    }
-    if (hasOverride) {
-      return readManifestFile(rootDir, APITOGO_MANIFEST_ENV_FILES[env]);
-    }
-    return null;
-  }
-  const base = await readManifestFile(rootDir, APITOGO_MANIFEST_BASE_FILENAME);
-  if (!base) {
-    return null;
-  }
-  if (!hasOverride) {
-    return base;
-  }
-  const override = await readManifestFile(
-    rootDir,
-    APITOGO_MANIFEST_ENV_FILES[env]
-  );
-  if (!override) {
-    return base;
-  }
-  return mergeManifest(base, override);
-}
-
-// src/vite/plugin-local-manifest.ts
+init_apitogo_config_loader();
+init_local_manifest();
+import path17 from "node:path";
 var APITOGO_LOCAL_MANIFEST_VIRTUAL_ID = "virtual:apitogo-local-manifest";
 var resolvedVirtualModuleId4 = `\0${APITOGO_LOCAL_MANIFEST_VIRTUAL_ID}`;
 var viteLocalManifestPlugin = () => {
@@ -7304,6 +7712,15 @@ var viteLocalManifestPlugin = () => {
     try {
       const manifest = await readEffectiveManifest(rootDir, env);
       catalog = manifestToPreviewCatalog(manifest);
+      if (!catalog.plans.length) {
+        const config2 = loadApitogoConfig(rootDir);
+        catalog = {
+          ...catalog,
+          ...plansToPreviewCatalog(
+            readPlanCatalogItems(config2)
+          )
+        };
+      }
     } catch {
     }
     return `export default ${JSON.stringify(catalog)};`;
@@ -7332,8 +7749,8 @@ var viteLocalManifestPlugin = () => {
         server.watcher.add(watchPath);
       }
       server.watcher.on("change", async (changedPath) => {
-        const resolvedChanged = path16.resolve(changedPath);
-        if (!watchPaths.some((p) => path16.resolve(p) === resolvedChanged)) {
+        const resolvedChanged = path17.resolve(changedPath);
+        if (!watchPaths.some((p) => path17.resolve(p) === resolvedChanged)) {
           return;
         }
         const module = server.moduleGraph.getModuleById(
@@ -7360,7 +7777,7 @@ init_loader();
 init_ProtectedRoutesSchema();
 init_joinUrl();
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 import { matchPath } from "react-router";
 var processMarkdownFile = async (filePath) => {
   const { content: markdownContent, data: frontmatter } = await readFrontmatter(filePath);
@@ -7448,7 +7865,7 @@ var viteMarkdownExportPlugin = () => {
       if (process.env.NODE_ENV !== "production" || Object.keys(markdownFiles).length === 0 || !needsMdFiles) {
         return;
       }
-      const distDir = path17.join(
+      const distDir = path18.join(
         config2.__meta.rootDir,
         "dist",
         config2.basePath ?? ""
@@ -7469,15 +7886,15 @@ var viteMarkdownExportPlugin = () => {
             content: finalMarkdown
           });
           const segments = routePath === "/" ? ["index"] : routePath.split("/").filter(Boolean);
-          const outputPath = `${path17.join(distDir, ...segments)}.md`;
-          await mkdir2(path17.dirname(outputPath), { recursive: true });
+          const outputPath = `${path18.join(distDir, ...segments)}.md`;
+          await mkdir2(path18.dirname(outputPath), { recursive: true });
           await writeFile2(outputPath, finalMarkdown, "utf-8");
         } catch (error) {
           console.warn(`Failed to export markdown for ${routePath}:`, error);
         }
       }
       if (config2.docs?.llms?.llmsTxt || config2.docs?.llms?.llmsTxtFull) {
-        const markdownInfoPath = path17.join(
+        const markdownInfoPath = path18.join(
           config2.__meta.rootDir,
           "node_modules/.apitogo/markdown-info.json"
         );
@@ -7629,9 +8046,9 @@ var remarkCodeTabs = () => (tree) => {
 };
 
 // src/vite/mdx/remark-inject-filepath.ts
-import path18 from "node:path";
+import path19 from "node:path";
 var remarkInjectFilepath = (rootDir) => (tree, vfile) => {
-  const relativePath = path18.relative(rootDir, vfile.path).split(path18.sep).join(path18.posix.sep);
+  const relativePath = path19.relative(rootDir, vfile.path).split(path19.sep).join(path19.posix.sep);
   tree.children.unshift(exportMdxjsConst("__filepath", relativePath));
 };
 
@@ -7718,18 +8135,18 @@ var remarkLastModified = () => {
 };
 
 // src/vite/mdx/remark-link-rewrite.ts
-import path19 from "node:path";
+import path20 from "node:path";
 import { visit as visit5 } from "unist-util-visit";
 var remarkLinkRewrite = (basePath = "") => (tree) => {
   visit5(tree, "link", (node) => {
     if (!node.url) return;
     if (node.url.startsWith("http") || node.url.startsWith("mailto:")) return;
     node.url = node.url.replace(/\\/g, "/");
-    const base = path19.posix.join(basePath);
+    const base = path20.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 = path19.posix.join("..", node.url);
+      node.url = path20.posix.join("..", node.url);
     }
     node.url = node.url.replace(/\.mdx?(#.*)?$/, "$1");
   });
@@ -7949,11 +8366,11 @@ var plugin_mdx_default = viteMdxPlugin;
 
 // src/vite/plugin-modules.ts
 init_loader();
-import path20 from "node:path";
+import path21 from "node:path";
 import { normalizePath as normalizePath2 } from "vite";
-var getLandingModuleImport = (moduleDir, mode) => mode === "internal" ? normalizePath2(path20.join(moduleDir, "../module-landing/src/index.tsx")) : "@lukoweb/apitogo-module-landing";
-var getUserPanelModuleImport = (moduleDir, mode) => mode === "internal" ? normalizePath2(path20.join(moduleDir, "../module-user-panel/src/index.tsx")) : "@lukoweb/apitogo-module-user-panel";
-var resolveProjectPageImport = (rootDir, pagePath) => normalizePath2(path20.resolve(rootDir, pagePath));
+var getLandingModuleImport = (moduleDir, mode) => mode === "internal" ? normalizePath2(path21.join(moduleDir, "../module-landing/src/index.tsx")) : "@lukoweb/apitogo-module-landing";
+var getUserPanelModuleImport = (moduleDir, mode) => mode === "internal" ? normalizePath2(path21.join(moduleDir, "../module-user-panel/src/index.tsx")) : "@lukoweb/apitogo-module-user-panel";
+var resolveProjectPageImport = (rootDir, pagePath) => normalizePath2(path21.resolve(rootDir, pagePath));
 var viteModulesPlugin = () => {
   const virtualModuleId4 = "virtual:zudoku-modules-plugin";
   const resolvedVirtualModuleId5 = `\0${virtualModuleId4}`;
@@ -8074,7 +8491,7 @@ var plugin_modules_default = viteModulesPlugin;
 
 // src/vite/plugin-search.ts
 init_loader();
-import path21 from "node:path";
+import path22 from "node:path";
 var viteSearchPlugin = () => {
   const virtualModuleId4 = "virtual:zudoku-search-plugin";
   const resolvedVirtualModuleId5 = `\0${virtualModuleId4}`;
@@ -8092,7 +8509,7 @@ var viteSearchPlugin = () => {
         return resolvedVirtualModuleId5;
       }
       if (id === "/pagefind/pagefind.js" && resolvedViteConfig?.publicDir) {
-        return path21.join(resolvedViteConfig.publicDir, "pagefind/pagefind.js");
+        return path22.join(resolvedViteConfig.publicDir, "pagefind/pagefind.js");
       }
     },
     async load(id) {
@@ -8234,10 +8651,10 @@ function vitePlugin() {
 var resolveMergedPublicDir = (rootDir, merged) => {
   if (merged.publicDir === false) return void 0;
   const rel = typeof merged.publicDir === "string" ? merged.publicDir : "public";
-  return path22.resolve(rootDir, rel);
+  return path23.resolve(rootDir, rel);
 };
-var getAppClientEntryPath = () => path22.posix.join(getZudokuRootDir(), "src/app/entry.client.tsx");
-var getAppServerEntryPath = () => path22.posix.join(getZudokuRootDir(), "src/app/entry.server.tsx");
+var getAppClientEntryPath = () => path23.posix.join(getZudokuRootDir(), "src/app/entry.client.tsx");
+var getAppServerEntryPath = () => path23.posix.join(getZudokuRootDir(), "src/app/entry.server.tsx");
 var hasLoggedCdnInfo = false;
 var MEDIA_REGEX = /\.(a?png|jpe?g|gif|bmp|svg|webp|tiff|ico|webm|ogg|mp3|wav|m4a|avif|mp4)/i;
 var defineEnvVars = (vars) => Object.fromEntries(
@@ -8267,7 +8684,7 @@ async function getViteConfig(dir, configEnv) {
   );
   if (ZuploEnv.isZuplo) {
     dotenv.config({
-      path: path22.resolve(config2.__meta.rootDir, "../.env.zuplo"),
+      path: path23.resolve(config2.__meta.rootDir, "../.env.zuplo"),
       quiet: true
     });
   }
@@ -8326,8 +8743,8 @@ async function getViteConfig(dir, configEnv) {
       ssr: configEnv.isSsrBuild,
       sourcemap: true,
       target: "es2022",
-      outDir: path22.resolve(
-        path22.join(
+      outDir: path23.resolve(
+        path23.join(
           dir,
           "dist",
           config2.basePath ?? "",
@@ -8346,7 +8763,7 @@ async function getViteConfig(dir, configEnv) {
     },
     experimental: {
       renderBuiltUrl(filename) {
-        if (cdnUrl?.base && [".js", ".css"].includes(path22.extname(filename))) {
+        if (cdnUrl?.base && [".js", ".css"].includes(path23.extname(filename))) {
           return joinUrl(cdnUrl.base, filename);
         }
         if (cdnUrl?.media && MEDIA_REGEX.test(filename)) {
@@ -8359,7 +8776,7 @@ async function getViteConfig(dir, configEnv) {
       esbuildOptions: {
         target: "es2022"
       },
-      entries: [path22.posix.join(getZudokuRootDir(), "src/{app,lib}/**")],
+      entries: [path23.posix.join(getZudokuRootDir(), "src/{app,lib}/**")],
       exclude: [
         "@lukoweb/apitogo",
         "@lukoweb/apitogo-plugin-dev-portal-billing"
@@ -8465,7 +8882,7 @@ init_package_json();
 init_joinUrl();
 import assert from "node:assert";
 import { cp, mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import path23 from "node:path";
+import path24 from "node:path";
 var pkgJson = getZudokuPackageJson();
 function generateOutput({
   config: config2,
@@ -8522,9 +8939,9 @@ async function writeOutput(dir, {
   rewrites
 }) {
   const output = generateOutput({ config: config2, redirects, rewrites });
-  const outputDir = process.env.VERCEL ? path23.join(dir, ".vercel/output") : path23.join(dir, "dist/.output");
+  const outputDir = process.env.VERCEL ? path24.join(dir, ".vercel/output") : path24.join(dir, "dist/.output");
   await mkdir3(outputDir, { recursive: true });
-  const outputFile = path23.join(outputDir, "config.json");
+  const outputFile = path24.join(outputDir, "config.json");
   await writeFile3(outputFile, JSON.stringify(output, null, 2), "utf-8");
   if (process.env.VERCEL) {
     console.log("Wrote Vercel output to", outputDir);
@@ -8534,9 +8951,9 @@ async function writeOutput(dir, {
 // src/vite/prerender/prerender.ts
 init_logger();
 init_file_exists();
-import { readFile as readFile3, rm } from "node:fs/promises";
+import { readFile as readFile2, rm } from "node:fs/promises";
 import os from "node:os";
-import path26 from "node:path";
+import path27 from "node:path";
 import { pathToFileURL } from "node:url";
 import { createIndex } from "pagefind";
 import colors7 from "picocolors";
@@ -8576,9 +8993,9 @@ function throttle(fn) {
 
 // src/vite/sitemap.ts
 init_joinUrl();
-import { createWriteStream, existsSync } from "node:fs";
+import { createWriteStream, existsSync as existsSync2 } from "node:fs";
 import { mkdir as mkdir4 } from "node:fs/promises";
-import path24 from "node:path";
+import path25 from "node:path";
 import colors5 from "picocolors";
 import { SitemapStream } from "sitemap";
 async function generateSitemap({
@@ -8592,11 +9009,11 @@ async function generateSitemap({
     return;
   }
   const sitemap = new SitemapStream({ hostname: config2.siteUrl });
-  const outputDir = path24.resolve(baseOutputDir, config2.outDir ?? "");
-  if (!existsSync(outputDir)) {
+  const outputDir = path25.resolve(baseOutputDir, config2.outDir ?? "");
+  if (!existsSync2(outputDir)) {
     await mkdir4(outputDir, { recursive: true });
   }
-  const sitemapOutputPath = path24.join(outputDir, "sitemap.xml");
+  const sitemapOutputPath = path25.join(outputDir, "sitemap.xml");
   const writeStream = createWriteStream(sitemapOutputPath);
   sitemap.pipe(writeStream);
   let lastmod;
@@ -8626,14 +9043,14 @@ async function generateSitemap({
 
 // src/vite/prerender/utils.ts
 init_joinUrl();
-var resolveRoutePath = (path38) => {
-  const segments = path38.split("/");
+var resolveRoutePath = (path39) => {
+  const segments = path39.split("/");
   if (segments.some((s) => s.startsWith(":") && !s.endsWith("?"))) {
     return void 0;
   }
   return segments.filter((s) => !s.startsWith(":")).join("/") || void 0;
 };
-var isSkipped = (path38) => path38.includes("*") || /^\d+$/.test(path38);
+var isSkipped = (path39) => path39.includes("*") || /^\d+$/.test(path39);
 var resolveRoutes = (routes, parentPath = "") => routes.flatMap((route) => {
   if (route.path && isSkipped(route.path)) return [];
   const routePath = route.path ? resolveRoutePath(route.path) : void 0;
@@ -8682,12 +9099,12 @@ var prerender = async ({
   serverConfigFilename,
   writeRedirects = true
 }) => {
-  const distDir = path26.join(dir, "dist", basePath);
+  const distDir = path27.join(dir, "dist", basePath);
   const serverConfigPath = pathToFileURL(
-    path26.join(distDir, "server", serverConfigFilename)
+    path27.join(distDir, "server", serverConfigFilename)
   ).href;
   const entryServerPath = pathToFileURL(
-    path26.join(distDir, "server/entry.server.js")
+    path27.join(distDir, "server/entry.server.js")
   ).href;
   const rawConfig = await import(serverConfigPath).then(
     (m) => m.default
@@ -8772,7 +9189,7 @@ var prerender = async ({
     })
   );
   const pagefindWriteResult = await pagefindIndex?.writeFiles({
-    outputPath: path26.join(distDir, "pagefind")
+    outputPath: path27.join(distDir, "pagefind")
   });
   const seconds = ((performance.now() - start) / 1e3).toFixed(1);
   const message = `\u2713 finished prerendering ${paths.length} routes in ${seconds} seconds using ${maxThreads} workers`;
@@ -8804,13 +9221,13 @@ var prerender = async ({
     const { generateLlmsTxtFiles: generateLlmsTxtFiles2 } = await Promise.resolve().then(() => (init_llms(), llms_exports));
     const docsConfig = DocsConfigSchema2.parse(config2.docs);
     const llmsConfig = docsConfig.llms ?? {};
-    const markdownInfoPath = path26.join(
+    const markdownInfoPath = path27.join(
       dir,
       "node_modules/.apitogo/markdown-info.json"
     );
     let markdownFileInfos = [];
     if (await fileExists(markdownInfoPath)) {
-      const markdownInfoContent = await readFile3(markdownInfoPath, "utf-8");
+      const markdownInfoContent = await readFile2(markdownInfoPath, "utf-8");
       markdownFileInfos = JSON.parse(markdownInfoContent);
     }
     if (llmsConfig.llmsTxt || llmsConfig.llmsTxtFull) {
@@ -8895,7 +9312,7 @@ async function runBuild(options) {
       html,
       basePath: config2.basePath
     });
-    await rm2(path27.join(clientOutDir, "index.html"), { force: true });
+    await rm2(path28.join(clientOutDir, "index.html"), { force: true });
   } else {
     await runPrerender({
       dir,
@@ -8919,7 +9336,7 @@ var runPrerender = async (options) => {
       serverConfigFilename,
       writeRedirects: process.env.VERCEL === void 0
     });
-    const indexHtml = path27.join(clientOutDir, "index.html");
+    const indexHtml = path28.join(clientOutDir, "index.html");
     if (!workerResults.find((r) => r.outputPath === indexHtml)) {
       await writeFile5(indexHtml, html, "utf-8");
     }
@@ -8929,15 +9346,15 @@ var runPrerender = async (options) => {
     for (const statusPage of statusPages) {
       await rename(
         statusPage,
-        path27.join(dir, DIST_DIR, path27.basename(statusPage))
+        path28.join(dir, DIST_DIR, path28.basename(statusPage))
       );
     }
     await rm2(serverOutDir, { recursive: true, force: true });
     if (process.env.VERCEL) {
-      await mkdir5(path27.join(dir, ".vercel/output/static"), { recursive: true });
+      await mkdir5(path28.join(dir, ".vercel/output/static"), { recursive: true });
       await rename(
-        path27.join(dir, DIST_DIR),
-        path27.join(dir, ".vercel/output/static")
+        path28.join(dir, DIST_DIR),
+        path28.join(dir, ".vercel/output/static")
       );
     }
     await writeOutput(dir, {
@@ -8947,7 +9364,7 @@ var runPrerender = async (options) => {
     });
     if (ZuploEnv.isZuplo && issuer) {
       await writeFile5(
-        path27.join(dir, DIST_DIR, ".output/zuplo.json"),
+        path28.join(dir, DIST_DIR, ".output/zuplo.json"),
         JSON.stringify({ issuer }, null, 2),
         "utf-8"
       );
@@ -8959,10 +9376,10 @@ var runPrerender = async (options) => {
 };
 var bundleSSREntry = async (options) => {
   const { dir, adapter, serverOutDir, serverConfigFilename, html, basePath } = options;
-  const tempEntryPath = path27.join(dir, "__ssr-entry.ts");
+  const tempEntryPath = path28.join(dir, "__ssr-entry.ts");
   const packageRoot = getZudokuRootDir();
-  const templateContent = await readFile4(
-    path27.join(packageRoot, "src/vite/ssr-templates", `${adapter}.ts`),
+  const templateContent = await readFile3(
+    path28.join(packageRoot, "src/vite/ssr-templates", `${adapter}.ts`),
     "utf-8"
   );
   const entryContent = templateContent.replace('"__TEMPLATE__"', JSON.stringify(html)).replace('"__CONFIG_FILE__"', JSON.stringify(`./${serverConfigFilename}`)).replace(
@@ -8977,9 +9394,9 @@ var bundleSSREntry = async (options) => {
       platform: adapter === "node" ? "node" : "neutral",
       target: "es2022",
       format: "esm",
-      outfile: path27.join(serverOutDir, "entry.js"),
+      outfile: path28.join(serverOutDir, "entry.js"),
       external: ["./entry.server.js", `./${serverConfigFilename}`],
-      nodePaths: [path27.join(packageRoot, "node_modules")],
+      nodePaths: [path28.join(packageRoot, "node_modules")],
       banner: { js: "// Bundled SSR entry" }
     });
   } finally {
@@ -9034,11 +9451,11 @@ function textOrJson(text) {
 init_package_json();
 
 // src/cli/preview/handler.ts
-import path28 from "node:path";
+import path29 from "node:path";
 import { preview as vitePreview } from "vite";
 var DEFAULT_PREVIEW_PORT = 4e3;
 async function preview(argv) {
-  const dir = path28.resolve(process.cwd(), argv.dir);
+  const dir = path29.resolve(process.cwd(), argv.dir);
   const viteConfig = await getViteConfig(dir, {
     command: "serve",
     mode: "production",
@@ -9079,7 +9496,7 @@ async function build(argv) {
     printDiagnosticsToConsole("");
     printDiagnosticsToConsole("");
   }
-  const dir = path29.resolve(process.cwd(), argv.dir);
+  const dir = path30.resolve(process.cwd(), argv.dir);
   try {
     await runBuild({
       dir,
@@ -9238,8 +9655,8 @@ var build_default = {
 
 // src/cli/configure-github-workflow/handler.ts
 import { constants } from "node:fs";
-import { access as access2, mkdir as mkdir6, writeFile as writeFile6 } from "node:fs/promises";
-import path30 from "node:path";
+import { access, mkdir as mkdir6, writeFile as writeFile6 } from "node:fs/promises";
+import path31 from "node:path";
 var APITOGO_DEPLOY_WORKFLOW_YAML = `name: Build and Deploy
 
 on:
@@ -9350,12 +9767,12 @@ jobs:
         run: apitogo deploy --deployment-token="$APITOGO_TOKEN" --json-only
 `;
 async function configureGithubWorkflow(argv) {
-  const dir = path30.resolve(process.cwd(), argv.dir);
-  const workflowDir = path30.join(dir, ".github", "workflows");
-  const workflowPath = path30.join(workflowDir, "apitogo-deploy.yml");
+  const dir = path31.resolve(process.cwd(), argv.dir);
+  const workflowDir = path31.join(dir, ".github", "workflows");
+  const workflowPath = path31.join(workflowDir, "apitogo-deploy.yml");
   try {
     try {
-      await access2(workflowPath, constants.F_OK);
+      await access(workflowPath, constants.F_OK);
       if (!argv.force) {
         await printCriticalFailureToConsoleAndExit(
           `Workflow file already exists: ${workflowPath}. Pass --force to overwrite.`
@@ -9424,15 +9841,15 @@ function applyJsonOnlyDeployQuietMode() {
 }
 
 // src/cli/deploy/handler.ts
-import { access as access3, readFile as readFile5 } from "node:fs/promises";
-import path31 from "node:path";
+import { access as access2, readFile as readFile4 } from "node:fs/promises";
+import path32 from "node:path";
 import { create as createTar } from "tar";
 var DEPLOY_ENDPOINT = "https://deploy-server-dotnet2-b3fkcaaraydbckfe.canadacentral-01.azurewebsites.net/deploy";
 var ARCHIVE_NAME = "dist.tgz";
 var createDeploymentArchive = async (dir) => {
-  const distDir = path31.join(dir, "dist");
-  await access3(distDir);
-  const archivePath = path31.join(dir, ARCHIVE_NAME);
+  const distDir = path32.join(dir, "dist");
+  await access2(distDir);
+  const archivePath = path32.join(dir, ARCHIVE_NAME);
   await createTar(
     {
       cwd: dir,
@@ -9446,7 +9863,7 @@ var createDeploymentArchive = async (dir) => {
 };
 async function deploy(argv) {
   await build({ ...argv, preview: void 0 });
-  const dir = path31.resolve(process.cwd(), argv.dir);
+  const dir = path32.resolve(process.cwd(), argv.dir);
   const deploymentToken = argv.deploymentToken?.trim() || process.env.npm_config_deployment_token?.trim();
   const env = argv.env?.trim() || process.env.npm_config_env?.trim() || "production";
   try {
@@ -9459,15 +9876,15 @@ async function deploy(argv) {
     const archivePath = await createDeploymentArchive(dir);
     if (!isJsonOnlyDeployEnv()) {
       printDiagnosticsToConsole(
-        `Uploading ${path31.basename(archivePath)} to ${env}...`
+        `Uploading ${path32.basename(archivePath)} to ${env}...`
       );
     }
-    const archiveBuffer = await readFile5(archivePath);
+    const archiveBuffer = await readFile4(archivePath);
     const formData = new FormData();
     formData.append(
       "file",
       new Blob([archiveBuffer], { type: "application/gzip" }),
-      path31.basename(archivePath)
+      path32.basename(archivePath)
     );
     formData.append("deploymentToken", deploymentToken);
     formData.append("env", env);
@@ -9552,14 +9969,14 @@ var deploy_default = {
 
 // src/cli/dev/handler.ts
 init_joinUrl();
-import path34 from "node:path";
+import path35 from "node:path";
 
 // src/vite/dev-server.ts
 init_logger();
 import fs4 from "node:fs/promises";
 import http from "node:http";
 import https from "node:https";
-import path33 from "node:path";
+import path34 from "node:path";
 import { createHttpTerminator } from "http-terminator";
 import {
   createServer as createViteServer,
@@ -9592,7 +10009,7 @@ init_loader();
 // src/vite/pagefind-dev-index.ts
 init_invariant();
 init_joinUrl();
-import path32 from "node:path";
+import path33 from "node:path";
 import { createIndex as createIndex2 } from "pagefind";
 import { isRunnableDevEnvironment } from "vite";
 async function* buildPagefindDevIndex(vite, config2) {
@@ -9645,7 +10062,7 @@ async function* buildPagefindDevIndex(vite, config2) {
       path: urlPath
     };
   }
-  const outputPath = path32.join(vite.config.publicDir, "pagefind");
+  const outputPath = path33.join(vite.config.publicDir, "pagefind");
   await pagefindIndex.writeFiles({ outputPath });
   yield { type: "complete", success: true, indexed };
 }
@@ -9664,9 +10081,9 @@ var DevServer = class {
     this.protocol = "https";
     const { dir } = this.options;
     const [key, cert, ca] = await Promise.all([
-      fs4.readFile(path33.resolve(dir, config2.https.key)),
-      fs4.readFile(path33.resolve(dir, config2.https.cert)),
-      config2.https.ca ? fs4.readFile(path33.resolve(dir, config2.https.ca)) : void 0
+      fs4.readFile(path34.resolve(dir, config2.https.key)),
+      fs4.readFile(path34.resolve(dir, config2.https.cert)),
+      config2.https.ca ? fs4.readFile(path34.resolve(dir, config2.https.ca)) : void 0
     ]);
     return https.createServer({ key, cert, ca });
   }
@@ -9683,7 +10100,7 @@ var DevServer = class {
     );
     const server = await this.createNodeServer(config2);
     if (config2.search?.type === "pagefind" && viteConfig.publicDir !== false) {
-      const publicRoot = path33.resolve(
+      const publicRoot = path34.resolve(
         this.options.dir,
         typeof viteConfig.publicDir === "string" ? viteConfig.publicDir : "public"
       );
@@ -9700,7 +10117,7 @@ var DevServer = class {
           // built-in transform middleware which would treat the path as a static asset.
           name: "apitogo:entry-client",
           configureServer(server2) {
-            const entryPath = path33.posix.join(
+            const entryPath = path34.posix.join(
               server2.config.base,
               "/__z/entry.client.tsx"
             );
@@ -9865,7 +10282,7 @@ init_package_json();
 async function dev(argv) {
   const packageJson2 = getZudokuPackageJson();
   process.env.NODE_ENV = "development";
-  const dir = path34.resolve(process.cwd(), argv.dir);
+  const dir = path35.resolve(process.cwd(), argv.dir);
   const server = new DevServer({
     dir,
     argPort: argv.port,
@@ -9949,15 +10366,15 @@ var dev_default = {
 
 // src/cli/make-config/handler.ts
 import { constants as constants3 } from "node:fs";
-import { access as access5, mkdir as mkdir7, readFile as readFile7, writeFile as writeFile8 } from "node:fs/promises";
-import path36 from "node:path";
+import { access as access4, mkdir as mkdir7, readFile as readFile6, writeFile as writeFile8 } from "node:fs/promises";
+import path37 from "node:path";
 import { glob as glob5 } from "glob";
 
 // src/cli/make-config/scaffold-project.ts
 init_package_json();
 import { constants as constants2 } from "node:fs";
-import { access as access4, readFile as readFile6, writeFile as writeFile7 } from "node:fs/promises";
-import path35 from "node:path";
+import { access as access3, readFile as readFile5, writeFile as writeFile7 } from "node:fs/promises";
+import path36 from "node:path";
 import { glob as glob4 } from "glob";
 var OPENAPI_GLOBS = [
   "apis/openapi.json",
@@ -10017,9 +10434,9 @@ var findMatchingCurly = (source, startIndex) => {
   }
   throw new Error("Could not find matching closing brace for object.");
 };
-var toPosix = (p) => p.split(path35.sep).join("/");
+var toPosix = (p) => p.split(path36.sep).join("/");
 var sanitizePackageName = (dir) => {
-  const base = path35.basename(path35.resolve(dir));
+  const base = path36.basename(path36.resolve(dir));
   const s = base.toLowerCase().replace(/[^a-z0-9-_.]/g, "-").replace(/^-+|-+$/g, "");
   return s || "apitogo-site";
 };
@@ -10029,9 +10446,9 @@ var apitogoVersionRange = () => {
 };
 async function findOpenApiSpecPath(dir) {
   for (const rel of OPENAPI_GLOBS) {
-    const full = path35.join(dir, rel);
+    const full = path36.join(dir, rel);
     try {
-      await access4(full, constants2.R_OK);
+      await access3(full, constants2.R_OK);
       return toPosix(rel);
     } catch {
     }
@@ -10044,7 +10461,7 @@ async function findOpenApiSpecPath(dir) {
   return extra[0] ? toPosix(extra[0]) : null;
 }
 async function ensurePackageJson(dir) {
-  const pkgPath = path35.join(dir, "package.json");
+  const pkgPath = path36.join(dir, "package.json");
   const apitogoVer = apitogoVersionRange();
   const baseDeps = {
     react: ">=19.0.0",
@@ -10057,7 +10474,7 @@ async function ensurePackageJson(dir) {
     preview: "apitogo preview"
   };
   try {
-    await access4(pkgPath, constants2.R_OK);
+    await access3(pkgPath, constants2.R_OK);
   } catch (err) {
     const code = err.code;
     if (code !== "ENOENT") throw err;
@@ -10079,7 +10496,7 @@ async function ensurePackageJson(dir) {
 `, "utf8");
     return true;
   }
-  const raw = await readFile6(pkgPath, "utf8");
+  const raw = await readFile5(pkgPath, "utf8");
   let pkg;
   try {
     pkg = JSON.parse(raw);
@@ -10107,9 +10524,9 @@ async function ensurePackageJson(dir) {
   return false;
 }
 async function ensureTsconfigJson(dir) {
-  const tsPath = path35.join(dir, "tsconfig.json");
+  const tsPath = path36.join(dir, "tsconfig.json");
   try {
-    await access4(tsPath, constants2.R_OK);
+    await access3(tsPath, constants2.R_OK);
     return false;
   } catch {
     const tsconfig = {
@@ -10189,7 +10606,7 @@ var CONFIG_FILENAMES = [
 ];
 var DEFAULT_NEW_CONFIG_FILENAME = "apitogo.config.tsx";
 var createTreeNode = () => ({ docs: [], children: /* @__PURE__ */ new Map() });
-var toPosixPath2 = (value) => value.split(path36.sep).join(path36.posix.sep);
+var toPosixPath2 = (value) => value.split(path37.sep).join(path37.posix.sep);
 var toRoutePath = (relativeFile, pagesDir) => {
   const relativeNoExt = relativeFile.replace(/\.mdx?$/, "");
   const withoutPagesPrefix = relativeNoExt.replace(
@@ -10434,26 +10851,26 @@ export default config;
 `;
 };
 var ensureApitogoDeployWorkflow = async (dir) => {
-  const workflowPath = path36.join(
+  const workflowPath = path37.join(
     dir,
     ".github",
     "workflows",
     "apitogo-deploy.yml"
   );
   try {
-    await access5(workflowPath, constants3.F_OK);
+    await access4(workflowPath, constants3.F_OK);
     return false;
   } catch {
   }
-  await mkdir7(path36.join(dir, ".github", "workflows"), { recursive: true });
+  await mkdir7(path37.join(dir, ".github", "workflows"), { recursive: true });
   await writeFile8(workflowPath, APITOGO_DEPLOY_WORKFLOW_YAML, "utf8");
   return true;
 };
 var findExistingConfigPath = async (dir) => {
   for (const filename of CONFIG_FILENAMES) {
-    const fullPath = path36.join(dir, filename);
+    const fullPath = path37.join(dir, filename);
     try {
-      await readFile7(fullPath, "utf8");
+      await readFile6(fullPath, "utf8");
       return fullPath;
     } catch {
     }
@@ -10461,7 +10878,7 @@ var findExistingConfigPath = async (dir) => {
   return null;
 };
 async function makeConfig(argv) {
-  const dir = path36.resolve(process.cwd(), argv.dir);
+  const dir = path37.resolve(process.cwd(), argv.dir);
   const pagesDir = toPosixPath2(
     argv.pagesDir.replace(/^[./]+/, "").replace(/\/+$/, "")
   );
@@ -10480,7 +10897,7 @@ async function makeConfig(argv) {
     let configPath = await findExistingConfigPath(dir);
     let createdNew = false;
     if (!configPath) {
-      configPath = path36.join(dir, DEFAULT_NEW_CONFIG_FILENAME);
+      configPath = path37.join(dir, DEFAULT_NEW_CONFIG_FILENAME);
       await writeFile8(
         configPath,
         buildNewConfigContents(pagesDir, openApiSpecPath),
@@ -10500,7 +10917,7 @@ async function makeConfig(argv) {
     if (routePaths.length === 0) {
       throw new Error(`No .md or .mdx files found under '${pagesDir}'.`);
     }
-    let originalConfig = await readFile7(configPath, "utf8");
+    let originalConfig = await readFile6(configPath, "utf8");
     if (!createdNew && openApiSpecPath) {
       originalConfig = insertApisIfMissing(
         originalConfig,
@@ -10521,7 +10938,7 @@ async function makeConfig(argv) {
     await writeFile8(configPath, withRedirects, "utf8");
     const action = createdNew ? "Initialized" : "Updated";
     printResultToConsole(
-      `${action} ${path36.basename(configPath)} from ${pagesDir}/ (navigation and redirects; other top-level settings preserved unless newly scaffolded).`
+      `${action} ${path37.basename(configPath)} from ${pagesDir}/ (navigation and redirects; other top-level settings preserved unless newly scaffolded).`
     );
     const createdWorkflow = await ensureApitogoDeployWorkflow(dir);
     if (createdWorkflow) {
@@ -10663,8 +11080,8 @@ var remove_default = {
 };
 
 // src/cli/common/outdated.ts
-import { existsSync as existsSync2, mkdirSync } from "node:fs";
-import { readFile as readFile8, writeFile as writeFile9 } from "node:fs/promises";
+import { existsSync as existsSync3, mkdirSync } from "node:fs";
+import { readFile as readFile7, writeFile as writeFile9 } from "node:fs/promises";
 import { join } from "node:path";
 import colors10 from "picocolors";
 import { gt } from "semver";
@@ -10714,12 +11131,12 @@ function box(message, {
 
 // src/cli/common/xdg/lib.ts
 import { homedir } from "node:os";
-import path37 from "node:path";
+import path38 from "node:path";
 function defineDirectoryWithFallback(xdgName, fallback) {
   if (process.env[xdgName]) {
     return process.env[xdgName];
   } else {
-    return path37.join(homedir(), fallback);
+    return path38.join(homedir(), fallback);
   }
 }
 var XDG_CONFIG_HOME = defineDirectoryWithFallback(
@@ -10734,15 +11151,15 @@ var XDG_STATE_HOME = defineDirectoryWithFallback(
   "XDG_DATA_HOME",
   ".local/state"
 );
-var ZUDOKU_XDG_CONFIG_HOME = path37.join(
+var ZUDOKU_XDG_CONFIG_HOME = path38.join(
   XDG_CONFIG_HOME,
   CLI_XDG_FOLDER_NAME
 );
-var ZUDOKU_XDG_DATA_HOME = path37.join(
+var ZUDOKU_XDG_DATA_HOME = path38.join(
   XDG_DATA_HOME,
   CLI_XDG_FOLDER_NAME
 );
-var ZUDOKU_XDG_STATE_HOME = path37.join(
+var ZUDOKU_XDG_STATE_HOME = path38.join(
   XDG_STATE_HOME,
   CLI_XDG_FOLDER_NAME
 );
@@ -10787,14 +11204,14 @@ async function getLatestVersion() {
   return void 0;
 }
 async function getVersionCheckInfo() {
-  if (!existsSync2(ZUDOKU_XDG_STATE_HOME)) {
+  if (!existsSync3(ZUDOKU_XDG_STATE_HOME)) {
     mkdirSync(ZUDOKU_XDG_STATE_HOME, { recursive: true });
   }
   const versionCheckPath = join(ZUDOKU_XDG_STATE_HOME, VERSION_CHECK_FILE);
   let versionCheckInfo;
-  if (existsSync2(versionCheckPath)) {
+  if (existsSync3(versionCheckPath)) {
     try {
-      versionCheckInfo = await readFile8(versionCheckPath, "utf-8").then(
+      versionCheckInfo = await readFile7(versionCheckPath, "utf-8").then(
         JSON.parse
       );
     } catch {