@riverbankcms/sdk 0.7.5 → 0.8.0

package/dist/cli/index.js

@@ -3,7 +3,7 @@
 
 var jiti = require('jiti');
 var path9 = require('path');
-var fs = require('fs');
+var fs6 = require('fs');
 var dotenv = require('dotenv');
 var commander = require('commander');
 var zod = require('zod');
@@ -13,6 +13,10 @@ var readline = require('readline');
 var equal = require('fast-deep-equal');
 var os = require('os');
 var child_process = require('child_process');
+var simpleGit = require('simple-git');
+require('react');
+require('react/jsx-runtime');
+var crypto2 = require('crypto');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -36,14 +40,19 @@ function _interopNamespace(e) {
 }
 
 var path9__namespace = /*#__PURE__*/_interopNamespace(path9);
+var fs6__namespace = /*#__PURE__*/_interopNamespace(fs6);
 var prompts__default = /*#__PURE__*/_interopDefault(prompts);
 var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
 var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
 var equal__default = /*#__PURE__*/_interopDefault(equal);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
+var simpleGit__default = /*#__PURE__*/_interopDefault(simpleGit);
+var crypto2__namespace = /*#__PURE__*/_interopNamespace(crypto2);
 
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -51,6 +60,15 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/cli/load-config.ts
 var load_config_exports = {};
@@ -59,7 +77,7 @@ __export(load_config_exports, {
 });
 async function loadConfigFile(configPath) {
   const resolvedPath = resolveConfigPath(configPath);
-  if (!fs.existsSync(resolvedPath)) {
+  if (!fs6.existsSync(resolvedPath)) {
     throw new Error(
       `Config file not found: ${resolvedPath}
 Create a riverbank.config.ts file or specify a path with --config`
@@ -90,7 +108,7 @@ function resolveConfigPath(configPath) {
     return path9.resolve(process.cwd(), DEFAULT_CONFIG_FILENAME);
   }
   const resolved = path9.resolve(configPath);
-  if (fs.existsSync(resolved) && !resolved.endsWith(".ts") && !resolved.endsWith(".js")) {
+  if (fs6.existsSync(resolved) && !resolved.endsWith(".ts") && !resolved.endsWith(".js")) {
     return path9.resolve(resolved, DEFAULT_CONFIG_FILENAME);
   }
   return resolved;
@@ -102,6 +120,240 @@ var init_load_config = __esm({
   }
 });
 
+// src/constants.ts
+var PREBUILD_PAGE_SIZE, DEFAULT_MAX_PREBUILD_AGE_SEC, DEFAULT_PREBUILD_DIR;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    PREBUILD_PAGE_SIZE = 50;
+    DEFAULT_MAX_PREBUILD_AGE_SEC = 86400;
+    DEFAULT_PREBUILD_DIR = ".riverbank-cache";
+  }
+});
+
+// src/prebuild/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  PrebuildLoader: () => PrebuildLoader,
+  canUsePrebuild: () => canUsePrebuild,
+  createPrebuildLoader: () => createPrebuildLoader
+});
+function loadManifest(prebuildDir) {
+  if (cachedManifest?.dir === prebuildDir) {
+    return cachedManifest.manifest;
+  }
+  const manifestPath = path9__namespace.join(prebuildDir, "manifest.json");
+  if (!fs6__namespace.existsSync(manifestPath)) {
+    return null;
+  }
+  try {
+    const content = fs6__namespace.readFileSync(manifestPath, "utf-8");
+    const manifest = JSON.parse(content);
+    cachedManifest = { manifest, dir: prebuildDir };
+    return manifest;
+  } catch {
+    return null;
+  }
+}
+function loadJsonFile(prebuildDir, relativePath) {
+  const filePath = path9__namespace.join(prebuildDir, relativePath);
+  if (!fs6__namespace.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = fs6__namespace.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function isPrebuildExpired(manifest, maxAgeSec) {
+  const ageMs = Date.now() - new Date(manifest.generatedAt).getTime();
+  return ageMs > maxAgeSec * 1e3;
+}
+function getPrebuildAgeSec(manifest) {
+  const ageMs = Date.now() - new Date(manifest.generatedAt).getTime();
+  return Math.floor(ageMs / 1e3);
+}
+function canUsePrebuild() {
+  if (typeof process === "undefined" || !process.versions?.node) {
+    return false;
+  }
+  try {
+    return typeof fs6__namespace.existsSync === "function";
+  } catch {
+    return false;
+  }
+}
+function createPrebuildLoader(config3) {
+  return new PrebuildLoader(config3);
+}
+var cachedManifest, PrebuildLoader;
+var init_loader = __esm({
+  "src/prebuild/loader.ts"() {
+    init_constants();
+    cachedManifest = null;
+    PrebuildLoader = class {
+      constructor(config3) {
+        this.prebuildDir = config3.prebuildDir ?? DEFAULT_PREBUILD_DIR;
+        this.maxPrebuildAgeSec = config3.maxPrebuildAgeSec ?? DEFAULT_MAX_PREBUILD_AGE_SEC;
+      }
+      /**
+       * Check if prebuild is available and not expired.
+       */
+      isAvailable() {
+        if (!canUsePrebuild()) {
+          return false;
+        }
+        const manifest = loadManifest(this.prebuildDir);
+        if (!manifest) {
+          return false;
+        }
+        return !isPrebuildExpired(manifest, this.maxPrebuildAgeSec);
+      }
+      /**
+       * Load site data from prebuild cache.
+       */
+      loadSite(siteId) {
+        const manifest = loadManifest(this.prebuildDir);
+        if (!manifest || isPrebuildExpired(manifest, this.maxPrebuildAgeSec)) {
+          return null;
+        }
+        const cacheFile = loadJsonFile(this.prebuildDir, "site.json");
+        if (!cacheFile || cacheFile.data.site.id !== siteId) {
+          return null;
+        }
+        return {
+          data: cacheFile.data,
+          prebuildAgeSec: getPrebuildAgeSec(manifest)
+        };
+      }
+      /**
+       * Load page data from prebuild cache.
+       */
+      loadPage(siteId, pagePath) {
+        const manifest = loadManifest(this.prebuildDir);
+        if (!manifest || isPrebuildExpired(manifest, this.maxPrebuildAgeSec)) {
+          return null;
+        }
+        const cacheKey = `page:${siteId}:${pagePath}:false`;
+        const relativePath = manifest.keyToFile[cacheKey];
+        if (!relativePath) {
+          return null;
+        }
+        const cacheFile = loadJsonFile(this.prebuildDir, relativePath);
+        if (!cacheFile) {
+          return null;
+        }
+        return {
+          data: cacheFile.data,
+          prebuildAgeSec: getPrebuildAgeSec(manifest)
+        };
+      }
+      /**
+       * Load entries from prebuild cache with runtime filtering.
+       *
+       * The prebuild stores ALL entries for each content type.
+       * Filtering, ordering, and pagination are applied at runtime.
+       */
+      loadEntries(siteId, params) {
+        if (params.preview) {
+          return null;
+        }
+        if (params.mode === "manual" && params.entryIds?.length) {
+          return null;
+        }
+        const manifest = loadManifest(this.prebuildDir);
+        if (!manifest || isPrebuildExpired(manifest, this.maxPrebuildAgeSec)) {
+          return null;
+        }
+        const cacheKey = `entries-all:${siteId}:${params.contentType}`;
+        const relativePath = manifest.keyToFile[cacheKey];
+        if (!relativePath) {
+          return null;
+        }
+        const cacheFile = loadJsonFile(this.prebuildDir, relativePath);
+        if (!cacheFile) {
+          return null;
+        }
+        let entries = [...cacheFile.entries];
+        if (params.order === "newest") {
+          entries.sort((a, b) => {
+            const aTime = a.publishedAt ? new Date(a.publishedAt).getTime() : 0;
+            const bTime = b.publishedAt ? new Date(b.publishedAt).getTime() : 0;
+            return bTime - aTime;
+          });
+        } else if (params.order === "oldest") {
+          entries.sort((a, b) => {
+            const aTime = a.publishedAt ? new Date(a.publishedAt).getTime() : 0;
+            const bTime = b.publishedAt ? new Date(b.publishedAt).getTime() : 0;
+            return aTime - bTime;
+          });
+        } else if (params.order === "title") {
+          entries.sort((a, b) => (a.title || "").localeCompare(b.title || ""));
+        }
+        const total = entries.length;
+        const offset = params.offset ?? 0;
+        const limit = params.limit ?? 10;
+        if (offset > 0) {
+          entries = entries.slice(offset);
+        }
+        entries = entries.slice(0, limit);
+        const prebuildAgeSec = getPrebuildAgeSec(manifest);
+        if (params.includeMeta) {
+          return {
+            data: {
+              entries,
+              total,
+              hasMore: offset + entries.length < total,
+              limit,
+              offset,
+              totalPages: Math.ceil(total / limit),
+              currentPage: Math.floor(offset / limit) + 1
+            },
+            prebuildAgeSec
+          };
+        }
+        return {
+          data: { entries },
+          prebuildAgeSec
+        };
+      }
+      /**
+       * Load navigation data from prebuild cache.
+       */
+      loadNavigation() {
+        const manifest = loadManifest(this.prebuildDir);
+        if (!manifest || isPrebuildExpired(manifest, this.maxPrebuildAgeSec)) {
+          return null;
+        }
+        const cacheFile = loadJsonFile(
+          this.prebuildDir,
+          "navigation/menus.json"
+        );
+        if (!cacheFile) {
+          return null;
+        }
+        return {
+          data: cacheFile.menus,
+          prebuildAgeSec: getPrebuildAgeSec(manifest)
+        };
+      }
+      /**
+       * Get the manifest for inspection.
+       */
+      getManifest() {
+        return loadManifest(this.prebuildDir);
+      }
+      /**
+       * Clear the cached manifest (for testing).
+       */
+      clearCache() {
+        cachedManifest = null;
+      }
+    };
+  }
+});
+
 // ../blocks/src/system/manifest/augmentManifest.ts
 function augmentManifest(manifest) {
   let augmentedFields = manifest.fields ?? [];
@@ -574,11 +826,11 @@ function bind(from, options) {
     }
   });
 }
