@lukoweb/apitogo 0.1.47 → 0.1.49

package/dist/cli/cli.js

@@ -3985,7 +3985,7 @@ import yargs from "yargs/yargs";
 import path29 from "node:path";
 
 // src/vite/build.ts
-import { mkdir as mkdir5, readFile as readFile3, rename, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile4, rename, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
 import path27 from "node:path";
 import { build as esbuild } from "esbuild";
 import { build as viteBuild, mergeConfig as mergeConfig3 } from "vite";
@@ -4133,7 +4133,7 @@ import {
 // package.json
 var package_default = {
   name: "@lukoweb/apitogo",
-  version: "0.1.47",
+  version: "0.1.49",
   type: "module",
   sideEffects: [
     "**/*.css",
@@ -7085,12 +7085,282 @@ 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
+var APITOGO_LOCAL_MANIFEST_VIRTUAL_ID = "virtual:apitogo-local-manifest";
+var resolvedVirtualModuleId4 = `\0${APITOGO_LOCAL_MANIFEST_VIRTUAL_ID}`;
+var viteLocalManifestPlugin = () => {
+  let rootDir = "";
+  let viteMode = "development";
+  let watchPaths = [];
+  const loadManifestModule = async () => {
+    const env = resolveManifestEnv(viteMode);
+    let catalog = manifestToPreviewCatalog(null);
+    try {
+      const manifest = await readEffectiveManifest(rootDir, env);
+      catalog = manifestToPreviewCatalog(manifest);
+    } catch {
+    }
+    return `export default ${JSON.stringify(catalog)};`;
+  };
+  return {
+    name: "apitogo-local-manifest-plugin",
+    configResolved(resolvedConfig) {
+      rootDir = resolvedConfig.root;
+      viteMode = resolvedConfig.mode;
+      const env = resolveManifestEnv(viteMode);
+      watchPaths = manifestPathsForEnv(rootDir, env).watchPaths;
+    },
+    resolveId(id) {
+      if (id === APITOGO_LOCAL_MANIFEST_VIRTUAL_ID) {
+        return resolvedVirtualModuleId4;
+      }
+    },
+    async load(id) {
+      if (id !== resolvedVirtualModuleId4) {
+        return;
+      }
+      return loadManifestModule();
+    },
+    configureServer(server) {
+      for (const watchPath of watchPaths) {
+        server.watcher.add(watchPath);
+      }
+      server.watcher.on("change", async (changedPath) => {
+        const resolvedChanged = path16.resolve(changedPath);
+        if (!watchPaths.some((p) => path16.resolve(p) === resolvedChanged)) {
+          return;
+        }
+        const module = server.moduleGraph.getModuleById(
+          resolvedVirtualModuleId4
+        );
+        if (module) {
+          server.moduleGraph.invalidateModule(module);
+        }
+        const mod = await server.moduleGraph.getModuleByUrl(
+          APITOGO_LOCAL_MANIFEST_VIRTUAL_ID
+        );
+        if (mod) {
+          server.reloadModule(mod);
+        }
+        server.ws.send({ type: "full-reload", path: "*" });
+      });
+    }
+  };
+};
+var plugin_local_manifest_default = viteLocalManifestPlugin;
+
 // src/vite/plugin-markdown-export.ts
 init_loader();
 init_ProtectedRoutesSchema();
 init_joinUrl();
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import path15 from "node:path";
+import path17 from "node:path";
 import { matchPath } from "react-router";
 var processMarkdownFile = async (filePath) => {
   const { content: markdownContent, data: frontmatter } = await readFrontmatter(filePath);
@@ -7178,7 +7448,7 @@ var viteMarkdownExportPlugin = () => {
       if (process.env.NODE_ENV !== "production" || Object.keys(markdownFiles).length === 0 || !needsMdFiles) {
         return;
       }
-      const distDir = path15.join(
+      const distDir = path17.join(
         config2.__meta.rootDir,
         "dist",
         config2.basePath ?? ""
@@ -7199,15 +7469,15 @@ var viteMarkdownExportPlugin = () => {
             content: finalMarkdown
           });
           const segments = routePath === "/" ? ["index"] : routePath.split("/").filter(Boolean);
-          const outputPath = `${path15.join(distDir, ...segments)}.md`;
-          await mkdir2(path15.dirname(outputPath), { recursive: true });
+          const outputPath = `${path17.join(distDir, ...segments)}.md`;
+          await mkdir2(path17.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 = path15.join(
+        const markdownInfoPath = path17.join(
           config2.__meta.rootDir,
           "node_modules/.apitogo/markdown-info.json"
         );
@@ -7359,9 +7629,9 @@ var remarkCodeTabs = () => (tree) => {
 };
 
 // src/vite/mdx/remark-inject-filepath.ts
-import path16 from "node:path";
+import path18 from "node:path";
 var remarkInjectFilepath = (rootDir) => (tree, vfile) => {
-  const relativePath = path16.relative(rootDir, vfile.path).split(path16.sep).join(path16.posix.sep);
+  const relativePath = path18.relative(rootDir, vfile.path).split(path18.sep).join(path18.posix.sep);
   tree.children.unshift(exportMdxjsConst("__filepath", relativePath));
 };
 
@@ -7448,18 +7718,18 @@ var remarkLastModified = () => {
 };
 
 // src/vite/mdx/remark-link-rewrite.ts
-import path17 from "node:path";
+import path19 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 = path17.posix.join(basePath);
+    const base = path19.posix.join(basePath);
     if (basePath && node.url.startsWith(base)) {
       node.url = node.url.slice(base.length);
     } else if (!node.url.startsWith("/") && !node.url.startsWith("#")) {
-      node.url = path17.posix.join("..", node.url);
+      node.url = path19.posix.join("..", node.url);
     }
     node.url = node.url.replace(/\.mdx?(#.*)?$/, "$1");
   });
@@ -7679,11 +7949,11 @@ var plugin_mdx_default = viteMdxPlugin;
 
 // src/vite/plugin-modules.ts
 init_loader();
-import path18 from "node:path";
+import path20 from "node:path";
 import { normalizePath as normalizePath2 } from "vite";
-var getLandingModuleImport = (moduleDir, mode) => mode === "internal" ? normalizePath2(path18.join(moduleDir, "../module-landing/src/index.tsx")) : "@lukoweb/apitogo-module-landing";
-var getUserPanelModuleImport = (moduleDir, mode) => mode === "internal" ? normalizePath2(path18.join(moduleDir, "../module-user-panel/src/index.tsx")) : "@lukoweb/apitogo-module-user-panel";
-var resolveProjectPageImport = (rootDir, pagePath) => normalizePath2(path18.resolve(rootDir, pagePath));
+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 viteModulesPlugin = () => {
   const virtualModuleId4 = "virtual:zudoku-modules-plugin";
   const resolvedVirtualModuleId5 = `\0${virtualModuleId4}`;
@@ -7804,7 +8074,7 @@ var plugin_modules_default = viteModulesPlugin;
 
 // src/vite/plugin-search.ts
 init_loader();
-import path19 from "node:path";
+import path21 from "node:path";
 var viteSearchPlugin = () => {
   const virtualModuleId4 = "virtual:zudoku-search-plugin";
   const resolvedVirtualModuleId5 = `\0${virtualModuleId4}`;
@@ -7822,7 +8092,7 @@ var viteSearchPlugin = () => {
         return resolvedVirtualModuleId5;
       }
       if (id === "/pagefind/pagefind.js" && resolvedViteConfig?.publicDir) {
-        return path19.join(resolvedViteConfig.publicDir, "pagefind/pagefind.js");
+        return path21.join(resolvedViteConfig.publicDir, "pagefind/pagefind.js");
       }
     },
     async load(id) {
@@ -7933,161 +8203,6 @@ var viteShikiRegisterPlugin = () => {
   };
 };
 
-// src/vite/plugin-local-manifest.ts
-import path21 from "node:path";
-
-// src/config/local-manifest.ts
-import path20 from "node:path";
-import { z as z10 } from "zod";
-var DEV_PORTAL_MANIFEST_FILENAME = "apitogo.local.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(),
-  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 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 manifestFilePath(rootDir) {
-  return path20.join(path20.resolve(rootDir), DEV_PORTAL_MANIFEST_FILENAME);
-}
-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;
-  }
-}
-
-// src/vite/plugin-local-manifest.ts
-var APITOGO_LOCAL_MANIFEST_VIRTUAL_ID = "virtual:apitogo-local-manifest";
-var resolvedVirtualModuleId4 = `\0${APITOGO_LOCAL_MANIFEST_VIRTUAL_ID}`;
-var viteLocalManifestPlugin = () => {
-  let rootDir = "";
-  let manifestPath = "";
-  const loadManifestModule = async () => {
-    const { readFile: readFile8 } = await import("node:fs/promises");
-    let catalog = { plans: [] };
-    try {
-      const raw = await readFile8(manifestPath, "utf8");
-      const manifest = parseLocalManifestJson(raw);
-      catalog = plansToPreviewCatalog(manifest?.plans);
-    } catch {
-    }
-    return `export default ${JSON.stringify(catalog)};`;
-  };
-  return {
-    name: "apitogo-local-manifest-plugin",
-    configResolved(resolvedConfig) {
-      rootDir = resolvedConfig.root;
-      manifestPath = manifestFilePath(rootDir);
-    },
-    resolveId(id) {
-      if (id === APITOGO_LOCAL_MANIFEST_VIRTUAL_ID) {
-        return resolvedVirtualModuleId4;
-      }
-    },
-    async load(id) {
-      if (id !== resolvedVirtualModuleId4) {
-        return;
-      }
-      return loadManifestModule();
-    },
-    configureServer(server) {
-      const watchPath = path21.join(rootDir, DEV_PORTAL_MANIFEST_FILENAME);
-      server.watcher.add(watchPath);
-      server.watcher.on("change", async (changedPath) => {
-        if (path21.resolve(changedPath) !== path21.resolve(manifestPath)) {
-          return;
-        }
-        const module = server.moduleGraph.getModuleById(
-          resolvedVirtualModuleId4
-        );
-        if (module) {
-          server.moduleGraph.invalidateModule(module);
-        }
-        const mod = await server.moduleGraph.getModuleByUrl(
-          APITOGO_LOCAL_MANIFEST_VIRTUAL_ID
-        );
-        if (mod) {
-          server.reloadModule(mod);
-        }
-        server.ws.send({ type: "full-reload", path: "*" });
-      });
-    }
-  };
-};
-var plugin_local_manifest_default = viteLocalManifestPlugin;
-
 // src/vite/plugin.ts
 init_plugin_theme();
 function vitePlugin() {
@@ -8419,7 +8534,7 @@ async function writeOutput(dir, {
 // src/vite/prerender/prerender.ts
 init_logger();
 init_file_exists();
-import { readFile as readFile2, rm } from "node:fs/promises";
+import { readFile as readFile3, rm } from "node:fs/promises";
 import os from "node:os";
 import path26 from "node:path";
 import { pathToFileURL } from "node:url";
@@ -8695,7 +8810,7 @@ var prerender = async ({
     );
     let markdownFileInfos = [];
     if (await fileExists(markdownInfoPath)) {
-      const markdownInfoContent = await readFile2(markdownInfoPath, "utf-8");
+      const markdownInfoContent = await readFile3(markdownInfoPath, "utf-8");
       markdownFileInfos = JSON.parse(markdownInfoContent);
     }
     if (llmsConfig.llmsTxt || llmsConfig.llmsTxtFull) {
@@ -8846,7 +8961,7 @@ var bundleSSREntry = async (options) => {
   const { dir, adapter, serverOutDir, serverConfigFilename, html, basePath } = options;
   const tempEntryPath = path27.join(dir, "__ssr-entry.ts");
   const packageRoot = getZudokuRootDir();
-  const templateContent = await readFile3(
+  const templateContent = await readFile4(
     path27.join(packageRoot, "src/vite/ssr-templates", `${adapter}.ts`),
     "utf-8"
   );
@@ -9123,7 +9238,7 @@ var build_default = {
 
 // src/cli/configure-github-workflow/handler.ts
 import { constants } from "node:fs";
-import { access, mkdir as mkdir6, writeFile as writeFile6 } from "node:fs/promises";
+import { access as access2, mkdir as mkdir6, writeFile as writeFile6 } from "node:fs/promises";
 import path30 from "node:path";
 var APITOGO_DEPLOY_WORKFLOW_YAML = `name: Build and Deploy
 
@@ -9240,7 +9355,7 @@ async function configureGithubWorkflow(argv) {
   const workflowPath = path30.join(workflowDir, "apitogo-deploy.yml");
   try {
     try {
-      await access(workflowPath, constants.F_OK);
+      await access2(workflowPath, constants.F_OK);
       if (!argv.force) {
         await printCriticalFailureToConsoleAndExit(
           `Workflow file already exists: ${workflowPath}. Pass --force to overwrite.`
@@ -9309,14 +9424,14 @@ function applyJsonOnlyDeployQuietMode() {
 }
 
 // src/cli/deploy/handler.ts
-import { access as access2, readFile as readFile4 } from "node:fs/promises";
+import { access as access3, readFile as readFile5 } from "node:fs/promises";
 import path31 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 access2(distDir);
+  await access3(distDir);
   const archivePath = path31.join(dir, ARCHIVE_NAME);
   await createTar(
     {
@@ -9347,7 +9462,7 @@ async function deploy(argv) {
         `Uploading ${path31.basename(archivePath)} to ${env}...`
       );
     }
-    const archiveBuffer = await readFile4(archivePath);
+    const archiveBuffer = await readFile5(archivePath);
     const formData = new FormData();
     formData.append(
       "file",
@@ -9834,14 +9949,14 @@ var dev_default = {
 
 // src/cli/make-config/handler.ts
 import { constants as constants3 } from "node:fs";
-import { access as access4, mkdir as mkdir7, readFile as readFile6, writeFile as writeFile8 } from "node:fs/promises";
+import { access as access5, mkdir as mkdir7, readFile as readFile7, writeFile as writeFile8 } from "node:fs/promises";
 import path36 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 access3, readFile as readFile5, writeFile as writeFile7 } from "node:fs/promises";
+import { access as access4, readFile as readFile6, writeFile as writeFile7 } from "node:fs/promises";
 import path35 from "node:path";
 import { glob as glob4 } from "glob";
 var OPENAPI_GLOBS = [
@@ -9916,7 +10031,7 @@ async function findOpenApiSpecPath(dir) {
   for (const rel of OPENAPI_GLOBS) {
     const full = path35.join(dir, rel);
     try {
-      await access3(full, constants2.R_OK);
+      await access4(full, constants2.R_OK);
       return toPosix(rel);
     } catch {
     }
@@ -9942,7 +10057,7 @@ async function ensurePackageJson(dir) {
     preview: "apitogo preview"
   };
   try {
-    await access3(pkgPath, constants2.R_OK);
+    await access4(pkgPath, constants2.R_OK);
   } catch (err) {
     const code = err.code;
     if (code !== "ENOENT") throw err;
@@ -9964,7 +10079,7 @@ async function ensurePackageJson(dir) {
 `, "utf8");
     return true;
   }
-  const raw = await readFile5(pkgPath, "utf8");
+  const raw = await readFile6(pkgPath, "utf8");
   let pkg;
   try {
     pkg = JSON.parse(raw);
@@ -9994,7 +10109,7 @@ async function ensurePackageJson(dir) {
 async function ensureTsconfigJson(dir) {
   const tsPath = path35.join(dir, "tsconfig.json");
   try {
-    await access3(tsPath, constants2.R_OK);
+    await access4(tsPath, constants2.R_OK);
     return false;
   } catch {
     const tsconfig = {
@@ -10326,7 +10441,7 @@ var ensureApitogoDeployWorkflow = async (dir) => {
     "apitogo-deploy.yml"
   );
   try {
-    await access4(workflowPath, constants3.F_OK);
+    await access5(workflowPath, constants3.F_OK);
     return false;
   } catch {
   }
@@ -10338,7 +10453,7 @@ var findExistingConfigPath = async (dir) => {
   for (const filename of CONFIG_FILENAMES) {
     const fullPath = path36.join(dir, filename);
     try {
-      await readFile6(fullPath, "utf8");
+      await readFile7(fullPath, "utf8");
       return fullPath;
     } catch {
     }
@@ -10385,7 +10500,7 @@ async function makeConfig(argv) {
     if (routePaths.length === 0) {
       throw new Error(`No .md or .mdx files found under '${pagesDir}'.`);
     }
-    let originalConfig = await readFile6(configPath, "utf8");
+    let originalConfig = await readFile7(configPath, "utf8");
     if (!createdNew && openApiSpecPath) {
       originalConfig = insertApisIfMissing(
         originalConfig,
@@ -10549,7 +10664,7 @@ var remove_default = {
 
 // src/cli/common/outdated.ts
 import { existsSync as existsSync2, mkdirSync } from "node:fs";
-import { readFile as readFile7, writeFile as writeFile9 } from "node:fs/promises";
+import { readFile as readFile8, writeFile as writeFile9 } from "node:fs/promises";
 import { join } from "node:path";
 import colors10 from "picocolors";
 import { gt } from "semver";
@@ -10679,7 +10794,7 @@ async function getVersionCheckInfo() {
   let versionCheckInfo;
   if (existsSync2(versionCheckPath)) {
     try {
-      versionCheckInfo = await readFile7(versionCheckPath, "utf-8").then(
+      versionCheckInfo = await readFile8(versionCheckPath, "utf-8").then(
         JSON.parse
       );
     } catch {

package/dist/declarations/config/local-manifest.d.ts

@@ -1,5 +1,11 @@
 import { z } from "zod";
 export declare const DEV_PORTAL_MANIFEST_FILENAME = "apitogo.local.json";
+export declare const APITOGO_MANIFEST_BASE_FILENAME = "apitogo.json";
+export declare const APITOGO_MANIFEST_ENV_FILES: {
+    readonly development: "apitogo.local.json";
+    readonly production: "apitogo.prod.json";
+};
+export type ApitogoManifestEnv = keyof typeof APITOGO_MANIFEST_ENV_FILES;
 export declare const ManifestPlanInputSchema: z.ZodObject<{
     sku: z.ZodString;
     displayName: z.ZodString;
@@ -21,6 +27,9 @@ export declare const DevPortalLocalManifestSchema: z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
         logoUrl: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    pricing: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
     plans: z.ZodOptional<z.ZodArray<z.ZodObject<{
         sku: z.ZodString;
         displayName: z.ZodString;
@@ -71,10 +80,23 @@ export type DevPortalPreviewPlan = {
     includedActionKeys: string[];
 };
 export type DevPortalPreviewPlanCatalog = {
+    pricingEnabled: boolean;
     plans: DevPortalPreviewPlan[];
 };
+export declare function isPricingEnabled(manifest: DevPortalLocalManifest | null | undefined): boolean;
+export declare function manifestToPreviewCatalog(manifest: DevPortalLocalManifest | null | undefined): DevPortalPreviewPlanCatalog;
 export declare function normalizeBillingPeriod(period?: string): string;
-export declare function plansToPreviewCatalog(plans: ManifestPlanInput[] | undefined): DevPortalPreviewPlanCatalog;
-export declare function manifestFilePath(rootDir: string): string;
+export declare function plansToPreviewCatalog(plans: ManifestPlanInput[] | undefined): Pick<DevPortalPreviewPlanCatalog, "plans">;
+export declare function resolveManifestEnv(viteMode: string): ApitogoManifestEnv;
+export declare function mergePlansBySku(existing: ManifestPlanInput[] | undefined, patch: ManifestPlanInput[]): ManifestPlanInput[];
+export declare function mergeManifest(base: DevPortalLocalManifest, override: DevPortalLocalManifest): DevPortalLocalManifest;
+export declare function manifestFilePath(rootDir: string, filename?: string): string;
+export declare function manifestPathsForEnv(rootDir: string, env: ApitogoManifestEnv): {
+    basePath: string;
+    overridePath: string;
+    watchPaths: string[];
+};
 export declare function parseLocalManifestJson(raw: string): DevPortalLocalManifest | null;
+export declare function readManifestFile(rootDir: string, filename: string): Promise<DevPortalLocalManifest | null>;
+export declare function readEffectiveManifest(rootDir: string, env: ApitogoManifestEnv): Promise<DevPortalLocalManifest | null>;
 export declare function readLocalManifest(rootDir: string): Promise<DevPortalLocalManifest | null>;

package/docs/configuration/authentication.md

@@ -46,16 +46,16 @@ VITE_APITOGO_DEV_PORTAL_API_URL=https://your-dev-portal-api.example.com
 
 **Local preview:** When the backend URL is a placeholder or unreachable, the account area shows a
 message that sign-in unlocks after publish. Docs and API reference remain public. Plans on
-`/pricing` load from `apitogo.local.json` (including `includedActionKeys` per plan). Plan edits
-hot-reload without restarting the dev server.
+`/pricing` load from `apitogo.json` with optional `apitogo.local.json` overrides (including
+`includedActionKeys` per plan). Plan edits hot-reload without restarting the dev server.
 
 ### Dev portal configuration files
 
-| Concern | File |
-| --- | --- |
-| Site nav, docs, plugins, auth wiring | `apitogo.config.tsx` |
-| Plans, rate limits, `includedActionKeys`, project/deploy metadata | `apitogo.local.json` |
-| OIDC and Stripe for publish (MCP only) | `apitogo.local.secrets.json` |
+| Concern                                                           | File                                                             |
+| ----------------------------------------------------------------- | ---------------------------------------------------------------- |
+| Site nav, docs, plugins, auth wiring                              | `apitogo.config.tsx`                                             |
+| Plans, rate limits, `includedActionKeys`, project/deploy metadata | `apitogo.json` (+ env overrides — see [Manifest](./manifest.md)) |
+| OIDC and Stripe for publish (MCP only)                            | `apitogo.local.secrets.json`                                     |
 
 **Production:** Register one OIDC app with redirect URI `https://{backend}/signin-oidc` (see MCP
 `manualSteps.oidcRedirectUri`). The frontend uses cookie sessions via `credentials: "include"` on

package/docs/configuration/manifest.md

@@ -0,0 +1,116 @@
+---
+title: Manifest (apitogo.json)
+sidebar_icon: file-json
+---
+
+Dev portal sites provisioned through APItoGo use JSON manifest files for plans, branding, backend
+paths, and gateway settings. Shared defaults live in **`apitogo.json`**; optional per-environment
+files override values without duplicating the full config.
+
+## Files
+
+| File                         | When used        | Purpose                                                                   |
+| ---------------------------- | ---------------- | ------------------------------------------------------------------------- |
+| `apitogo.json`               | Always (base)    | Committed defaults: `siteName`, `branding`, `plans`, `backend`, `gateway` |
+| `apitogo.local.json`         | `npm run dev`    | Local-only overrides (optional)                                           |
+| `apitogo.prod.json`          | `npm run build`  | Production build overrides (optional)                                     |
+| `apitogo.local.secrets.json` | MCP publish only | OIDC and Stripe credentials — never loaded by the dev server              |
+
+New scaffolds ship `apitogo.json` plus `apitogo.local.example.json` and `apitogo.prod.example.json`
+to show how overrides work. Copy or rename the examples when you need environment-specific values.
+
+## Resolution
+
+At dev and build time the tooling merges the base file with the environment override:
+
+```mermaid
+flowchart LR
+  base["apitogo.json"]
+  local["apitogo.local.json"]
+  prod["apitogo.prod.json"]
+  devMerge["merge"]
+  buildMerge["merge"]
+  viteDev["npm run dev"]
+  viteBuild["npm run build"]
+
+  base --> devMerge
+  local --> devMerge
+  base --> buildMerge
+  prod --> buildMerge
+  viteDev --> devMerge
+  buildMerge --> viteBuild
+```
+
+- **Local preview** (`npm run dev`): `apitogo.json` + `apitogo.local.json`
+- **Production build** (`npm run build`): `apitogo.json` + `apitogo.prod.json`
+- **Deployed site**: plans are served from the live dev-portal API (`GET /api/v1/plans`), not from
+  JSON files in the browser bundle
+
+If `apitogo.json` is missing but `apitogo.local.json` exists, the local file is used as the full
+manifest (legacy single-file projects).
+
+## Merge rules
+
+Override files patch the base manifest:
+
+- Top-level keys: override wins
+- `branding`, `backend`, `gateway`: deep-merged (override fields patch nested objects)
+- `plans`: merged by `sku` — an override plan with the same SKU updates only the fields you specify
+
+Example base (`apitogo.json`):
+
+```json
+{
+  "siteName": "My API",
+  "branding": { "title": "My API" },
+  "plans": [
+    {
+      "sku": "pro",
+      "displayName": "Pro",
+      "isFree": false,
+      "priceAmount": 9.99,
+      "billingPeriod": "month"
+    }
+  ]
+}
+```
+
+Example local override (`apitogo.local.json`):
+
+```json
+{
+  "projectId": "your-local-project-id",
+  "backend": { "sourceDirectory": "../my-api" }
+}
+```
+
+Example production override (`apitogo.prod.json`):
+
+```json
+{
+  "plans": [{ "sku": "pro", "priceAmount": 19.99 }],
+  "backend": { "deployed": true }
+}
+```
+
+## What to put where
+
+| Concern                                      | Recommended file                                                         |
+| -------------------------------------------- | ------------------------------------------------------------------------ |
+| Plans, rate limits, `includedActionKeys`     | `apitogo.json` (shared)                                                  |
+| Branding, site name                          | `apitogo.json`                                                           |
+| Backend paths, OpenAPI location              | `apitogo.json`; machine-specific paths in `apitogo.local.json`           |
+| `projectId` after bootstrap                  | `apitogo.local.json` until MCP writes to the correct file                |
+| Production-only plan pricing or deploy flags | `apitogo.prod.json`                                                      |
+| OIDC / Stripe                                | `apitogo.local.secrets.json` (see [Authentication](./authentication.md)) |
+
+## Hot reload
+
+During `npm run dev`, changes to `apitogo.json` or `apitogo.local.json` hot-reload on `/pricing`
+without restarting the server. Restart the dev server after changing
+`VITE_APITOGO_DEV_PORTAL_API_URL` in `.env`.
+
+## Related configuration
+
+- Site navigation, docs, and plugins: [`apitogo.config.tsx`](./overview.md)
+- Authentication for dev-portal sites: [Authentication](./authentication.md)

package/docs/quickstart.md

@@ -25,8 +25,8 @@ have you up and running with a modern, customizable site that your developers wi
    npm create @lukoweb/apitogo@latest
    ```
 
-   The CLI will walk you through setting up your project with interactive prompts. Choose from
-   templates like API documentation, developer portals, or start from scratch.
+   The CLI will walk you through setting up your project with interactive prompts. By default you
+   get an empty dev-portal site; opt in to include starter example docs and an OpenAPI spec.
 
 1. **Navigate to your project:**
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lukoweb/apitogo",
-  "version": "0.1.47",
+  "version": "0.1.49",
   "type": "module",
   "sideEffects": [
     "**/*.css",

package/src/config/local-manifest.ts

@@ -1,15 +1,20 @@
-import { readFile } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 
+/** @deprecated Use {@link APITOGO_MANIFEST_ENV_FILES.development} — kept for external consumers. */
 export const DEV_PORTAL_MANIFEST_FILENAME = "apitogo.local.json";
 
-const BillingPeriodSchema = z.enum([
-  "month",
-  "year",
-  "monthly",
-  "annual",
-]);
+export const APITOGO_MANIFEST_BASE_FILENAME = "apitogo.json";
+
+export const APITOGO_MANIFEST_ENV_FILES = {
+  development: "apitogo.local.json",
+  production: "apitogo.prod.json",
+} as const;
+
+export type ApitogoManifestEnv = keyof typeof APITOGO_MANIFEST_ENV_FILES;
+
+const BillingPeriodSchema = z.enum(["month", "year", "monthly", "annual"]);
 
 export const ManifestPlanInputSchema = z.object({
   sku: z.string().min(1),
@@ -30,6 +35,11 @@ export const DevPortalLocalManifestSchema = z.object({
       logoUrl: z.string().optional(),
     })
     .optional(),
+  pricing: z
+    .object({
+      enabled: z.boolean().optional(),
+    })
+    .optional(),
   plans: z.array(ManifestPlanInputSchema).optional(),
   backend: z
     .object({
@@ -56,7 +66,9 @@ export const DevPortalLocalManifestSchema = z.object({
 });
 
 export type ManifestPlanInput = z.infer<typeof ManifestPlanInputSchema>;
-export type DevPortalLocalManifest = z.infer<typeof DevPortalLocalManifestSchema>;
+export type DevPortalLocalManifest = z.infer<
+  typeof DevPortalLocalManifestSchema
+>;
 
 export type DevPortalPreviewPlan = {
   sku: string;
@@ -70,9 +82,27 @@ export type DevPortalPreviewPlan = {
 };
 
 export type DevPortalPreviewPlanCatalog = {
+  pricingEnabled: boolean;
   plans: DevPortalPreviewPlan[];
 };
 
+export function isPricingEnabled(
+  manifest: DevPortalLocalManifest | null | undefined,
+): boolean {
+  return manifest?.pricing?.enabled === true;
+}
+
+export function manifestToPreviewCatalog(
+  manifest: DevPortalLocalManifest | null | undefined,
+): DevPortalPreviewPlanCatalog {
+  const plans = manifest?.plans;
+  const catalog = plansToPreviewCatalog(plans);
+  return {
+    pricingEnabled: isPricingEnabled(manifest),
+    plans: catalog.plans,
+  };
+}
+
 export function normalizeBillingPeriod(period?: string): string {
   if (!period) {
     return "monthly";
@@ -90,7 +120,7 @@ export function normalizeBillingPeriod(period?: string): string {
 
 export function plansToPreviewCatalog(
   plans: ManifestPlanInput[] | undefined,
-): DevPortalPreviewPlanCatalog {
+): Pick<DevPortalPreviewPlanCatalog, "plans"> {
   if (!plans?.length) {
     return { plans: [] };
   }
@@ -109,8 +139,70 @@ export function plansToPreviewCatalog(
   };
 }
 
-export function manifestFilePath(rootDir: string): string {
-  return path.join(path.resolve(rootDir), DEV_PORTAL_MANIFEST_FILENAME);
+export function resolveManifestEnv(viteMode: string): ApitogoManifestEnv {
+  return viteMode === "production" ? "production" : "development";
+}
+
+export function mergePlansBySku(
+  existing: ManifestPlanInput[] | undefined,
+  patch: ManifestPlanInput[],
+): ManifestPlanInput[] {
+  const bySku = new Map<string, ManifestPlanInput>();
+  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());
+}
+
+export function mergeManifest(
+  base: DevPortalLocalManifest,
+  override: DevPortalLocalManifest,
+): DevPortalLocalManifest {
+  const merged: DevPortalLocalManifest = { ...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;
+}
+
+export function manifestFilePath(rootDir: string, filename?: string): string {
+  return path.join(
+    path.resolve(rootDir),
+    filename ?? DEV_PORTAL_MANIFEST_FILENAME,
+  );
+}
+
+export function manifestPathsForEnv(
+  rootDir: string,
+  env: ApitogoManifestEnv,
+): { basePath: string; overridePath: string; watchPaths: string[] } {
+  const resolvedRoot = path.resolve(rootDir);
+  const basePath = path.join(resolvedRoot, APITOGO_MANIFEST_BASE_FILENAME);
+  const overridePath = path.join(resolvedRoot, APITOGO_MANIFEST_ENV_FILES[env]);
+
+  return {
+    basePath,
+    overridePath,
+    watchPaths: [basePath, overridePath],
+  };
 }
 
 export function parseLocalManifestJson(
@@ -128,10 +220,20 @@ export function parseLocalManifestJson(
   }
 }
 
-export async function readLocalManifest(
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function readManifestFile(
   rootDir: string,
+  filename: string,
 ): Promise<DevPortalLocalManifest | null> {
-  const filePath = manifestFilePath(rootDir);
+  const filePath = manifestFilePath(rootDir, filename);
 
   try {
     const raw = await readFile(filePath, "utf8");
@@ -140,3 +242,53 @@ export async function readLocalManifest(
     return null;
   }
 }
+
+export async function readEffectiveManifest(
+  rootDir: string,
+  env: ApitogoManifestEnv,
+): Promise<DevPortalLocalManifest | null> {
+  const { basePath, overridePath } = manifestPathsForEnv(rootDir, env);
+  const hasBase = await fileExists(basePath);
+  const hasOverride = await fileExists(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);
+}
+
+export async function readLocalManifest(
+  rootDir: string,
+): Promise<DevPortalLocalManifest | null> {
+  return readEffectiveManifest(rootDir, "development");
+}

package/src/vite/dev-portal-env.ts

@@ -1,4 +1,4 @@
-import path from "node:path";
+
 import { loadEnv } from "vite";
 
 export const DEV_PORTAL_VITE_ENV_KEYS = [

package/src/vite/plugin-local-manifest.ts

@@ -1,27 +1,29 @@
 import path from "node:path";
 import type { Plugin, ResolvedConfig } from "vite";
 import {
-  DEV_PORTAL_MANIFEST_FILENAME,
-  manifestFilePath,
-  parseLocalManifestJson,
-  plansToPreviewCatalog,
+  manifestPathsForEnv,
+  manifestToPreviewCatalog,
+  readEffectiveManifest,
+  resolveManifestEnv,
 } from "../config/local-manifest.js";
 
-export const APITOGO_LOCAL_MANIFEST_VIRTUAL_ID = "virtual:apitogo-local-manifest";
+export const APITOGO_LOCAL_MANIFEST_VIRTUAL_ID =
+  "virtual:apitogo-local-manifest";
+
 const resolvedVirtualModuleId = `\0${APITOGO_LOCAL_MANIFEST_VIRTUAL_ID}`;
 
 const viteLocalManifestPlugin = (): Plugin => {
   let rootDir = "";
-  let manifestPath = "";
+  let viteMode = "development";
+  let watchPaths: string[] = [];
 
   const loadManifestModule = async (): Promise<string> => {
-    const { readFile } = await import("node:fs/promises");
-    let catalog = { plans: [] as ReturnType<typeof plansToPreviewCatalog>["plans"] };
+    const env = resolveManifestEnv(viteMode);
+    let catalog = manifestToPreviewCatalog(null);
 
     try {
-      const raw = await readFile(manifestPath, "utf8");
-      const manifest = parseLocalManifestJson(raw);
-      catalog = plansToPreviewCatalog(manifest?.plans);
+      const manifest = await readEffectiveManifest(rootDir, env);
+      catalog = manifestToPreviewCatalog(manifest);
     } catch {
       // Missing or invalid manifest — empty catalog for preview.
     }
@@ -33,7 +35,9 @@ const viteLocalManifestPlugin = (): Plugin => {
     name: "apitogo-local-manifest-plugin",
     configResolved(resolvedConfig: ResolvedConfig) {
       rootDir = resolvedConfig.root;
-      manifestPath = manifestFilePath(rootDir);
+      viteMode = resolvedConfig.mode;
+      const env = resolveManifestEnv(viteMode);
+      watchPaths = manifestPathsForEnv(rootDir, env).watchPaths;
     },
     resolveId(id) {
       if (id === APITOGO_LOCAL_MANIFEST_VIRTUAL_ID) {
@@ -48,11 +52,13 @@ const viteLocalManifestPlugin = (): Plugin => {
       return loadManifestModule();
     },
     configureServer(server) {
-      const watchPath = path.join(rootDir, DEV_PORTAL_MANIFEST_FILENAME);
+      for (const watchPath of watchPaths) {
+        server.watcher.add(watchPath);
+      }
 
-      server.watcher.add(watchPath);
       server.watcher.on("change", async (changedPath) => {
-        if (path.resolve(changedPath) !== path.resolve(manifestPath)) {
+        const resolvedChanged = path.resolve(changedPath);
+        if (!watchPaths.some((p) => path.resolve(p) === resolvedChanged)) {
           return;
         }
 

package/src/vite/plugin.ts

@@ -11,13 +11,13 @@ import viteConfigPlugin from "./plugin-config.js";
 import viteCustomPagesPlugin from "./plugin-custom-pages.js";
 import { viteDocMetadataPlugin } from "./plugin-doc-metadata.js";
 import viteDocsPlugin from "./plugin-docs.js";
+import viteLocalManifestPlugin from "./plugin-local-manifest.js";
 import viteMarkdownExportPlugin from "./plugin-markdown-export.js";
 import viteMdxPlugin from "./plugin-mdx.js";
 import viteModulesPlugin from "./plugin-modules.js";
 import { viteNavigationPlugin } from "./plugin-navigation.js";
 import { viteSearchPlugin } from "./plugin-search.js";
 import { viteShikiRegisterPlugin } from "./plugin-shiki-register.js";
-import viteLocalManifestPlugin from "./plugin-local-manifest.js";
 import { viteThemePlugin } from "./plugin-theme.js";
 
 export default function vitePlugin(): PluginOption {