-function when(path11, options) {
+function when(path13, options) {
   return (node) => ({
     ...node,
     $when: {
-      when: { from: path11 },
+      when: { from: path13 },
       ...options?.equals !== void 0 ? { equals: options.equals } : {},
       ...options?.not ? { not: true } : {}
     }
@@ -651,25 +903,25 @@ function devValidate(node) {
 }
 
 // ../blocks/src/system/node/fragments/backgroundLayer.ts
-function backgroundLayer(path11, options = {}) {
+function backgroundLayer(path13, options = {}) {
   const {
     styleClassName = "absolute inset-0 -z-10 h-full w-full pointer-events-none",
     imageClassName
   } = options;
   const styleLayer = el("div", {
-    className: { $bind: { from: path11, transforms: [{ id: "background.resolveClass", options: { baseClass: styleClassName } }] } },
-    style: { $bind: { from: path11, transforms: [{ id: "background.resolveStyle" }] } }
+    className: { $bind: { from: path13, transforms: [{ id: "background.resolveClass", options: { baseClass: styleClassName } }] } },
+    style: { $bind: { from: path13, transforms: [{ id: "background.resolveStyle" }] } }
   });
-  const imageLayer = createBackgroundImageNode(path11, imageClassName);
+  const imageLayer = createBackgroundImageNode(path13, imageClassName);
   return [styleLayer, imageLayer];
 }
-function createBackgroundImageNode(path11, baseClassName = "absolute -z-10") {
-  const imagePath = `${path11}.image`;
+function createBackgroundImageNode(path13, baseClassName = "absolute -z-10") {
+  const imagePath = `${path13}.image`;
   return media(
     {
       className: {
         $bind: {
-          from: path11,
+          from: path13,
           transforms: [{
             id: "background.resolveImageClassName",
             options: { baseClass: `background-image ${baseClassName}` }
@@ -678,7 +930,7 @@ function createBackgroundImageNode(path11, baseClassName = "absolute -z-10") {
       },
       style: {
         $bind: {
-          from: path11,
+          from: path13,
           transforms: [{ id: "background.resolveImageStyle" }]
         }
       }
@@ -1106,27 +1358,27 @@ function scopePropValue(value, scope) {
   }
   return value;
 }
-function scopeContentPath(path11, scope) {
+function scopeContentPath(path13, scope) {
   if (!scope || scope.length === 0) {
-    return path11;
+    return path13;
   }
-  if (path11 === "content") {
+  if (path13 === "content") {
     return `content.${scope}`;
   }
-  if (path11.startsWith("content.")) {
-    const remainder = path11.slice("content.".length);
+  if (path13.startsWith("content.")) {
+    const remainder = path13.slice("content.".length);
     return remainder.length > 0 ? `content.${scope}.${remainder}` : `content.${scope}`;
   }
-  if (path11.startsWith("content[")) {
-    return path11.replace(/^content/, `content.${scope}`);
+  if (path13.startsWith("content[")) {
+    return path13.replace(/^content/, `content.${scope}`);
   }
-  if (path11.startsWith("$root.")) {
-    return path11;
+  if (path13.startsWith("$root.")) {
+    return path13;
   }
-  if (path11.includes(".")) {
-    return path11;
+  if (path13.includes(".")) {
+    return path13;
   }
-  return `content.${scope}.${path11}`;
+  return `content.${scope}.${path13}`;
 }
 
 // ../blocks/src/system/fragments/builder.ts
@@ -5133,7 +5385,7 @@ var contentConfigSchema = contentConfigBaseSchema.superRefine((data, ctx) => {
       });
     }
     const paths = data.pages.map((p) => p.path);
-    const duplicatePaths = paths.filter((path11, i) => paths.indexOf(path11) !== i);
+    const duplicatePaths = paths.filter((path13, i) => paths.indexOf(path13) !== i);
     if (duplicatePaths.length > 0) {
       ctx.addIssue({
         code: zod.z.ZodIssueCode.custom,
@@ -5510,8 +5762,8 @@ var ManagementApiError = class extends Error {
 function createHttpClient(config3) {
   const baseUrl = `${config3.dashboardUrl}/api/sdk/${config3.siteId}`;
   const timeout = config3.timeout ?? 3e4;
-  async function request(method, path11, options) {
-    let url = `${baseUrl}${path11}`;
+  async function request(method, path13, options) {
+    let url = `${baseUrl}${path13}`;
     if (options?.params && Object.keys(options.params).length > 0) {
       const searchParams = new URLSearchParams(options.params);
       url = `${url}?${searchParams.toString()}`;
@@ -5579,17 +5831,17 @@ function createHttpClient(config3) {
     return json.data;
   }
   return {
-    async get(path11, params) {
-      return request("GET", path11, { params });
+    async get(path13, params) {
+      return request("GET", path13, { params });
     },
-    async post(path11, body) {
-      return request("POST", path11, { body });
+    async post(path13, body) {
+      return request("POST", path13, { body });
     },
-    async patch(path11, body) {
-      return request("PATCH", path11, { body });
+    async patch(path13, body) {
+      return request("PATCH", path13, { body });
     },
-    async delete(path11, body) {
-      await request("DELETE", path11, { body });
+    async delete(path13, body) {
+      await request("DELETE", path13, { body });
     }
   };
 }
@@ -6748,11 +7000,11 @@ function findChangedFields(local, remote, prefix = "") {
   const changes = [];
   const allKeys = /* @__PURE__ */ new Set([...Object.keys(local), ...Object.keys(remote)]);
   for (const key of allKeys) {
-    const path11 = prefix ? `${prefix}.${key}` : key;
+    const path13 = prefix ? `${prefix}.${key}` : key;
     const localVal = local[key];
     const remoteVal = remote[key];
     if (!equal__default.default(localVal, remoteVal)) {
-      changes.push(path11);
+      changes.push(path13);
     }
   }
   return changes;
@@ -8505,7 +8757,7 @@ function getContentDir() {
 function loadTemplate(name) {
   const contentDir = getContentDir();
   const filePath = path9__namespace.join(contentDir, `${name}.md`);
-  return fs.readFileSync(filePath, "utf-8");
+  return fs6.readFileSync(filePath, "utf-8");
 }
 async function initDocs(options) {
   const { rootDir, configPath, agentsPath } = options;
@@ -8692,6 +8944,3407 @@ Examples:
   $ riverbankcms identifiers backfill
 `).addCommand(backfillCommand);
 
+// src/cli/commands/deploy.ts
+init_load_config();
+
+// ../api/src/endpoints.ts
+var ENDPOINT_DEFINITIONS = {
+  // AI endpoints - no cache due to dynamic nature
+  aiContentUpdateChat: {
+    path: "/ai/content-update-chat",
+    method: "POST",
+    auth: "user",
+    responseKind: "stream"
+  },
+  aiChat: {
+    path: "/ai/chat",
+    method: "POST",
+    auth: "user",
+    responseKind: "stream"
+  },
+  applySeoChanges: {
+    path: "/seo/apply",
+    method: "POST",
+    auth: "user",
+    responseKind: "json"
+  },
+  aiCreateBriefChat: {
+    path: "/ai/chat/create-brief",
+    method: "POST",
+    auth: "user",
+    responseKind: "json"
+  },
+  aiPrototypeChat: {
+    path: "/ai/chat/create-prototype",
+    method: "POST",
+    revalidate: 30,
+    // Short cache for AI responses to avoid duplicate calls
+    tags: ["ai-prototype"],
+    auth: "user",
+    responseKind: "json"
+  },
+  aiPatchDryRun: {
+    path: "/ai/patch/dry-run",
+    method: "POST",
+    auth: "user",
+    responseKind: "json"
+  },
+  aiPatchApply: {
+    path: "/ai/patch/apply",
+    method: "POST",
+    auth: "user",
+    responseKind: "json"
+  },
+  aiPlaygroundPropose: {
+    path: "/sites/{siteId}/ai/playground/propose",
+    method: "POST",
+    auth: "user",
+    responseKind: "json"
+  },
+  // Admin SEO
+  listGscPropertiesAdmin: {
+    path: "/admin/seo/gsc/properties",
+    method: "GET",
+    auth: "admin",
+    responseKind: "json"
+  },
+  adminSetGscPersist: {
+    path: "/admin/seo/gsc/meta/persist",
+    method: "POST",
+    auth: "admin",
+    responseKind: "json"
+  },
+  adminStartGscVerification: {
+    path: "/admin/seo/gsc/properties/verify/start",
+    method: "POST",
+    auth: "admin",
+    responseKind: "json"
+  },
+  adminConfirmGscVerification: {
+    path: "/admin/seo/gsc/properties/verify/confirm",
+    method: "POST",
+    auth: "admin",
+    responseKind: "json"
+  },
+  adminRunGscIngest: {
+    path: "/admin/seo/ingest/run",
+    method: "POST",
+    auth: "admin",
+    responseKind: "json"
+  },
+  getSeoVerificationMeta: {
+    path: "/public/seo/verification/meta",
+    method: "GET",
+    auth: "public",
+    responseKind: "json"
+  },
+  checkRedirect: {
+    path: "/api/public/content/redirect",
+    method: "GET",
+    revalidate: 86400,
+    // 24 hours - redirects rarely change
+    tags: ["redirect"],
+    auth: "public",
+    responseKind: "json"
+  },
+  listRedirectRules: {
+    path: "/sites/{siteId}/redirects",
+    method: "GET",
+    auth: "user",
+    responseKind: "json"
+  },
+  createRedirectRule: {
+    path: "/sites/{siteId}/redirects",
+    method: "POST",
+    auth: "user",
+    responseKind: "json"
+  },
+  deleteRedirectRule: {
+    path: "/sites/{siteId}/redirects/{ruleId}",
+    method: "DELETE",
+    auth: "user",
+    responseKind: "json"
+  },
+  // API Keys (Account-level - DEPRECATED, use site-scoped endpoints)
+  listApiKeys: {
+    path: "/account/api-keys",
+    method: "GET",
+    auth: "user",
+    responseKind: "json"
+  },
+  createApiKey: {
+    path: "/account/api-keys",
+    method: "POST",
+    auth: "user",
+    responseKind: "json"
+  },
+  revokeApiKey: {
+    path: "/account/api-keys/{keyId}",
+    method: "DELETE",
+    auth: "user",
+    responseKind: "json"
+  },
+  // API Keys (Site-scoped - preferred)
+  listSiteApiKeys: {
+    path: "/sites/{siteId}/api-keys",
+    method: "GET",
+    auth: "user",
+    tags: ["site-{siteId}", "api-keys"],
+    responseKind: "json"
+  },
+  createSiteApiKey: {
+    path: "/sites/{siteId}/api-keys",
+    method: "POST",
+    auth: "user",
+    tags: ["site-{siteId}", "api-keys"],
+    responseKind: "json"
+  },
+  revokeSiteApiKey: {
+    path: "/sites/{siteId}/api-keys/{keyId}",
+    method: "DELETE",
+    auth: "user",
+    tags: ["site-{siteId}", "api-keys"],
+    responseKind: "json"
+  },
+  getSitePreviewKey: {
+    path: "/sites/{siteId}/api-keys/preview",
+    method: "GET",
+    auth: "user",
+    tags: ["site-{siteId}", "api-keys", "preview-key"],
+    responseKind: "json"
+  },
+  regenerateSitePreviewKey: {
+    path: "/sites/{siteId}/api-keys/preview/regenerate",
+    method: "POST",
+    auth: "user",
+    tags: ["site-{siteId}", "api-keys", "preview-key"],
+    responseKind: "json"
+  },
+  getSiteApiKeyAccessLogs: {
+    path: "/sites/{siteId}/api-keys/access-logs",
+    method: "GET",
+    auth: "user",
+    tags: ["site-{siteId}", "api-keys", "access-logs"],
+    responseKind: "json"
+  },
+  // Management API Keys (SDK write operations)
+  listManagementKeys: {
+    path: "/sites/{siteId}/api-keys/management",
+    method: "GET",
+    auth: "user",
+    tags: ["site-{siteId}", "api-keys", "management-keys"],
+    responseKind: "json"
+  },
+  createManagementKey: {
+    path: "/sites/{siteId}/api-keys/management",
+    method: "POST",
+    auth: "user",
+    tags: ["site-{siteId}", "api-keys", "management-keys"],
+    responseKind: "json"
+  },
+  revokeManagementKey: {
+    path: "/sites/{siteId}/api-keys/management",
+    method: "DELETE",
+    auth: "user",
+    tags: ["site-{siteId}", "api-keys", "management-keys"],
+    responseKind: "json"
+  },
+  getBookingSettings: {
+    path: "/sites/{siteId}/bookings/settings",
+    method: "GET",
+    auth: "user",
+    responseKind: "json"
+  },
+  updateBookingSettings: {
+    path: "/sites/{siteId}/bookings/settings",
+    method: "PUT",
+    auth: "user",
+    responseKind: "json"
+  },
+  listAppointmentResources: {
+    path: "/sites/{siteId}/bookings/resources",
+    method: "GET",
+    auth: "user",
+    responseKind: "json"
+  },
+  createAppointmentResource: {
+    path: "/sites/{siteId}/bookings/resources",
+    method: "POST",
+    auth: "user",
+    responseKind: "json"
+  },
+  getAppointmentResource: {
+    path: "/sites/{siteId}/bookings/resources/{resourceId}",
+    method: "GET",
+    auth: "user",
+    responseKind: "json"
+  },
+  updateAppointmentResource: {
+    path: "/sites/{siteId}/bookings/resources/{resourceId}",
+    method: "PUT",
+    auth: "user",
+    responseKind: "json"
+  },
+  deleteAppointmentResource: {
+    path: "/sites/{siteId}/bookings/resources/{resourceId}",
+    method: "DELETE",
+    auth: "user",
+    responseKind: "json"
+  },
+  listAppointmentServices: {
+    path: "/sites/{siteId}/bookings/services",
+    method: "GET",
+    auth: "user",
+    responseKind: "json"
+  },
+  createAppointmentService: {
+    path: "/sites/{siteId}/bookings/services",
+    method: "POST",
+    auth: "user",
+    responseKind: "json"
+  },
+  getAppointmentService: {
+    path: "/sites/{siteId}/bookings/services/{serviceId}",
+    method: "GET",
+    auth: "user",
+    responseKind: "json"
+  },
+  updateAppointmentService: {
+    path: "/sites/{siteId}/bookings/services/{serviceId}",
+    method: "PUT",
+    auth: "user",
+    responseKind: "json"
+  },
+  deleteAppointmentService: {
+    path: "/sites/{siteId}/bookings/services/{serviceId}",
+    method: "DELETE",
+    auth: "user",
+    responseKind: "json"
+  },
+  getAppointmentServicesReference: {
+    path: "/sites/{siteId}/bookings/services/reference",
+    method: "GET",
+    auth: "user",
+    responseKind: "json"
+  },
+  getAppointmentResourcesReference: {
+    path: "/sites/{siteId}/bookings/resources/reference",
+    method: "GET",
+    auth: "user",
+    responseKind: "json"
+  },
+  // Service-Resource linking
+  getResourceServices: {
+    path: "/sites/{siteId}/bookings/resources/{resourceId}/services",
+    method: "GET",
+    auth: "user",
+    responseKind: "json"
+  },
+  updateResourceServices: {
+    path: "/sites/{siteId}/bookings/resources/{resourceId}/services",
+    method: "PUT",
+    auth: "user",
+    responseKind: "json"
+  },
+  getServiceResources: {
+    path: "/sites/{siteId}/bookings/services/{serviceId}/resources",
+    method: "GET",
+    auth: "user",
+    responseKind: "json"
+  },
+  updateServiceResources: {
+    path: "/sites/{siteId}/bookings/services/{serviceId}/resources",
+    method: "PUT",
+    auth: "user",
+    responseKind: "json"
+  },
+  // Availability management
+  listAvailabilityRules: {
+    path: "/sites/{siteId}/bookings/resources/{resourceId}/availability",
+    method: "GET",
+    auth: "user",
+    responseKind: "json"
+  },
+  upsertAvailabilityRule: {
+    path: "/sites/{siteId}/bookings/resources/{resourceId}/availability",
+    method: "POST",
+    auth: "user",
+    responseKind: "json"
+  },
+  deleteAvailabilityRule: {
+    path: "/sites/{siteId}/bookings/resources/{resourceId}/availability/{ruleId}",
+    method: "DELETE",
+    auth: "user",
+    responseKind: "json"
+  },
+  listBlackouts: {
+    path: "/sites/{siteId}/bookings/resources/{resourceId}/blackouts",
+    method: "GET",
+    auth: "user",
+    responseKind: "json"
+  },
+  createBlackout: {
+    path: "/sites/{siteId}/bookings/resources/{resourceId}/blackouts",
+    method: "POST",
+    auth: "user",
+    responseKind: "json"
+  },
+  deleteBlackout: {
+    path: "/sites/{siteId}/bookings/resources/{resourceId}/blackouts/{blackoutId}",
+    method: "DELETE",
+    auth: "user",
+    responseKind: "json"
+  },
+  getAvailableSlots: {
+    path: "/sites/{siteId}/bookings/availability/slots",
+    method: "GET",
+    auth: "user",
+    responseKind: "json"
+  },
+  createAppointment: {
+    path: "/sites/{siteId}/bookings/appointments",
+    method: "POST",
+    auth: "user",
+    responseKind: "json"
+  },
+  // Data retrieval endpoints - good candidates for caching
+  getBrief: {
+    path: "/briefs",
+    method: "GET",
+    revalidate: 120,
+    // 2 minutes
+    tags: ["brief"],
+    auth: "user",
+    responseKind: "json"
+  },
+  // Unified site data endpoint - use this for all site lookups
+  getSite: {
+    path: "/sites",
+    method: "GET",
+    revalidate: 900,
+    // 15 minutes - site data changes less frequently
+    tags: ["site"],
+    auth: "user",
+    responseKind: "json"
+  },
+  // DEPRECATED: Use getSite with ?slug={slug} instead
+  getSiteBySlug: {
+    path: "/sites/by-slug/{slug}",
+    method: "GET",
+    revalidate: 900,
+    // 15 minutes - site data changes less frequently
+    tags: ["site", "site-{slug}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  // DEPRECATED: Use getSite with ?domain={domain} instead
+  getSiteByDomain: {
+    path: "/sites/by-domain/{domain}",
+    method: "GET",
+    revalidate: 900,
+    // 15 minutes - site data changes less frequently
+    tags: ["site", "site-domain-{domain}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  createBriefTurn: {
+    path: "/brief-turns",
+    method: "POST",
+    tags: ["brief"],
+    // Tags for invalidation after mutation
+    auth: "user",
+    responseKind: "json"
+  },
+  upsertBrief: {
+    path: "/briefs",
+    method: "PUT",
+    tags: ["brief"],
+    auth: "user",
+    responseKind: "json"
+  },
+  aiBriefToSpec: {
+    path: "/ai/actions/brief-to-spec",
+    method: "POST",
+    tags: ["brief", "spec"],
+    auth: "user",
+    responseKind: "json"
+  },
+  createSite: {
+    path: "/sites",
+    method: "POST",
+    tags: ["site"],
+    auth: "user",
+    responseKind: "json"
+  },
+  createSiteManual: {
+    path: "/sites/manual",
+    method: "POST",
+    tags: ["site"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateSite: {
+    path: "/sites",
+    method: "PUT",
+    tags: ["site"],
+    auth: "user",
+    responseKind: "json"
+  },
+  deleteSite: {
+    path: "/sites/{siteId}",
+    method: "DELETE",
+    tags: ["site", "site-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  listSiteMembers: {
+    path: "/sites/{siteId}/members",
+    method: "GET",
+    tags: ["site-{siteId}", "site-members-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  inviteSiteMember: {
+    path: "/sites/{siteId}/members",
+    method: "POST",
+    tags: ["site-{siteId}", "site-members-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateSiteMemberRole: {
+    path: "/sites/{siteId}/members/{memberId}",
+    method: "PATCH",
+    tags: ["site-{siteId}", "site-members-{siteId}", "site-member-{memberId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  authLogin: {
+    path: "/auth/login/submit",
+    method: "POST",
+    tags: ["auth"],
+    auth: "public",
+    responseKind: "json"
+  },
+  authForgotPassword: {
+    path: "/auth/forgot/submit",
+    method: "POST",
+    tags: ["auth"],
+    auth: "public",
+    responseKind: "json"
+  },
+  authRegister: {
+    path: "/auth/register/submit",
+    method: "POST",
+    tags: ["auth"],
+    auth: "public",
+    responseKind: "json"
+  },
+  authReauthenticate: {
+    path: "/auth/reauth/submit",
+    method: "POST",
+    tags: ["auth"],
+    auth: "public",
+    responseKind: "json"
+  },
+  lookupSiteDomains: {
+    path: "/sites/{siteId}/domains/lookup",
+    method: "POST",
+    tags: ["site-{siteId}", "site-domains"],
+    auth: "user",
+    responseKind: "json"
+  },
+  registerSiteDomain: {
+    path: "/sites/{siteId}/domains/register",
+    method: "POST",
+    tags: ["site-{siteId}", "site-domains"],
+    auth: "user",
+    responseKind: "json"
+  },
+  addCustomDomain: {
+    path: "/sites/{siteId}/domains/custom",
+    method: "POST",
+    tags: ["site-{siteId}", "site-domains"],
+    auth: "user",
+    responseKind: "json"
+  },
+  removeCustomDomain: {
+    path: "/sites/{siteId}/domains/custom",
+    method: "DELETE",
+    tags: ["site-{siteId}", "site-domains"],
+    auth: "user",
+    responseKind: "json"
+  },
+  syncCustomDomainToEdgeConfig: {
+    path: "/sites/{siteId}/domains/custom/sync",
+    method: "POST",
+    tags: ["site-{siteId}", "site-domains"],
+    auth: "user",
+    responseKind: "json"
+  },
+  removeSiteMember: {
+    path: "/sites/{siteId}/members/{memberId}",
+    method: "DELETE",
+    tags: ["site-{siteId}", "site-members-{siteId}", "site-member-{memberId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  revokeSiteInvitation: {
+    path: "/sites/{siteId}/members/invitations/{invitationId}",
+    method: "DELETE",
+    tags: ["site-{siteId}", "site-members-{siteId}", "site-invite-{invitationId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  transferSiteOwnership: {
+    path: "/sites/{siteId}/members/transfer-ownership",
+    method: "POST",
+    tags: ["site-{siteId}", "site-members-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  listContentEntries: {
+    path: "/sites/{siteId}/content/{type}",
+    method: "GET",
+    revalidate: 60,
+    tags: ["site-{siteId}", "content-{siteId}-{type}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getContentTemplate: {
+    path: "/sites/{siteId}/content/types/{type}/template",
+    method: "GET",
+    revalidate: 60,
+    tags: ["site-{siteId}", "content-template-{siteId}-{type}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateContentTemplateBlock: {
+    path: "/sites/{siteId}/content/types/{type}/template/blocks/{blockId}",
+    method: "PATCH",
+    tags: ["site-{siteId}", "content-template-{siteId}-{type}", "content-template-block-{blockId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  applyContentTemplateAddon: {
+    path: "/sites/{siteId}/content/types/{type}/template/addons",
+    method: "POST",
+    tags: ["site-{siteId}", "content-template-{siteId}-{type}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateContentTemplateBlockBindings: {
+    path: "/sites/{siteId}/content/types/{type}/template/blocks/{blockId}/bindings",
+    method: "PATCH",
+    tags: ["site-{siteId}", "content-template-{siteId}-{type}", "content-template-block-{blockId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  createTemplateBlock: {
+    path: "/sites/{siteId}/content/types/{type}/template/blocks",
+    method: "POST",
+    tags: ["site-{siteId}", "content-template-{siteId}-{type}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  deleteTemplateBlock: {
+    path: "/sites/{siteId}/content/types/{type}/template/blocks/{blockId}",
+    method: "DELETE",
+    tags: ["site-{siteId}", "content-template-{siteId}-{type}", "content-template-block-{blockId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  reorderTemplateBlocks: {
+    path: "/sites/{siteId}/content/types/{type}/template/blocks/reorder",
+    method: "POST",
+    tags: ["site-{siteId}", "content-template-{siteId}-{type}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getTransforms: {
+    path: "/transforms",
+    method: "GET",
+    revalidate: 3600,
+    tags: ["transforms"],
+    auth: "public",
+    responseKind: "json"
+  },
+  createContentEntry: {
+    path: "/sites/{siteId}/content/{type}",
+    method: "POST",
+    tags: ["site-{siteId}", "content-{siteId}-{type}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getContentEntry: {
+    path: "/sites/{siteId}/content/{type}/{entryId}",
+    method: "GET",
+    tags: ["site-{siteId}", "content-{siteId}-{type}", "content-entry-{entryId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateContentEntry: {
+    path: "/sites/{siteId}/content/{type}/{entryId}",
+    method: "PUT",
+    tags: ["site-{siteId}", "content-{siteId}-{type}", "content-entry-{entryId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateContentEntryContent: {
+    path: "/sites/{siteId}/content/{type}/{entryId}/content",
+    method: "PUT",
+    tags: ["site-{siteId}", "content-{siteId}-{type}", "content-entry-{entryId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateRouteMetadata: {
+    path: "/sites/{siteId}/routes/{routeId}/metadata",
+    method: "PATCH",
+    tags: ["site-{siteId}", "route-{routeId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  publishContentEntry: {
+    path: "/sites/{siteId}/content/{type}/{entryId}/publish",
+    method: "POST",
+    tags: ["site-{siteId}", "content-{siteId}-{type}", "content-entry-{entryId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  discardContentEntry: {
+    path: "/sites/{siteId}/content/{type}/{entryId}/discard",
+    method: "POST",
+    tags: ["site-{siteId}", "content-{siteId}-{type}", "content-entry-{entryId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  unpublishContentEntry: {
+    path: "/sites/{siteId}/content/{type}/{entryId}/unpublish",
+    method: "POST",
+    tags: ["site-{siteId}", "content-{siteId}-{type}", "content-entry-{entryId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  // Content types: enable + setup
+  listContentTypes: {
+    path: "/sites/{siteId}/content-types",
+    method: "GET",
+    revalidate: 120,
+    // 2 minutes
+    tags: ["site-{siteId}", "content-types"],
+    auth: "user",
+    responseKind: "json"
+  },
+  enableContentType: {
+    path: "/sites/{siteId}/content-types/{key}/enable",
+    method: "POST",
+    tags: ["site-{siteId}", "content-types", "content-type-{key}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  setupContentType: {
+    path: "/sites/{siteId}/content-types/{key}/setup",
+    method: "POST",
+    tags: ["site-{siteId}", "content-types", "content-type-{key}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  deleteContentEntry: {
+    path: "/sites/{siteId}/content/{type}/{entryId}",
+    method: "DELETE",
+    tags: ["site-{siteId}", "content-{siteId}-{type}", "content-entry-{entryId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateSiteGeneralSettings: {
+    path: "/sites/{siteId}/settings/general",
+    method: "POST",
+    tags: ["site-{siteId}", "site-settings-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getSiteLayoutSettings: {
+    path: "/sites/{siteId}/settings/layout",
+    method: "GET",
+    revalidate: 120,
+    tags: ["site-{siteId}", "site-settings-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateSiteLayoutSettings: {
+    path: "/sites/{siteId}/settings/layout",
+    method: "POST",
+    tags: ["site-{siteId}", "site-settings-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getMaintenanceSettings: {
+    path: "/sites/{siteId}/settings/maintenance",
+    method: "GET",
+    revalidate: 120,
+    tags: ["site-{siteId}", "site-settings-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateMaintenanceSettings: {
+    path: "/sites/{siteId}/settings/maintenance",
+    method: "POST",
+    tags: ["site-{siteId}", "site-settings-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  setHomepage: {
+    path: "/sites/{siteId}/settings/homepage",
+    method: "POST",
+    tags: ["site-{siteId}", "site-homepage"],
+    auth: "user",
+    responseKind: "json"
+  },
+  listAccountDomains: {
+    path: "/domains",
+    method: "GET",
+    tags: ["domains"],
+    auth: "user",
+    responseKind: "json"
+  },
+  searchDomains: {
+    path: "/domains/search",
+    method: "POST",
+    tags: ["domains"],
+    auth: "user",
+    responseKind: "json"
+  },
+  registerDomain: {
+    path: "/domains/register",
+    method: "POST",
+    tags: ["domains"],
+    auth: "user",
+    responseKind: "json"
+  },
+  assignDomain: {
+    path: "/domains/{domainId}/assign",
+    method: "POST",
+    tags: ["domains", "domain-{domainId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  adminStartImpersonation: {
+    path: "/admin/impersonation/start",
+    method: "POST",
+    tags: ["admin", "impersonation"],
+    auth: "user",
+    responseKind: "json"
+  },
+  adminStopImpersonation: {
+    path: "/admin/impersonation/stop",
+    method: "POST",
+    tags: ["admin", "impersonation"],
+    auth: "user",
+    responseKind: "json"
+  },
+  adminAssignRole: {
+    path: "/admin/roles/assign",
+    method: "POST",
+    tags: ["admin", "roles"],
+    auth: "user",
+    responseKind: "json"
+  },
+  adminRevokeRole: {
+    path: "/admin/roles/revoke",
+    method: "POST",
+    tags: ["admin", "roles"],
+    auth: "user",
+    responseKind: "json"
+  },
+  adminChangePlan: {
+    path: "/admin/billing/plan",
+    method: "POST",
+    tags: ["admin", "billing"],
+    auth: "user",
+    responseKind: "json"
+  },
+  changePlan: {
+    path: "/billing/plan/change",
+    method: "POST",
+    tags: ["billing"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mfaTotpEnroll: {
+    path: "/auth/mfa/totp/enroll",
+    method: "POST",
+    tags: ["mfa"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mfaTotpVerify: {
+    path: "/auth/mfa/totp/verify",
+    method: "POST",
+    tags: ["mfa"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mfaTotpActivate: {
+    path: "/auth/mfa/totp/activate",
+    method: "POST",
+    tags: ["mfa"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mfaDeleteFactor: {
+    path: "/auth/mfa/factors/{factorId}",
+    method: "DELETE",
+    tags: ["mfa"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mfaBackupCodesGet: {
+    path: "/auth/mfa/backup-codes",
+    method: "GET",
+    tags: ["mfa"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mfaBackupCodesRotate: {
+    path: "/auth/mfa/backup-codes/rotate",
+    method: "POST",
+    tags: ["mfa"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mfaPhoneEnroll: {
+    path: "/auth/mfa/phone/enroll",
+    method: "POST",
+    tags: ["mfa"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mfaPhoneChallenge: {
+    path: "/auth/mfa/phone/challenge",
+    method: "POST",
+    tags: ["mfa"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mfaPhoneVerify: {
+    path: "/auth/mfa/phone/verify",
+    method: "POST",
+    tags: ["mfa"],
+    auth: "user",
+    responseKind: "json"
+  },
+  accountUpdatePassword: {
+    path: "/account/password/update",
+    method: "POST",
+    tags: ["account"],
+    auth: "user",
+    responseKind: "json"
+  },
+  accountRevokeSessions: {
+    path: "/account/sessions/revoke",
+    method: "POST",
+    tags: ["account"],
+    auth: "user",
+    responseKind: "json"
+  },
+  adminListInvites: {
+    path: "/admin/invites",
+    method: "GET",
+    tags: ["admin", "invites"],
+    auth: "user",
+    responseKind: "json"
+  },
+  adminCreateInvite: {
+    path: "/admin/invites",
+    method: "POST",
+    tags: ["admin", "invites"],
+    auth: "user",
+    responseKind: "json"
+  },
+  adminRevokeInvite: {
+    path: "/admin/invites/{inviteId}",
+    method: "DELETE",
+    tags: ["admin", "invites"],
+    auth: "user",
+    responseKind: "json"
+  },
+  adminCreateUser: {
+    path: "/admin/users",
+    method: "POST",
+    tags: ["admin", "users"],
+    auth: "admin",
+    responseKind: "json"
+  },
+  adminListAllowedDomains: {
+    path: "/admin/allowed-domains",
+    method: "GET",
+    tags: ["admin", "allowed-domains"],
+    auth: "user",
+    responseKind: "json"
+  },
+  adminAddAllowedDomain: {
+    path: "/admin/allowed-domains",
+    method: "POST",
+    tags: ["admin", "allowed-domains"],
+    auth: "user",
+    responseKind: "json"
+  },
+  adminDeleteAllowedDomain: {
+    path: "/admin/allowed-domains/{domainId}",
+    method: "DELETE",
+    tags: ["admin", "allowed-domains"],
+    auth: "user",
+    responseKind: "json"
+  },
+  authAcceptInvite: {
+    path: "/auth/invite/accept",
+    method: "POST",
+    tags: ["auth", "invite"],
+    auth: "user",
+    responseKind: "json"
+  },
+  acceptSiteInvitation: {
+    path: "/sites/invitations/accept",
+    method: "POST",
+    tags: ["site-invitations"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getNavigationMenus: {
+    path: "/sites/{siteId}/navigation/menus",
+    method: "GET",
+    tags: ["site-{siteId}", "navigation"],
+    auth: "user",
+    responseKind: "json"
+  },
+  createNavigationMenu: {
+    path: "/sites/{siteId}/navigation/menus",
+    method: "POST",
+    tags: ["site-{siteId}", "navigation"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateNavigationMenu: {
+    path: "/sites/{siteId}/navigation/menus/{menuId}",
+    method: "PATCH",
+    tags: ["site-{siteId}", "navigation", "navigation-menu-{menuId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  deleteNavigationMenu: {
+    path: "/sites/{siteId}/navigation/menus/{menuId}",
+    method: "DELETE",
+    tags: ["site-{siteId}", "navigation", "navigation-menu-{menuId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  createNavigationItem: {
+    path: "/sites/{siteId}/navigation/menus/{menuId}/items",
+    method: "POST",
+    tags: ["site-{siteId}", "navigation", "navigation-menu-{menuId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateNavigationItem: {
+    path: "/sites/{siteId}/navigation/menus/{menuId}/items/{itemId}",
+    method: "PATCH",
+    tags: ["site-{siteId}", "navigation", "navigation-menu-{menuId}", "navigation-item-{itemId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  deleteNavigationItem: {
+    path: "/sites/{siteId}/navigation/menus/{menuId}/items/{itemId}",
+    method: "DELETE",
+    tags: ["site-{siteId}", "navigation", "navigation-menu-{menuId}", "navigation-item-{itemId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  reorderNavigationItems: {
+    path: "/sites/{siteId}/navigation/menus/{menuId}/items/reorder",
+    method: "POST",
+    tags: ["site-{siteId}", "navigation", "navigation-menu-{menuId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getRoutableContent: {
+    path: "/sites/{siteId}/routable-content",
+    method: "GET",
+    revalidate: 60,
+    tags: ["site-{siteId}", "routable-content-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  // Public routable content for SDK SSG
+  getPublicRoutableContent: {
+    path: "/public/sites/{siteId}/routable-content",
+    method: "GET",
+    revalidate: 60,
+    tags: ["site-{siteId}", "routable-content-{siteId}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  // Generic public content preview (preferred)
+  getPublishedEntryPreview: {
+    path: "/public/content/{siteId}/{type}/{slug}/preview",
+    method: "GET",
+    revalidate: 60,
+    tags: ["content-{siteId}-{type}-{slug}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublishedEntries: {
+    path: "/public/content/{siteId}/{type}/entries",
+    method: "GET",
+    revalidate: 60,
+    tags: ["content-{siteId}-{type}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getPublishedPostPreview: {
+    path: "/public/posts/{siteId}/{slug}/preview",
+    method: "GET",
+    revalidate: 60,
+    tags: ["blog-post:{siteId}:{slug}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  proposalsSelect: {
+    path: "/proposals/select",
+    method: "POST",
+    tags: ["proposal", "site"],
+    auth: "user",
+    responseKind: "json"
+  },
+  createTheme: {
+    path: "/ai/chat/create-theme",
+    method: "POST",
+    revalidate: 60,
+    // 1 minute cache for theme creation to avoid duplicate requests
+    tags: ["theme", "ai-theme"],
+    auth: "user",
+    responseKind: "json"
+  },
+  generateThemes: {
+    path: "/theme/generate",
+    method: "POST",
+    tags: ["theme"],
+    auth: "user",
+    responseKind: "json"
+  },
+  extractThemeFromInspiration: {
+    path: "/theme/extract-from-inspiration",
+    method: "POST",
+    tags: ["theme", "preferences"],
+    auth: "user",
+    responseKind: "json"
+  },
+  saveSiteTheme: {
+    path: "/sites/{siteId}/theme/save",
+    method: "POST",
+    tags: ["site-{siteId}", "theme"],
+    auth: "user",
+    responseKind: "json"
+  },
+  uploadSiteLogo: {
+    path: "/storage/upload-site-logo",
+    method: "POST",
+    tags: ["site", "logo"],
+    auth: "user",
+    responseKind: "json"
+  },
+  upsertThemePreferences: {
+    path: "/theme-preferences/upsert",
+    method: "POST",
+    tags: ["theme", "preferences"],
+    auth: "user",
+    responseKind: "json"
+  },
+  finalizeSite: {
+    path: "/sites/finalize",
+    method: "POST",
+    tags: ["site"],
+    auth: "user",
+    responseKind: "json"
+  },
+  instagramUploadZip: {
+    path: "/api/instagram/upload-zip",
+    method: "POST",
+    tags: ["instagram-import"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getAnalyticsReport: {
+    path: "/sites/{siteId}/analytics/report",
+    method: "GET",
+    revalidate: 300,
+    tags: ["site-{siteId}", "analytics-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getSeoOverview: {
+    path: "/sites/{siteId}/seo/overview",
+    method: "GET",
+    revalidate: 300,
+    tags: ["site-{siteId}", "seo-overview-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getSeoPages: {
+    path: "/sites/{siteId}/seo/pages",
+    method: "GET",
+    revalidate: 300,
+    tags: ["site-{siteId}", "seo-pages-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getSeoQueries: {
+    path: "/sites/{siteId}/seo/queries",
+    method: "GET",
+    revalidate: 300,
+    tags: ["site-{siteId}", "seo-queries-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getPerformanceOverview: {
+    path: "/sites/{siteId}/performance/overview",
+    method: "GET",
+    revalidate: 300,
+    tags: ["site-{siteId}", "performance-overview-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  createMediaAsset: {
+    path: "/media",
+    method: "POST",
+    tags: ["media"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mediaList: {
+    path: "/media",
+    method: "GET",
+    tags: ["media"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mediaGet: {
+    path: "/media/{assetId}",
+    method: "GET",
+    tags: ["media", "media-{assetId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mediaUpdate: {
+    path: "/media/{assetId}",
+    method: "PATCH",
+    tags: ["media", "media-{assetId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mediaDelete: {
+    path: "/media/{assetId}",
+    method: "DELETE",
+    tags: ["media", "media-{assetId}"],
+    auth: "user",
+    responseKind: "void"
+  },
+  mediaBulkDelete: {
+    path: "/media/bulk-delete",
+    method: "POST",
+    tags: ["media"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mediaGetSignedUrl: {
+    path: "/media/{assetId}/signed-url",
+    method: "GET",
+    tags: ["media", "media-{assetId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mediaUpload: {
+    path: "/media/upload",
+    method: "POST",
+    tags: ["media"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getMediaLabels: {
+    path: "/media/labels",
+    method: "GET",
+    tags: ["media", "media-labels"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getMediaSettings: {
+    path: "/media/settings",
+    method: "GET",
+    tags: ["media-settings"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateMediaSettings: {
+    path: "/media/settings",
+    method: "POST",
+    tags: ["media-settings"],
+    auth: "user",
+    responseKind: "json"
+  },
+  // Media endpoints
+  mediaSearch: {
+    path: "/media/search",
+    method: "POST",
+    tags: ["media-search"],
+    auth: "user",
+    responseKind: "json"
+  },
+  classifyMediaAsset: {
+    path: "/media/{assetId}/classify",
+    method: "POST",
+    tags: ["media", "media-{assetId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  classifyMediaBatch: {
+    path: "/media/classify",
+    method: "POST",
+    tags: ["media"],
+    auth: "user",
+    responseKind: "json"
+  },
+  mediaJobsStatus: {
+    path: "/media/jobs/status",
+    method: "GET",
+    tags: ["media"],
+    auth: "user",
+    responseKind: "json"
+  },
+  enqueueMediaClassifyJob: {
+    path: "/media/jobs",
+    method: "POST",
+    tags: ["media"],
+    auth: "user",
+    responseKind: "json"
+  },
+  runMediaClassifyJob: {
+    path: "/media/jobs/run",
+    method: "POST",
+    tags: ["media"],
+    auth: "user",
+    responseKind: "json"
+  },
+  runAllMediaClassifyJobs: {
+    path: "/media/jobs/run-all",
+    method: "POST",
+    tags: ["media"],
+    auth: "user",
+    responseKind: "json"
+  },
+  initSiteContent: {
+    path: "/sites/{siteId}/content/init",
+    method: "POST",
+    tags: ["site", "content"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateBlockContent: {
+    path: "/blocks/{blockId}/content",
+    method: "POST",
+    tags: ["block", "block-{blockId}", "content"],
+    auth: "user",
+    responseKind: "json"
+  },
+  saveBlockContent: {
+    path: "/blocks/{blockId}/content",
+    method: "POST",
+    tags: ["block", "block-{blockId}", "content"],
+    auth: "user",
+    responseKind: "json"
+  },
+  createBlock: {
+    path: "/sites/{siteId}/pages/{pageId}/blocks",
+    method: "POST",
+    tags: ["site-{siteId}", "page-{pageId}", "blocks"],
+    auth: "user",
+    responseKind: "json"
+  },
+  reorderBlocks: {
+    path: "/sites/{siteId}/pages/{pageId}/blocks/reorder",
+    method: "POST",
+    tags: ["site-{siteId}", "page-{pageId}", "blocks"],
+    auth: "user",
+    responseKind: "json"
+  },
+  deleteBlock: {
+    path: "/sites/{siteId}/pages/{pageId}/blocks/{blockId}",
+    method: "DELETE",
+    tags: ["site-{siteId}", "page-{pageId}", "blocks"],
+    auth: "user",
+    responseKind: "json"
+  },
+  listBlocks: {
+    path: "/sites/{siteId}/pages/{pageId}/blocks",
+    method: "GET",
+    tags: ["site-{siteId}", "page-{pageId}", "blocks"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getBlockContent: {
+    path: "/blocks/{blockId}/content",
+    method: "GET",
+    tags: ["block-{blockId}", "content"],
+    auth: "user",
+    responseKind: "json"
+  },
+  // DEPRECATED: Use getSite with ?id={id} instead
+  getSiteById: {
+    path: "/sites/by-id/{id}",
+    method: "GET",
+    revalidate: 900,
+    // 15 minutes
+    tags: ["site-{id}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  // Page data endpoints
+  getPageById: {
+    path: "/sites/{siteId}/pages/{pageId}",
+    method: "GET",
+    revalidate: 900,
+    // 15 minutes
+    tags: ["site-{siteId}", "page-{pageId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getContentByPath: {
+    path: "/sites/{siteId}/pages",
+    method: "GET",
+    tags: ["site-{siteId}", "routable-content-{siteId}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getPageByPath: {
+    path: "/sites/{siteId}/pages",
+    method: "GET",
+    tags: ["site-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  // Forms CRUD
+  listForms: {
+    path: "/sites/{siteId}/forms",
+    method: "GET",
+    tags: ["site-{siteId}", "forms"],
+    auth: "user",
+    responseKind: "json"
+  },
+  listBookingForms: {
+    path: "/sites/{siteId}/bookings/forms",
+    method: "GET",
+    tags: ["site-{siteId}", "forms"],
+    auth: "user",
+    responseKind: "json"
+  },
+  createForm: {
+    path: "/sites/{siteId}/forms",
+    method: "POST",
+    tags: ["site-{siteId}", "forms"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateForm: {
+    path: "/sites/{siteId}/forms/{slug}",
+    method: "PATCH",
+    tags: ["site-{siteId}", "forms", "form-{slug}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  deleteForm: {
+    path: "/sites/{siteId}/forms/{slug}",
+    method: "DELETE",
+    tags: ["site-{siteId}", "forms", "form-{slug}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  listFormSubmissions: {
+    path: "/sites/{siteId}/forms/{slug}/submissions",
+    method: "GET",
+    revalidate: 30,
+    tags: ["site-{siteId}", "form-{slug}", "form-submissions-{slug}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  // Public submit
+  submitForm: {
+    path: "/forms/submit",
+    method: "POST",
+    tags: ["forms-submit"],
+    auth: "public",
+    responseKind: "json"
+  },
+  // Public forms
+  getPublicFormById: {
+    path: "/public/forms/{formId}",
+    method: "GET",
+    revalidate: 60,
+    tags: ["form-{formId}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  // Public booking services
+  getPublicBookingServices: {
+    path: "/public/bookings/services",
+    method: "GET",
+    revalidate: 60,
+    tags: ["site-{siteId}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  devToolsImpersonateAdmin: {
+    path: "/dev-tools/impersonate/admin",
+    method: "POST",
+    auth: "admin",
+    responseKind: "json"
+  },
+  devToolsImpersonateRandom: {
+    path: "/dev-tools/impersonate/random",
+    method: "POST",
+    auth: "admin",
+    responseKind: "json"
+  },
+  devToolsSeedDemoData: {
+    path: "/dev-tools/seed",
+    method: "POST",
+    auth: "admin",
+    responseKind: "json"
+  },
+  // Public analytics collection endpoint
+  analyticsCollect: {
+    path: "/api/analytics/collect",
+    method: "POST",
+    auth: "public",
+    responseKind: "json"
+  },
+  // Public events for event calendar block
+  listPublicEvents: {
+    path: "/public/sites/{siteId}/events",
+    method: "GET",
+    revalidate: 60,
+    tags: ["public-events-{siteId}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  // Resolve event occurrence by URL segment (date or UUID)
+  resolveEventOccurrence: {
+    path: "/public/sites/{siteId}/events/occurrences/resolve",
+    method: "GET",
+    revalidate: 60,
+    tags: ["public-events-{siteId}", "event-occurrence"],
+    auth: "public",
+    responseKind: "json"
+  },
+  // Public event registration
+  registerForEvent: {
+    path: "/public/sites/{siteId}/events/register",
+    method: "POST",
+    tags: ["public-events-{siteId}", "event-registration"],
+    auth: "public",
+    responseKind: "json"
+  },
+  // Content Types CRUD
+  listSiteContentTypes: {
+    path: "/sites/{siteId}/content-types",
+    method: "GET",
+    revalidate: 60,
+    tags: ["site-{siteId}", "content-types-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getContentType: {
+    path: "/sites/{siteId}/content-types/by-id/{typeId}",
+    method: "GET",
+    revalidate: 60,
+    tags: ["site-{siteId}", "content-type-{typeId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  createContentType: {
+    path: "/sites/{siteId}/content-types",
+    method: "POST",
+    tags: ["site-{siteId}", "content-types-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  updateContentType: {
+    path: "/sites/{siteId}/content-types/by-id/{typeId}",
+    method: "PATCH",
+    tags: ["site-{siteId}", "content-type-{typeId}", "content-types-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  deleteContentType: {
+    path: "/sites/{siteId}/content-types/by-id/{typeId}",
+    method: "DELETE",
+    tags: ["site-{siteId}", "content-type-{typeId}", "content-types-{sideId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  duplicateContentType: {
+    path: "/sites/{siteId}/content-types/by-id/{typeId}/duplicate",
+    method: "POST",
+    tags: ["site-{siteId}", "content-type-{typeId}", "content-types-{siteId}"],
+    auth: "user",
+    responseKind: "json"
+  },
+  // Admin site creation
+  adminCreateSite: {
+    path: "/admin/sites",
+    method: "POST",
+    tags: ["admin", "sites"],
+    auth: "admin",
+    responseKind: "json"
+  },
+  // SDK Config
+  refreshSdkConfig: {
+    path: "/sites/{siteId}/refresh-sdk-config",
+    method: "POST",
+    tags: ["site-{siteId}", "sdk-config"],
+    auth: "user",
+    responseKind: "json"
+  },
+  // Stripe Connect - Site billing
+  stripeConnectAuthorize: {
+    path: "/sites/{siteId}/billing/connect/authorize",
+    method: "POST",
+    tags: ["site-{siteId}", "stripe-connect"],
+    auth: "user",
+    responseKind: "json"
+  },
+  stripeConnectStatus: {
+    path: "/sites/{siteId}/billing/connect/status",
+    method: "GET",
+    tags: ["site-{siteId}", "stripe-connect"],
+    auth: "user",
+    responseKind: "json"
+  },
+  stripeConnectDisconnect: {
+    path: "/sites/{siteId}/billing/connect/disconnect",
+    method: "DELETE",
+    tags: ["site-{siteId}", "stripe-connect"],
+    auth: "user",
+    responseKind: "json"
+  },
+  // Backup
+  importSiteBackup: {
+    path: "/sites/{siteId}/backup/import",
+    method: "POST",
+    tags: ["site-{siteId}", "backup"],
+    auth: "user",
+    responseKind: "json"
+  },
+  previewBackup: {
+    path: "/backup/preview",
+    method: "POST",
+    tags: ["backup"],
+    auth: "user",
+    responseKind: "json"
+  },
+  importBackupAsNewSite: {
+    path: "/sites/backup/import-as-new",
+    method: "POST",
+    tags: ["site", "backup"],
+    auth: "user",
+    responseKind: "json"
+  },
+  // Admin billing price overrides
+  adminGetPriceOverride: {
+    path: "/admin/billing/price-override",
+    method: "GET",
+    tags: ["admin", "billing", "price-override"],
+    auth: "admin",
+    responseKind: "json"
+  },
+  adminUpsertPriceOverride: {
+    path: "/admin/billing/price-override",
+    method: "POST",
+    tags: ["admin", "billing", "price-override"],
+    auth: "admin",
+    responseKind: "json"
+  },
+  adminDeletePriceOverride: {
+    path: "/admin/billing/price-override",
+    method: "DELETE",
+    tags: ["admin", "billing", "price-override"],
+    auth: "admin",
+    responseKind: "json"
+  }
+};
+var API_ENDPOINTS = ENDPOINT_DEFINITIONS;
+
+// ../api/src/url.ts
+function getCmsApiUrl() {
+  if (typeof window !== "undefined") {
+    return "/api";
+  }
+  const internalUrl = process.env.CMS_API_URL;
+  if (internalUrl) {
+    return internalUrl.replace(/\/$/, "");
+  }
+  const dashboardUrl = process.env.NEXT_PUBLIC_DASHBOARD_URL;
+  if (dashboardUrl) {
+    const base = dashboardUrl.replace(/\/$/, "");
+    return `${base}/api`;
+  }
+  const legacyApiUrl = process.env.NEXT_PUBLIC_CMS_API_URL;
+  if (legacyApiUrl) {
+    return legacyApiUrl.replace(/\/$/, "");
+  }
+  throw new Error(
+    "NEXT_PUBLIC_DASHBOARD_URL is not configured. Set it to your dashboard URL (e.g., http://dashboard.local:4000)"
+  );
+}
+function resolveApiBaseUrl() {
+  return getCmsApiUrl();
+}
+
+// ../api/src/request.ts
+var revalidateTag = null;
+if (typeof window === "undefined") {
+  try {
+    const dynamicRequire = new Function("modulePath", "return require(modulePath)");
+    const nextCache = dynamicRequire("next/cache");
+    revalidateTag = nextCache.revalidateTag ?? null;
+  } catch {
+  }
+}
+var sdkVersion;
+function generateRequestId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function setSdkVersion(version) {
+  sdkVersion = version;
+}
+var ApiRequestError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "ApiRequestError";
+    this.endpoint = options.endpoint;
+    this.status = options.status;
+    this.method = options.method;
+    this.auth = options.auth;
+    this.requestId = options.requestId;
+    this.body = options.body;
+    this.cause = options.cause;
+    this.errorCode = options.errorCode;
+    this.retryAfterMs = options.retryAfterMs;
+  }
+};
+function parseRetryAfterHeader(headerValue) {
+  if (!headerValue) return void 0;
+  if (/^\d+$/.test(headerValue)) {
+    const seconds = parseInt(headerValue, 10);
+    return seconds * 1e3;
+  }
+  const date = new Date(headerValue);
+  if (!isNaN(date.getTime())) {
+    const delayMs = date.getTime() - Date.now();
+    return delayMs > 0 ? delayMs : void 0;
+  }
+  return void 0;
+}
+function buildEndpointURL(baseURL, endpoint) {
+  return baseURL + API_ENDPOINTS[endpoint].path;
+}
+function invalidateCacheTags(tags, params) {
+  if (typeof window !== "undefined" || !revalidateTag || !tags) return;
+  tags.forEach((tag) => {
+    let processedTag = tag;
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        processedTag = processedTag.replace(`{${key}}`, String(value));
+      });
+    }
+    try {
+      revalidateTag(processedTag, "max");
+    } catch {
+    }
+  });
+}
+async function parseErrorBody(response) {
+  const clone = response.clone();
+  const contentType = clone.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    try {
+      return await clone.json();
+    } catch {
+    }
+  }
+  try {
+    const text2 = await clone.text();
+    return text2.length ? text2 : null;
+  } catch {
+    return null;
+  }
+}
+function buildSuccessEnvelope(data, requestId) {
+  return {
+    success: true,
+    data,
+    meta: {
+      requestId: requestId ?? generateRequestId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      apiVersion: "2025-01-01"
+    }
+  };
+}
+function buildErrorEnvelope(code, message, status, requestId) {
+  return {
+    success: false,
+    error: {
+      code,
+      message,
+      requestId: requestId ?? generateRequestId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      status
+    }
+  };
+}
+async function parseSuccessResponse(endpoint, response, config3) {
+  const responseKind = config3.responseKind ?? "json";
+  const auth = config3.auth ?? "user";
+  const requestId = response.headers.get("x-request-id") ?? void 0;
+  switch (responseKind) {
+    case "json": {
+      if (response.status === 204 || response.status === 205 || response.status === 304) {
+        return buildSuccessEnvelope(void 0, requestId);
+      }
+      const raw = await response.text();
+      if (!raw.trim()) {
+        return buildSuccessEnvelope(void 0, requestId);
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch (cause) {
+        throw new ApiRequestError(
+          `Failed to parse JSON response for endpoint ${String(endpoint)}`,
+          {
+            endpoint,
+            status: response.status,
+            method: config3.method,
+            auth,
+            requestId,
+            body: raw,
+            cause
+          }
+        );
+      }
+      if (parsed && typeof parsed === "object" && "success" in parsed && typeof parsed.success === "boolean") {
+        return parsed;
+      }
+      return buildSuccessEnvelope(parsed, requestId);
+    }
+    case "text": {
+      const text2 = await response.text();
+      return buildSuccessEnvelope(text2, requestId);
+    }
+    case "stream": {
+      const body = response.body;
+      if (!body) {
+        return buildErrorEnvelope(
+          "server:internal_error",
+          `Expected a streamed body for endpoint ${String(endpoint)}`,
+          response.status,
+          requestId
+        );
+      }
+      const stream = body;
+      return buildSuccessEnvelope(stream, requestId);
+    }
+    case "void": {
+      return buildSuccessEnvelope(void 0, requestId);
+    }
+    default: {
+      return buildSuccessEnvelope(void 0, requestId);
+    }
+  }
+}
+function createRawCMSClient(headers = {}, baseUrl) {
+  return ({
+    endpoint,
+    body,
+    params,
+    options = {}
+  }) => {
+    const resolvedBaseUrl = baseUrl ?? resolveApiBaseUrl();
+    let url = buildEndpointURL(resolvedBaseUrl, endpoint);
+    const originalPath = API_ENDPOINTS[endpoint].path;
+    const unusedParams = {};
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        const placeholder = `{${key}}`;
+        if (originalPath.includes(placeholder)) {
+          url = url.replace(placeholder, value);
+        } else {
+          unusedParams[key] = value;
+        }
+      });
+    }
+    const endpointConfig = API_ENDPOINTS[endpoint];
+    const method = endpointConfig.method;
+    const isGetOrHead = method === "GET" || method === "HEAD";
+    if (isGetOrHead) {
+      const queryParams = new URLSearchParams();
+      Object.entries(unusedParams).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          queryParams.append(key, String(value));
+        }
+      });
+      if (body) {
+        Object.entries(body).forEach(([key, value]) => {
+          if (value !== void 0 && value !== null) {
+            queryParams.append(key, String(value));
+          }
+        });
+      }
+      const queryString = queryParams.toString();
+      if (queryString) {
+        url += (url.includes("?") ? "&" : "?") + queryString;
+      }
+    }
+    const isFormData = typeof FormData !== "undefined" && body instanceof FormData;
+    const nextOptions = {};
+    if (isGetOrHead && "revalidate" in endpointConfig && typeof endpointConfig.revalidate === "number") {
+      nextOptions.revalidate = endpointConfig.revalidate;
+    }
+    if ("tags" in endpointConfig && Array.isArray(endpointConfig.tags)) {
+      nextOptions.tags = endpointConfig.tags.map((tag) => {
+        let processedTag = tag;
+        if (params) {
+          Object.entries(params).forEach(([key, value]) => {
+            processedTag = processedTag.replace(`{${key}}`, String(value));
+          });
+        }
+        return processedTag;
+      });
+    }
+    const requestInit = {
+      method,
+      ...options,
+      // Include credentials for same-origin requests (sends cookies for auth)
+      credentials: "same-origin",
+      // Don't include body for GET/HEAD requests
+      body: isGetOrHead ? void 0 : isFormData ? body : body ? JSON.stringify(body) : void 0,
+      headers: {
+        ...options.headers,
+        ...headers,
+        // Include SDK version if set
+        ...sdkVersion && { "x-sdk-version": sdkVersion },
+        // Don't set Content-Type for GET/HEAD requests without body
+        ...isGetOrHead ? {} : isFormData ? {} : { "Content-Type": "application/json" }
+      },
+      // Add Next.js caching options
+      next: Object.keys(nextOptions).length > 0 ? nextOptions : void 0
+    };
+    const fetchPromise = fetch(url, requestInit);
+    if (!isGetOrHead && "tags" in endpointConfig && Array.isArray(endpointConfig.tags)) {
+      const tags = endpointConfig.tags.map((tag) => tag);
+      return fetchPromise.then((response) => {
+        if (response.ok) {
+          invalidateCacheTags(tags, params);
+        }
+        return response;
+      });
+    }
+    return fetchPromise;
+  };
+}
+function createParsedClient(rawClient) {
+  return async (params) => {
+    const response = await rawClient(params);
+    const endpoint = params.endpoint;
+    const config3 = API_ENDPOINTS[endpoint];
+    const auth = config3.auth ?? "user";
+    if (!response.ok) {
+      const body = await parseErrorBody(response);
+      const requestId = response.headers.get("x-request-id") ?? void 0;
+      const retryAfterMs = parseRetryAfterHeader(response.headers.get("retry-after"));
+      throw new ApiRequestError(
+        `Request to ${String(endpoint)} failed with status ${response.status}`,
+        {
+          endpoint,
+          status: response.status,
+          method: config3.method,
+          auth,
+          requestId,
+          body,
+          retryAfterMs
+        }
+      );
+    }
+    return parseSuccessResponse(endpoint, response, config3);
+  };
+}
+function createCMSClient(headers = {}, baseUrl) {
+  return createParsedClient(createRawCMSClient(headers, baseUrl));
+}
+function createBearerAPIClient(token, baseUrl) {
+  const authHeaders = {
+    Authorization: `Bearer ${token}`
+  };
+  return createCMSClient(authHeaders, baseUrl);
+}
+
+// ../api/src/common/envelope.ts
+function isApiError(result) {
+  return result.success === false;
+}
+function isApiSuccess(result) {
+  return result.success === true;
+}
+var ApiEnvelopeError = class extends Error {
+  constructor(error) {
+    super(error.message);
+    this.name = "ApiEnvelopeError";
+    this.code = error.code;
+    this.requestId = error.requestId;
+    this.timestamp = error.timestamp;
+    this.status = error.status;
+    this.fieldErrors = error.fieldErrors;
+  }
+};
+function unwrapResponse(result) {
+  if (isApiSuccess(result)) {
+    return result.data;
+  }
+  throw new ApiEnvelopeError(result.error);
+}
+
+// src/client/cache.ts
+var SimpleCache = class {
+  constructor(options = {}) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = options.maxSize ?? 100;
+    this.ttl = options.ttl ?? 3e5;
+    this.staleTtl = options.staleTtl ?? 3e5;
+  }
+  /**
+   * Get a fresh value (within TTL)
+   * @returns The value if fresh, null otherwise
+   */
+  getFresh(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    const now = Date.now();
+    if (now <= entry.freshUntil) {
+      return entry.value;
+    }
+    return null;
+  }
+  /**
+   * Get a value that may be stale (past TTL but within staleTtl)
+   * @returns Object with value and stale age, or null if expired
+   */
+  getStale(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    const now = Date.now();
+    if (now > entry.staleUntil) {
+      this.cache.delete(key);
+      return null;
+    }
+    const staleAgeSec = now <= entry.freshUntil ? 0 : Math.floor((now - entry.freshUntil) / 1e3);
+    return {
+      value: entry.value,
+      staleAgeSec
+    };
+  }
+  /**
+   * Store a value with TTL and stale window
+   */
+  set(key, value, options) {
+    const ttl = options?.ttl ?? this.ttl;
+    const staleTtl = options?.staleTtl ?? this.staleTtl;
+    const now = Date.now();
+    while (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+      this.evictOne(now);
+    }
+    this.cache.set(key, {
+      value,
+      createdAt: now,
+      freshUntil: now + ttl,
+      staleUntil: now + ttl + staleTtl
+    });
+  }
+  /**
+   * Evict one entry to make room for a new one
+   * Priority: oldest stale entry, then oldest fresh entry
+   */
+  evictOne(now) {
+    let oldestStaleKey = null;
+    let oldestStaleTime = Infinity;
+    let oldestFreshKey = null;
+    let oldestFreshTime = Infinity;
+    for (const [key, entry] of this.cache) {
+      if (now > entry.freshUntil) {
+        if (entry.createdAt < oldestStaleTime) {
+          oldestStaleTime = entry.createdAt;
+          oldestStaleKey = key;
+        }
+      } else {
+        if (entry.createdAt < oldestFreshTime) {
+          oldestFreshTime = entry.createdAt;
+          oldestFreshKey = key;
+        }
+      }
+    }
+    const keyToEvict = oldestStaleKey ?? oldestFreshKey;
+    if (keyToEvict) {
+      this.cache.delete(keyToEvict);
+    }
+  }
+  /**
+   * Remove all fully expired entries (past staleUntil)
+   */
+  prune() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache) {
+      if (now > entry.staleUntil) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  /**
+   * Clear all entries
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Check if a key exists and is not fully expired
+   */
+  has(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    const now = Date.now();
+    if (now > entry.staleUntil) {
+      this.cache.delete(key);
+      return false;
+    }
+    return now <= entry.freshUntil;
+  }
+};
+
+// src/version.ts
+var SDK_VERSION = "0.8.0";
+
+// src/client/error.ts
+var RiverbankApiError = class _RiverbankApiError extends Error {
+  constructor(apiError) {
+    super(apiError.message);
+    this.name = "RiverbankApiError";
+    if ("cause" in apiError && apiError.cause) {
+      this.cause = apiError.cause;
+    }
+    this.code = apiError.code;
+    this.requestId = apiError.requestId;
+    this.status = apiError.status;
+    this.fieldErrors = apiError.fieldErrors;
+    this.timestamp = apiError.timestamp;
+    this.retryAfterMs = "retryAfterMs" in apiError ? apiError.retryAfterMs : void 0;
+    this.isRetryable = this.computeRetryable();
+    Object.setPrototypeOf(this, _RiverbankApiError.prototype);
+  }
+  /**
+   * Compute whether this error is retryable based on HTTP status code.
+   * - 0 (network errors - no HTTP response): retryable
+   * - 429 (rate limit): retryable
+   * - 5xx (server errors): retryable
+   * - 4xx (client errors, except 429): NOT retryable
+   */
+  computeRetryable() {
+    if (this.status === 0) return true;
+    if (this.status === 429) return true;
+    if (this.status >= 500) return true;
+    return false;
+  }
+  /**
+   * Check if this is a network error (no HTTP response received)
+   *
+   * Matches: network:connection_error, network:timeout, network:dns_error
+   */
+  isNetworkError() {
+    return this.code.startsWith("network:");
+  }
+  /**
+   * Check if this error matches a specific error code
+   *
+   * @example
+   * ```ts
+   * if (error.is('auth:unauthenticated')) {
+   *   // Redirect to login
+   * }
+   * ```
+   */
+  is(code) {
+    return this.code === code;
+  }
+  /**
+   * Check if this is an authentication or authorization error
+   *
+   * Matches: auth:unauthenticated, auth:token_expired, auth:token_invalid,
+   * auth:forbidden, auth:mfa_required, auth:insufficient_permissions
+   */
+  isAuthError() {
+    return this.code.startsWith("auth:");
+  }
+  /**
+   * Check if this is a validation error
+   *
+   * Matches: validation:invalid_input, validation:missing_field, validation:invalid_format
+   */
+  isValidationError() {
+    return this.code.startsWith("validation:");
+  }
+  /**
+   * Check if this is a resource error (not found, conflict, etc.)
+   *
+   * Matches: resource:not_found, resource:already_exists, resource:conflict, resource:gone
+   */
+  isResourceError() {
+    return this.code.startsWith("resource:");
+  }
+  /**
+   * Check if this is a rate limiting error
+   */
+  isRateLimitError() {
+    return this.code.startsWith("rate_limit:");
+  }
+  /**
+   * Check if this is a billing/payment error
+   */
+  isBillingError() {
+    return this.code.startsWith("billing:");
+  }
+  /**
+   * Check if this is a server error
+   */
+  isServerError() {
+    return this.code.startsWith("server:");
+  }
+  /**
+   * Returns a human-readable string representation of the error.
+   * Includes all key details for debugging.
+   *
+   * @example
+   * "RiverbankApiError: Content keys cannot access preview content | Code: auth:forbidden | Status: 401 | RequestId: req-abc123"
+   */
+  toString() {
+    const parts = [`RiverbankApiError: ${this.message}`];
+    if (this.code) parts.push(`Code: ${this.code}`);
+    if (this.status) parts.push(`Status: ${this.status}`);
+    if (this.requestId) parts.push(`RequestId: ${this.requestId}`);
+    return parts.join(" | ");
+  }
+  /**
+   * Custom Node.js inspect output for better console.log display.
+   * This ensures that console.log(error) shows all relevant details
+   * instead of just "[Object]" for nested properties.
+   */
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toDetailedString();
+  }
+  /**
+   * Returns a detailed multi-line string for debugging.
+   * Used by the Node.js inspect symbol for console output.
+   */
+  toDetailedString() {
+    const lines = [
+      `RiverbankApiError: ${this.message}`,
+      `  Code: ${this.code}`,
+      `  Status: ${this.status}`,
+      `  RequestId: ${this.requestId}`,
+      `  Timestamp: ${this.timestamp}`
+    ];
+    if (this.isRetryable) {
+      lines.push(`  Retryable: true`);
+      if (this.retryAfterMs) {
+        lines.push(`  RetryAfter: ${this.retryAfterMs}ms`);
+      }
+    }
+    if (this.fieldErrors && this.fieldErrors.length > 0) {
+      lines.push("  FieldErrors:");
+      this.fieldErrors.forEach((fe) => {
+        lines.push(`    - ${fe.field}: ${fe.message}`);
+      });
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/client/resilience.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxAttempts: 3,
+  baseDelayMs: 200,
+  maxDelayMs: 2e3,
+  jitter: "full"
+};
+var DEFAULT_CIRCUIT_BREAKER_CONFIG = {
+  failureThreshold: 5,
+  resetTimeoutMs: 3e4,
+  halfOpenMaxRequests: 2
+};
+var PERMANENT_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  // Server is not running / port not listening
+  "ENOTFOUND",
+  // DNS lookup failed - hostname doesn't exist
+  "EAI_AGAIN"
+  // DNS lookup timeout (usually permanent for invalid hosts)
+]);
+var TRANSIENT_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ECONNRESET",
+  // Connection was reset mid-request (server dropped it)
+  "EPIPE",
+  // Broken pipe (connection closed while writing)
+  "ETIMEDOUT",
+  // Connection timed out (could be temporary congestion)
+  "ESOCKETTIMEDOUT"
+  // Socket timeout
+]);
+var NODE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  // Permanent
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  // Transient
+  "ECONNRESET",
+  "EPIPE",
+  "ETIMEDOUT",
+  "ESOCKETTIMEDOUT"
+]);
+function isNodeNetworkErrorCode(code) {
+  return !code.includes(":") && NODE_NETWORK_ERROR_CODES.has(code);
+}
+function getErrorCodeFromCause(error) {
+  let current = error;
+  while (current) {
+    const nodeError = current;
+    if (nodeError.code && typeof nodeError.code === "string") {
+      if (isNodeNetworkErrorCode(nodeError.code)) {
+        return nodeError.code;
+      }
+    }
+    const errorWithCause = current;
+    current = errorWithCause.cause;
+  }
+  return void 0;
+}
+function isTransientError(error) {
+  if (error instanceof RiverbankApiError) {
+    const errorCode = getErrorCodeFromCause(error);
+    if (errorCode && PERMANENT_NETWORK_ERROR_CODES.has(errorCode)) {
+      return false;
+    }
+    if (error.status === 0) return true;
+    if (error.status === 429) return true;
+    if (error.status >= 500) return true;
+    return false;
+  }
+  if (error instanceof TypeError) {
+    const errorCode = getErrorCodeFromCause(error);
+    if (errorCode) {
+      if (PERMANENT_NETWORK_ERROR_CODES.has(errorCode)) {
+        return false;
+      }
+      if (TRANSIENT_NETWORK_ERROR_CODES.has(errorCode)) {
+        return true;
+      }
+    }
+    return true;
+  }
+  return true;
+}
+function calculateBackoff(attempt, config3) {
+  const baseDelayMs = config3.baseDelayMs ?? DEFAULT_RETRY_CONFIG.baseDelayMs;
+  const maxDelayMs = config3.maxDelayMs ?? DEFAULT_RETRY_CONFIG.maxDelayMs;
+  const jitter = config3.jitter ?? DEFAULT_RETRY_CONFIG.jitter;
+  const exponential = baseDelayMs * Math.pow(2, attempt - 1);
+  const capped = Math.min(exponential, maxDelayMs);
+  if (jitter === "full") {
+    return Math.random() * capped;
+  }
+  return capped;
+}
+var CircuitBreaker = class {
+  constructor(config3) {
+    this.state = "closed";
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.openUntil = 0;
+    this.halfOpenRequests = 0;
+    this.config = {
+      failureThreshold: config3?.failureThreshold ?? DEFAULT_CIRCUIT_BREAKER_CONFIG.failureThreshold,
+      resetTimeoutMs: config3?.resetTimeoutMs ?? DEFAULT_CIRCUIT_BREAKER_CONFIG.resetTimeoutMs,
+      halfOpenMaxRequests: config3?.halfOpenMaxRequests ?? DEFAULT_CIRCUIT_BREAKER_CONFIG.halfOpenMaxRequests
+    };
+  }
+  /**
+   * Check if circuit is open (requests should be blocked)
+   * Also handles automatic transition from open to half-open after timeout
+   */
+  isOpen() {
+    if (this.state === "open" && Date.now() >= this.openUntil) {
+      this.transitionTo("half-open");
+    }
+    return this.state === "open";
+  }
+  /**
+   * Check if a request can be attempted
+   * - closed: always yes
+   * - open: always no
+   * - half-open: limited number of probes
+   */
+  canAttempt() {
+    if (this.state === "closed") return true;
+    if (this.state === "open") return false;
+    return this.halfOpenRequests < this.config.halfOpenMaxRequests;
+  }
+  /**
+   * Increment half-open request counter (call before making request in half-open)
+   */
+  incrementHalfOpenRequests() {
+    if (this.state === "half-open") {
+      this.halfOpenRequests++;
+    }
+  }
+  /**
+   * Record a successful request
+   */
+  recordSuccess() {
+    if (this.state === "half-open") {
+      this.successCount++;
+      if (this.successCount >= this.config.halfOpenMaxRequests) {
+        this.transitionTo("closed");
+      }
+    } else {
+      this.failureCount = 0;
+    }
+  }
+  /**
+   * Record a failed request
+   * Only counts transient failures toward circuit breaker threshold
+   */
+  recordFailure(error) {
+    if (!isTransientError(error)) return;
+    this.failureCount++;
+    if (this.state === "half-open") {
+      this.transitionTo("open");
+    } else if (this.failureCount >= this.config.failureThreshold) {
+      this.transitionTo("open");
+    }
+  }
+  /**
+   * Get current circuit state
+   */
+  getState() {
+    return {
+      state: this.state,
+      failureCount: this.failureCount,
+      openUntil: this.state === "open" ? this.openUntil : void 0
+    };
+  }
+  /**
+   * Transition to a new state
+   */
+  transitionTo(newState) {
+    this.state = newState;
+    if (newState === "open") {
+      this.openUntil = Date.now() + this.config.resetTimeoutMs;
+    } else if (newState === "half-open") {
+      this.halfOpenRequests = 0;
+      this.successCount = 0;
+    } else if (newState === "closed") {
+      this.failureCount = 0;
+      this.successCount = 0;
+      this.halfOpenRequests = 0;
+    }
+  }
+};
+async function fetchWithTimeoutAndRetry(fetcher, config3) {
+  const maxAttempts = config3.maxAttempts ?? DEFAULT_RETRY_CONFIG.maxAttempts;
+  const requestTimeoutMs = config3.requestTimeoutMs ?? 8e3;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), requestTimeoutMs);
+      try {
+        const result = await fetcher(controller.signal);
+        return result;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      lastError = error;
+      const shouldRetry = shouldRetryError(error, config3.retryOn);
+      if (!shouldRetry) {
+        throw error;
+      }
+      if (attempt < maxAttempts) {
+        const delay = getRetryDelay(error, attempt, config3);
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError;
+}
+function isAbortError(error) {
+  if (typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError") {
+    return true;
+  }
+  if (error instanceof Error && error.name === "AbortError") {
+    return true;
+  }
+  return false;
+}
+function shouldRetryError(error, customRetryOn) {
+  if (isAbortError(error)) {
+    return false;
+  }
+  if (customRetryOn) {
+    const statusCode = error instanceof RiverbankApiError ? error.status : void 0;
+    return customRetryOn(error, statusCode);
+  }
+  return isTransientError(error);
+}
+function getRetryDelay(error, attempt, config3) {
+  if (error instanceof RiverbankApiError && error.retryAfterMs) {
+    return error.retryAfterMs;
+  }
+  return calculateBackoff(attempt, config3);
+}
+function sleep(ms) {
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
+}
+var CircuitOpenError = class extends Error {
+  constructor(state) {
+    super("Circuit breaker is open");
+    this.name = "CircuitOpenError";
+    this.circuitState = state;
+  }
+};
+
+// src/client/index.ts
+var prebuildModule = null;
+function getPrebuildModule() {
+  if (prebuildModule !== null) return prebuildModule;
+  if (typeof process === "undefined" || !process.versions?.node) {
+    return null;
+  }
+  try {
+    prebuildModule = (init_loader(), __toCommonJS(loader_exports));
+    return prebuildModule;
+  } catch {
+    return null;
+  }
+}
+setSdkVersion(SDK_VERSION);
+var DEFAULT_BROWSER_TIMEOUT_MS = 5e3;
+var DEFAULT_SERVER_TIMEOUT_MS = 8e3;
+function generateRequestId2() {
+  return `req-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function isAbortError2(error) {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return true;
+  }
+  if (error instanceof Error && error.name === "AbortError") {
+    return true;
+  }
+  return false;
+}
+function getNetworkErrorCode(error) {
+  if (error.name === "TimeoutError" || error.name === "AbortError") {
+    return "network:timeout";
+  }
+  const nodeError = error;
+  if (nodeError.code) {
+    switch (nodeError.code) {
+      case "ETIMEDOUT":
+      case "ESOCKETTIMEDOUT":
+        return "network:timeout";
+      case "ENOTFOUND":
+      case "EAI_AGAIN":
+        return "network:dns_error";
+      case "ECONNREFUSED":
+      case "ECONNRESET":
+      case "EPIPE":
+        return "network:connection_error";
+    }
+  }
+  const message = error.message.toLowerCase();
+  if (message.includes("timeout") || message.includes("timed out")) {
+    return "network:timeout";
+  }
+  if (message.includes("dns") || message.includes("getaddrinfo") || message.includes("enotfound")) {
+    return "network:dns_error";
+  }
+  return "network:connection_error";
+}
+function convertToTypedError(error) {
+  if (isAbortError2(error)) {
+    throw error;
+  }
+  if (error instanceof ApiEnvelopeError) {
+    throw new RiverbankApiError({
+      code: error.code,
+      message: error.message,
+      requestId: error.requestId,
+      timestamp: error.timestamp,
+      status: error.status,
+      fieldErrors: error.fieldErrors
+    });
+  }
+  if (error instanceof ApiRequestError && error.body && typeof error.body === "object") {
+    const body = error.body;
+    if (isApiError(body)) {
+      const envelopeError = body.error;
+      throw new RiverbankApiError({
+        ...envelopeError,
+        retryAfterMs: error.retryAfterMs
+      });
+    }
+  }
+  if (error instanceof TypeError || error instanceof Error && !("status" in error)) {
+    const networkError = error;
+    throw new RiverbankApiError({
+      code: getNetworkErrorCode(networkError),
+      message: networkError.message || "Network request failed",
+      requestId: `local-${Date.now()}`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      status: 0,
+      // No HTTP response received
+      cause: networkError
+      // Preserve original error for retry/circuit breaker classification
+    });
+  }
+  throw error;
+}
+function detectKeyType(apiKey) {
+  if (apiKey.startsWith("bld_live_sk_") || apiKey.startsWith("bld_test_sk_")) {
+    return "content";
+  }
+  if (apiKey.startsWith("bld_preview_sk_")) {
+    return "preview";
+  }
+  return "unknown";
+}
+function createRiverbankClient(config3) {
+  if (!config3.baseUrl) {
+    throw new Error(
+      "baseUrl is required when creating a Riverbank client. Expected format: https://dashboard.example.com/api (must include /api path)"
+    );
+  }
+  if (!config3.baseUrl.endsWith("/api")) {
+    throw new Error(
+      `baseUrl must end with '/api'. Received: ${config3.baseUrl}. Expected format: https://dashboard.example.com/api`
+    );
+  }
+  const cacheEnabled = config3.cache?.enabled ?? true;
+  const cacheTTL = (config3.cache?.ttl ?? 300) * 1e3;
+  const cacheMaxSize = config3.cache?.maxSize ?? 100;
+  const resilienceEnabled = config3.resilience?.enabled ?? true;
+  const staleIfError = config3.resilience?.staleIfError ?? true;
+  const staleTtlMs = (config3.resilience?.staleTtlSec ?? 300) * 1e3;
+  const requestTimeoutMs = config3.resilience?.requestTimeoutMs ?? (typeof window !== "undefined" ? DEFAULT_BROWSER_TIMEOUT_MS : DEFAULT_SERVER_TIMEOUT_MS);
+  const retryConfig = {
+    maxAttempts: config3.resilience?.retry?.maxAttempts ?? DEFAULT_RETRY_CONFIG.maxAttempts,
+    baseDelayMs: config3.resilience?.retry?.baseDelayMs ?? DEFAULT_RETRY_CONFIG.baseDelayMs,
+    maxDelayMs: config3.resilience?.retry?.maxDelayMs ?? DEFAULT_RETRY_CONFIG.maxDelayMs,
+    jitter: config3.resilience?.retry?.jitter ?? DEFAULT_RETRY_CONFIG.jitter,
+    retryOn: config3.resilience?.retry?.retryOn
+  };
+  const circuitBreakerConfig = {
+    failureThreshold: config3.resilience?.circuitBreaker?.failureThreshold ?? DEFAULT_CIRCUIT_BREAKER_CONFIG.failureThreshold,
+    resetTimeoutMs: config3.resilience?.circuitBreaker?.resetTimeoutMs ?? DEFAULT_CIRCUIT_BREAKER_CONFIG.resetTimeoutMs,
+    halfOpenMaxRequests: config3.resilience?.circuitBreaker?.halfOpenMaxRequests ?? DEFAULT_CIRCUIT_BREAKER_CONFIG.halfOpenMaxRequests
+  };
+  const keyType = detectKeyType(config3.apiKey);
+  const apiClient = createBearerAPIClient(config3.apiKey, config3.baseUrl);
+  const cache = new SimpleCache({
+    maxSize: cacheMaxSize,
+    ttl: cacheTTL,
+    staleTtl: staleTtlMs
+  });
+  const circuitBreaker = new CircuitBreaker(circuitBreakerConfig);
+  const prebuildDir = config3.resilience?.prebuildDir;
+  const prebuildMod = prebuildDir ? getPrebuildModule() : null;
+  const prebuildLoader = prebuildMod?.canUsePrebuild() && prebuildDir ? new prebuildMod.PrebuildLoader({
+    prebuildDir,
+    maxPrebuildAgeSec: config3.resilience?.maxPrebuildAgeSec
+  }) : null;
+  let lastStatus = null;
+  let isDegraded = false;
+  function emitStatus(source, data, details) {
+    const status = {
+      source,
+      isPreview: details.isPreview,
+      cacheKey: details.cacheKey,
+      error: details.error,
+      staleAgeSec: details.staleAgeSec,
+      prebuildAgeSec: details.prebuildAgeSec,
+      circuit: circuitBreaker.getState(),
+      requestId: details.requestId,
+      durationMs: details.durationMs
+    };
+    lastStatus = status;
+    config3.resilience?.onStatusChange?.(status);
+    const nowDegraded = source === "stale" || source === "error";
+    if (nowDegraded !== isDegraded) {
+      isDegraded = nowDegraded;
+      config3.resilience?.onDegradedMode?.(nowDegraded, status);
+    }
+    return data;
+  }
+  async function resilientFetch(cacheKey, fetcher, options) {
+    const requestId = generateRequestId2();
+    const startTime = Date.now();
+    const isPreview = options.preview ?? false;
+    const statusDetails = (extra = {}) => ({
+      requestId,
+      cacheKey,
+      isPreview,
+      durationMs: Date.now() - startTime,
+      ...extra
+    });
+    if (cacheEnabled && !options.force) {
+      const fresh = cache.getFresh(cacheKey);
+      if (fresh !== null) {
+        return emitStatus("cache", fresh, statusDetails());
+      }
+    }
+    if (resilienceEnabled && circuitBreaker.isOpen()) {
+      if (!isPreview && staleIfError) {
+        const stale = cache.getStale(cacheKey);
+        if (stale) {
+          return emitStatus("stale", stale.value, statusDetails({
+            staleAgeSec: stale.staleAgeSec,
+            error: { code: "circuit_open", message: "Circuit breaker is open" }
+          }));
+        }
+      }
+      if (!isPreview && options.prebuildFallback) {
+        const prebuildResult = options.prebuildFallback();
+        if (prebuildResult) {
+          return emitStatus("prebuild", prebuildResult.data, statusDetails({
+            prebuildAgeSec: prebuildResult.prebuildAgeSec,
+            error: { code: "circuit_open", message: "Circuit breaker is open" }
+          }));
+        }
+      }
+      const circuitState = circuitBreaker.getState();
+      emitStatus("error", null, statusDetails({
+        error: { code: "circuit_open", message: "Circuit breaker is open" }
+      }));
+      throw new CircuitOpenError(circuitState);
+    }
+    try {
+      let data;
+      if (resilienceEnabled) {
+        if (circuitBreaker.getState().state === "half-open") {
+          circuitBreaker.incrementHalfOpenRequests();
+        }
+        data = await fetchWithTimeoutAndRetry(
+          async (timeoutSignal) => {
+            const combinedSignal = options.signal ? combineAbortSignals(timeoutSignal, options.signal) : timeoutSignal;
+            try {
+              const response = await fetcher(combinedSignal);
+              return unwrapResponse(response);
+            } catch (error) {
+              convertToTypedError(error);
+            }
+          },
+          {
+            ...retryConfig,
+            requestTimeoutMs
+          }
+        );
+        circuitBreaker.recordSuccess();
+      } else {
+        try {
+          const response = await fetcher(options.signal ?? new AbortController().signal);
+          data = unwrapResponse(response);
+        } catch (error) {
+          convertToTypedError(error);
+        }
+      }
+      if (cacheEnabled) {
+        cache.set(cacheKey, data);
+      }
+      return emitStatus("live", data, statusDetails());
+    } catch (error) {
+      if (resilienceEnabled && error instanceof Error) {
+        circuitBreaker.recordFailure(error);
+      }
+      if (!isPreview && staleIfError && cacheEnabled) {
+        const stale = cache.getStale(cacheKey);
+        if (stale) {
+          const errorInfo2 = error instanceof RiverbankApiError ? { code: error.code, message: error.message } : { message: error.message };
+          return emitStatus("stale", stale.value, statusDetails({
+            staleAgeSec: stale.staleAgeSec,
+            error: errorInfo2
+          }));
+        }
+      }
+      if (!isPreview && options.prebuildFallback) {
+        const prebuildResult = options.prebuildFallback();
+        if (prebuildResult) {
+          const errorInfo2 = error instanceof RiverbankApiError ? { code: error.code, message: error.message } : { message: error.message };
+          return emitStatus("prebuild", prebuildResult.data, statusDetails({
+            prebuildAgeSec: prebuildResult.prebuildAgeSec,
+            error: errorInfo2
+          }));
+        }
+      }
+      const errorInfo = error instanceof RiverbankApiError ? { code: error.code, message: error.message } : { message: error.message };
+      emitStatus("error", null, statusDetails({ error: errorInfo }));
+      throw error;
+    }
+  }
+  function combineAbortSignals(...signals) {
+    const controller = new AbortController();
+    for (const signal of signals) {
+      if (signal.aborted) {
+        controller.abort(signal.reason);
+        break;
+      }
+      signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+    }
+    return controller.signal;
+  }
+  return {
+    async getSite(params) {
+      const { slug, domain, id, signal } = params;
+      if (!slug && !domain && !id) {
+        throw new Error(
+          `getSite() requires at least one identifier: slug, domain, or id. Received: ${JSON.stringify(params)}`
+        );
+      }
+      const cacheKey = `site:${slug || domain || id}`;
+      const siteId = id || slug || domain;
+      return resilientFetch(cacheKey, async (sig) => {
+        const apiParams = {};
+        if (params.slug) apiParams.slug = params.slug;
+        if (params.domain) apiParams.domain = params.domain;
+        if (params.id) apiParams.id = params.id;
+        return await apiClient({ endpoint: "getSite", params: apiParams, options: { signal: sig } });
+      }, {
+        signal,
+        prebuildFallback: prebuildLoader && siteId ? () => prebuildLoader.loadSite(siteId) : void 0
+      });
+    },
+    async getPage(params) {
+      const { siteId, path: path13, preview = false, signal } = params;
+      const cacheKey = `page:${siteId}:${path13}:${preview}`;
+      return resilientFetch(cacheKey, async (sig) => {
+        return await apiClient({ endpoint: "getContentByPath", params: { siteId }, body: { path: path13, preview }, options: { signal: sig } });
+      }, {
+        preview,
+        signal,
+        // Prebuild fallback only for published pages (not preview)
+        prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadPage(siteId, path13) : void 0
+      });
+    },
+    async getEntries(params) {
+      const { siteId, contentType, limit, offset, order, preview = false, mode, entryIds, includeMeta, signal } = params;
+      const entryIdsCacheKey = mode === "manual" && entryIds?.length ? entryIds.join(",") : "";
+      const cacheKey = `entries:${siteId}:${contentType}:${limit ?? ""}:${offset ?? ""}:${order ?? ""}:${preview}:${mode ?? ""}:${entryIdsCacheKey}:${includeMeta ?? ""}`;
+      return resilientFetch(cacheKey, async (sig) => {
+        let orderParam;
+        if (order === "newest") {
+          orderParam = "published_at.desc";
+        } else if (order === "oldest") {
+          orderParam = "published_at.asc";
+        } else if (order === "title") {
+          orderParam = "title.asc";
+        }
+        const apiParams = {
+          siteId,
+          type: contentType,
+          ...typeof limit === "number" && { limit: String(limit) },
+          ...typeof offset === "number" && { offset: String(offset) },
+          ...includeMeta && { meta: "true" },
+          ...orderParam && { order: orderParam },
+          ...preview && { stage: "preview" },
+          ...mode === "manual" && entryIds?.length && {
+            mode: "manual",
+            entryIds: JSON.stringify(entryIds)
+          }
+        };
+        return await apiClient({ endpoint: "listPublishedEntries", params: apiParams, options: { signal: sig } });
+      }, {
+        preview,
+        signal,
+        // Prebuild fallback only for published entries (not preview, not manual mode)
+        prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadEntries(siteId, params) : void 0
+      });
+    },
+    async getEntry(params) {
+      const { siteId, contentType, slug, signal } = params;
+      const cacheKey = `entry:${siteId}:${contentType}:${slug}`;
+      return resilientFetch(cacheKey, async (sig) => {
+        return await apiClient({ endpoint: "getPublishedEntryPreview", params: { siteId, type: contentType, slug }, options: { signal: sig } });
+      }, { signal });
+    },
+    async getPublicFormById(params) {
+      const { formId, signal } = params;
+      if (!formId) {
+        throw new Error("getPublicFormById() requires formId");
+      }
+      const cacheKey = `public-form:${formId}`;
+      return resilientFetch(cacheKey, async (sig) => {
+        return await apiClient({ endpoint: "getPublicFormById", params: { formId }, options: { signal: sig } });
+      }, { signal });
+    },
+    async getPublicBookingServices(params) {
+      const { siteId, ids, signal } = params;
+      if (!siteId) {
+        throw new Error("getPublicBookingServices() requires siteId");
+      }
+      const cacheKey = `public-booking-services:${siteId}:${ids ?? ""}`;
+      return resilientFetch(cacheKey, async (sig) => {
+        const apiParams = {
+          siteId,
+          ...ids && { ids }
+        };
+        return await apiClient({ endpoint: "getPublicBookingServices", params: apiParams, options: { signal: sig } });
+      }, { signal });
+    },
+    async listPublicEvents(params) {
+      const { siteId, limit, from, to, stage, signal } = params;
+      if (!siteId) {
+        throw new Error("listPublicEvents() requires siteId");
+      }
+      const cacheKey = `public-events:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${stage ?? ""}`;
+      return resilientFetch(cacheKey, async (sig) => {
+        const apiParams = {
+          siteId,
+          ...typeof limit === "number" && { limit: String(limit) },
+          ...from && { from },
+          ...to && { to },
+          ...stage && { stage }
+        };
+        return await apiClient({ endpoint: "listPublicEvents", params: apiParams, options: { signal: sig } });
+      }, { signal });
+    },
+    async resolveEventOccurrence(params) {
+      const { siteId, entryId, segment, signal } = params;
+      if (!siteId || !entryId || !segment) {
+        throw new Error("resolveEventOccurrence() requires siteId, entryId, and segment");
+      }
+      const cacheKey = `event-occurrence:${siteId}:${entryId}:${segment}`;
+      return resilientFetch(cacheKey, async (sig) => {
+        return await apiClient({
+          endpoint: "resolveEventOccurrence",
+          params: { siteId, entryId, segment },
+          options: { signal: sig }
+        });
+      }, { signal });
+    },
+    async checkRedirect(params) {
+      const { siteId, path: path13, signal } = params;
+      if (!siteId || !path13) {
+        throw new Error("checkRedirect() requires siteId and path");
+      }
+      const cacheKey = `redirect:${siteId}:${path13}`;
+      return resilientFetch(cacheKey, async (sig) => {
+        return await apiClient({
+          endpoint: "checkRedirect",
+          params: { site: siteId, path: path13 },
+          options: { signal: sig }
+        });
+      }, { signal });
+    },
+    async getAllPublishedRoutes(params) {
+      const { siteId, signal } = params;
+      if (!siteId) {
+        throw new Error("getAllPublishedRoutes() requires siteId");
+      }
+      const cacheKey = `routable-content:${siteId}:published`;
+      return resilientFetch(cacheKey, async (sig) => {
+        return await apiClient({
+          endpoint: "getPublicRoutableContent",
+          params: { siteId, publishedOnly: "true" },
+          options: { signal: sig }
+        });
+      }, { signal });
+    },
+    clearCache() {
+      cache.clear();
+    },
+    getKeyType() {
+      return keyType;
+    },
+    getLastEmittedStatus() {
+      return lastStatus;
+    },
+    getCircuitState() {
+      return circuitBreaker.getState();
+    }
+  };
+}
+init_constants();
+var MANIFEST_VERSION = "1.0.0";
+var MANIFEST_FILENAME = "manifest.json";
+function pathToFilename(routePath) {
+  if (routePath === "/") return "_home.json";
+  return routePath.slice(1).replace(/[^a-zA-Z0-9\-\/]/g, "_").replace(/\//g, "-") + ".json";
+}
+function ensureDir3(dirPath) {
+  if (!fs6__namespace.existsSync(dirPath)) {
+    fs6__namespace.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function writeJsonFile2(filePath, data) {
+  const content = JSON.stringify(data, null, 2);
+  fs6__namespace.writeFileSync(filePath, content, "utf-8");
+  return Buffer.byteLength(content, "utf-8");
+}
+function calculateChecksum(data) {
+  const { checksum: _, ...rest } = data;
+  const content = JSON.stringify(rest);
+  return crypto2__namespace.createHash("sha256").update(content).digest("hex");
+}
+async function fetchAllEntries(client, siteId, contentType, onProgress) {
+  const allEntries = [];
+  let offset = 0;
+  let hasMore = true;
+  while (hasMore) {
+    onProgress?.(`${contentType} (batch ${Math.floor(offset / PREBUILD_PAGE_SIZE) + 1})`);
+    const response = await client.getEntries({
+      siteId,
+      contentType,
+      limit: PREBUILD_PAGE_SIZE,
+      offset,
+      preview: false
+      // Published content only
+    });
+    allEntries.push(...response.entries);
+    offset += PREBUILD_PAGE_SIZE;
+    hasMore = response.entries.length === PREBUILD_PAGE_SIZE;
+  }
+  return allEntries;
+}
+async function prebuildSite(client, siteId, outputDir) {
+  const site = await client.getSite({ id: siteId });
+  const filename = "site.json";
+  const filePath = path9__namespace.join(outputDir, filename);
+  const cacheFile = {
+    data: site,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const size = writeJsonFile2(filePath, cacheFile);
+  return { files: [filename], size, siteData: site };
+}
+async function prebuildPages(client, siteId, routes, outputDir, onProgress) {
+  const pagesDir = path9__namespace.join(outputDir, "pages");
+  ensureDir3(pagesDir);
+  const files = [];
+  let totalSize = 0;
+  const publishedPaths = Object.entries(routes).filter(([_, route]) => route.status === "published").map(([_, route]) => route.path);
+  const pageIndex = [];
+  const total = publishedPaths.length;
+  let current = 0;
+  for (const pagePath of publishedPaths) {
+    current++;
+    onProgress?.({
+      current,
+      total,
+      item: `Page: ${pagePath}`,
+      contentType: "pages"
+    });
+    try {
+      const pageData = await client.getPage({ siteId, path: pagePath, preview: false });
+      const filename = pathToFilename(pagePath);
+      const filePath = path9__namespace.join(pagesDir, filename);
+      const cacheFile = {
+        data: pageData,
+        path: pagePath,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      totalSize += writeJsonFile2(filePath, cacheFile);
+      files.push(`pages/${filename}`);
+      if ("page" in pageData) {
+        pageIndex.push({
+          path: pagePath,
+          pageId: pageData.page.routeId || "",
+          title: pageData.page.name || "Untitled"
+        });
+      }
+    } catch (error) {
+      console.warn(`[Prebuild] Failed to fetch page ${pagePath}:`, error.message);
+    }
+  }
+  const indexFile = {
+    pages: pageIndex,
+    totalCount: pageIndex.length,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const indexPath = path9__namespace.join(pagesDir, "_index.json");
+  totalSize += writeJsonFile2(indexPath, indexFile);
+  files.push("pages/_index.json");
+  return { files, size: totalSize };
+}
+async function prebuildEntries(client, siteId, contentTypes, outputDir, onProgress) {
+  const entriesDir = path9__namespace.join(outputDir, "entries");
+  ensureDir3(entriesDir);
+  const files = [];
+  let totalSize = 0;
+  const total = contentTypes.length;
+  let current = 0;
+  for (const contentType of contentTypes) {
+    current++;
+    const entries = await fetchAllEntries(
+      client,
+      siteId,
+      contentType,
+      (item) => {
+        onProgress?.({
+          current,
+          total,
+          item: `Entries: ${item}`,
+          contentType: "entries"
+        });
+      }
+    );
+    const typeDir = path9__namespace.join(entriesDir, contentType);
+    ensureDir3(typeDir);
+    const cacheFile = {
+      entries,
+      contentType,
+      totalCount: entries.length,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const filename = `entries/${contentType}/all.json`;
+    const filePath = path9__namespace.join(entriesDir, contentType, "all.json");
+    totalSize += writeJsonFile2(filePath, cacheFile);
+    files.push(filename);
+  }
+  return { files, size: totalSize };
+}
+async function prebuildNavigation(siteData, outputDir, onProgress) {
+  const navDir = path9__namespace.join(outputDir, "navigation");
+  ensureDir3(navDir);
+  const files = [];
+  let totalSize = 0;
+  const menus = siteData.navigation || [];
+  onProgress?.({
+    current: 1,
+    total: 1,
+    item: "Navigation menus",
+    contentType: "navigation"
+  });
+  const cacheFile = {
+    menus: menus.map((menu) => ({
+      identifier: menu.identifier,
+      id: menu.id,
+      name: menu.name,
+      items: menu.items
+    })),
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const filename = "navigation/menus.json";
+  const filePath = path9__namespace.join(navDir, "menus.json");
+  totalSize += writeJsonFile2(filePath, cacheFile);
+  files.push(filename);
+  return { files, size: totalSize };
+}
+async function prebuildCache(options) {
+  const {
+    client,
+    siteId,
+    outputDir = DEFAULT_PREBUILD_DIR,
+    include = ["site", "pages", "entries", "navigation"],
+    contentTypes,
+    onProgress
+  } = options;
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const files = [];
+  let totalSize = 0;
+  const errors = [];
+  let siteData = null;
+  ensureDir3(outputDir);
+  if (include.includes("site") || include.includes("pages") || include.includes("navigation")) {
+    try {
+      const result = await prebuildSite(client, siteId, outputDir);
+      siteData = result.siteData;
+      if (include.includes("site")) {
+        files.push(...result.files);
+        totalSize += result.size;
+      }
+      onProgress?.({ current: 1, total: 4, item: "Site data", contentType: "site" });
+    } catch (error) {
+      errors.push(`Site prebuild failed: ${error.message}`);
+    }
+  }
+  if (include.includes("pages") && siteData) {
+    try {
+      const result = await prebuildPages(
+        client,
+        siteId,
+        siteData.routes,
+        outputDir,
+        onProgress
+      );
+      files.push(...result.files);
+      totalSize += result.size;
+    } catch (error) {
+      errors.push(`Pages prebuild failed: ${error.message}`);
+    }
+  }
+  if (include.includes("entries")) {
+    try {
+      const typesToPrebuild = contentTypes || [];
+      if (typesToPrebuild.length > 0) {
+        const result = await prebuildEntries(
+          client,
+          siteId,
+          typesToPrebuild,
+          outputDir,
+          onProgress
+        );
+        files.push(...result.files);
+        totalSize += result.size;
+      } else {
+        console.warn("[Prebuild] No contentTypes provided - skipping entries prebuild");
+      }
+    } catch (error) {
+      errors.push(`Entries prebuild failed: ${error.message}`);
+    }
+  }
+  if (include.includes("navigation") && siteData) {
+    try {
+      const result = await prebuildNavigation(siteData, outputDir, onProgress);
+      files.push(...result.files);
+      totalSize += result.size;
+    } catch (error) {
+      errors.push(`Navigation prebuild failed: ${error.message}`);
+    }
+  }
+  const keyToFile = {};
+  if (files.includes("site.json")) {
+    keyToFile[`site:${siteId}`] = "site.json";
+  }
+  for (const file of files) {
+    if (file.startsWith("pages/") && file !== "pages/_index.json") {
+      const filename = file.replace("pages/", "").replace(".json", "");
+      const pagePath = filename === "_home" ? "/" : "/" + filename.replace(/-/g, "/");
+      keyToFile[`page:${siteId}:${pagePath}:false`] = file;
+    }
+    if (file.startsWith("entries/") && file.endsWith("/all.json")) {
+      const contentType = file.split("/")[1];
+      keyToFile[`entries-all:${siteId}:${contentType}`] = file;
+    }
+  }
+  const manifest = {
+    version: MANIFEST_VERSION,
+    generatedAt,
+    siteId,
+    sdkVersion: SDK_VERSION,
+    keyToFile,
+    includedTypes: include,
+    fileCount: files.length,
+    totalSize
+  };
+  const checksum = calculateChecksum(manifest);
+  manifest.checksum = checksum;
+  const manifestPath = path9__namespace.join(outputDir, MANIFEST_FILENAME);
+  writeJsonFile2(manifestPath, manifest);
+  return {
+    success: errors.length === 0,
+    outputDir,
+    files,
+    totalSize,
+    generatedAt,
+    checksum,
+    errors: errors.length > 0 ? errors : void 0
+  };
+}
+
+// src/cli/commands/deploy.ts
+init_constants();
+async function loadDeployConfig() {
+  const rawConfig = await loadConfigFile();
+  const config3 = rawConfig;
+  if (!config3.siteId) {
+    throw new Error("siteId is required in riverbank.config.ts");
+  }
+  const contentTypes = config3.content?.contentTypes?.map((ct) => ct.key);
+  return {
+    siteId: config3.siteId,
+    deploy: config3.deploy ?? {},
+    contentTypes
+  };
+}
+async function checkWorkingDirectoryClean(git, prebuildOutput) {
+  const status = await git.status();
+  const dirtyFiles = status.files.map((f) => f.path).filter((path13) => !path13.startsWith(prebuildOutput));
+  return {
+    clean: dirtyFiles.length === 0,
+    dirtyFiles
+  };
+}
+async function commitCacheIfChanged(git, prebuildOutput) {
+  const status = await git.status();
+  const cacheChanges = status.files.filter((f) => f.path.startsWith(prebuildOutput));
+  if (cacheChanges.length === 0) {
+    return false;
+  }
+  await git.add(prebuildOutput);
+  const log = await git.log({ maxCount: 1 });
+  const lastCommit = log.latest;
+  const isLastCommitCache = lastCommit?.message.startsWith("chore: update prebuild cache");
+  let isUnpushed = false;
+  if (isLastCommitCache && lastCommit) {
+    try {
+      const branches = await git.branch(["-r", "--contains", lastCommit.hash]);
+      isUnpushed = branches.all.length === 0;
+    } catch (error) {
+      if (process.env.DEBUG) {
+        console.debug("[deploy] Could not check remote branches:", error);
+      }
+      isUnpushed = true;
+    }
+  }
+  if (isLastCommitCache && isUnpushed) {
+    await git.commit([], { "--amend": null, "--no-edit": null });
+  } else {
+    await git.commit("chore: update prebuild cache");
+  }
+  return true;
+}
+var deployCommand = new commander.Command("deploy").description("Deploy site with prebuild cache generation").option("--preview", "Preview deploy - skip prebuild cache generation").addHelpText("after", `
+Examples:
+  $ riverbankcms deploy           # Full deploy with cache generation
+  $ riverbankcms deploy --preview # Deploy without regenerating cache
+
+Configuration (riverbank.config.ts):
+  deploy: {
+    verifyCommand: 'pnpm verify',      // Command to run before deploy
+    prebuildOutput: '.riverbank-cache', // Prebuild output directory
+  }
+
+Workflow:
+  1. Run verifyCommand (if configured)
+  2. Check working directory is clean
+  3. Generate prebuild cache (unless --preview)
+  4. Commit cache changes (squashes consecutive unpushed commits)
+  5. Push to remote
+
+Notes:
+  - Requires git repository with remote configured
+  - CMS failure during prebuild continues with existing cache
+  - Uses --remote environment variables for API access
+`).action(async (options, command) => {
+  const { output } = getOutputContext(command);
+  const git = simpleGit__default.default();
+  try {
+    if (!await git.checkIsRepo()) {
+      return output.error("Not a git repository", {
+        suggestion: "Run this command from your project root directory"
+      });
+    }
+    output.info("Loading configuration...");
+    const config3 = await loadDeployConfig();
+    const prebuildOutput = config3.deploy.prebuildOutput ?? DEFAULT_PREBUILD_DIR;
+    if (config3.deploy.verifyCommand) {
+      output.info(`Running verification: ${config3.deploy.verifyCommand}`);
+      try {
+        child_process.execSync(config3.deploy.verifyCommand, { stdio: "inherit" });
+        output.success("Verification passed");
+      } catch {
+        return output.error("Verification failed", {
+          suggestion: "Fix the issues reported by the verify command and try again"
+        });
+      }
+    } else {
+      output.warn("No verifyCommand configured, skipping verification");
+    }
+    const { clean, dirtyFiles } = await checkWorkingDirectoryClean(git, prebuildOutput);
+    if (!clean) {
+      output.warn("Uncommitted changes detected:");
+      dirtyFiles.slice(0, 5).forEach((f) => output.warn(`  - ${f}`));
+      if (dirtyFiles.length > 5) {
+        output.warn(`  ... and ${dirtyFiles.length - 5} more files`);
+      }
+      return output.error("Working directory not clean", {
+        suggestion: "Commit or stash your changes before deploying"
+      });
+    }
+    if (!options.preview) {
+      output.info("Generating prebuild cache...");
+      try {
+        const env = loadEnvironment(true);
+        const client = createRiverbankClient({
+          apiKey: env.managementApiKey,
+          baseUrl: env.dashboardUrl
+        });
+        const result = await prebuildCache({
+          client,
+          siteId: config3.siteId,
+          outputDir: prebuildOutput,
+          contentTypes: config3.contentTypes,
+          onProgress: (p) => {
+            output.info(`  ${p.item}`);
+          }
+        });
+        if (result.success) {
+          output.success(`Prebuild complete: ${result.files.length} files (${formatBytes(result.totalSize)})`);
+        } else {
+          output.warn("Prebuild completed with errors:");
+          result.errors?.forEach((e) => output.warn(`  - ${e}`));
+        }
+        const committed = await commitCacheIfChanged(git, prebuildOutput);
+        if (committed) {
+          output.success("Cache committed");
+        } else {
+          output.info("Cache unchanged, no commit needed");
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        output.warn(`Prebuild failed: ${message}`);
+        output.warn("Continuing with existing cache...");
+      }
+    } else {
+      output.info("Skipping prebuild cache (--preview mode)");
+    }
+    output.info("Pushing to remote...");
+    try {
+      await git.push();
+      output.success("Deploy triggered successfully!");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return output.error(`Push failed: ${message}`, {
+        suggestion: "Check your git remote configuration and permissions"
+      });
+    }
+  } catch (error) {
+    handleCommandError(error, output);
+  }
+});
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
 // src/cli/index.ts
 dotenv.config({ path: ".env.local" });
 dotenv.config({ path: ".env" });
@@ -8729,6 +12382,7 @@ program.addCommand(deleteCommand);
 program.addCommand(previewCommand);
 program.addCommand(initDocsCommand);
 program.addCommand(identifiersCommand);
+program.addCommand(deployCommand);
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map