@riverbankcms/sdk 0.7.5 → 0.8.1

package/dist/cli/index.js

@@ -3,16 +3,20 @@
 
 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');
-var prompts = require('prompts');
 var fs3 = require('fs/promises');
 var readline = require('readline');
+var prompts = require('prompts');
 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 prompts__default = /*#__PURE__*/_interopDefault(prompts);
+var fs6__namespace = /*#__PURE__*/_interopNamespace(fs6);
 var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
 var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
+var prompts__default = /*#__PURE__*/_interopDefault(prompts);
 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 ?? [];
@@ -254,7 +506,11 @@ var uiSchema = zod.z.object({
   layout: zod.z.enum(["stack", "grid"]).optional(),
   columns: zod.z.number().int().min(2).max(4).optional(),
   // Entry picker configuration
-  contentTypeField: zod.z.string().optional()
+  contentTypeField: zod.z.string().optional(),
+  // Extras pattern: fields marked as extras are hidden behind a modal toggle
+  extras: zod.z.boolean().optional(),
+  // Render in block header instead of form body (used for section styles)
+  renderInHeader: zod.z.boolean().optional()
 }).partial();
 var baseFieldSchema = zod.z.object({
   id: zod.z.string().min(1, "Field id is required"),
@@ -574,11 +830,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 +907,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 +934,7 @@ function createBackgroundImageNode(path11, baseClassName = "absolute -z-10") {
       },
       style: {
         $bind: {
-          from: path11,
+          from: path13,
           transforms: [{ id: "background.resolveImageStyle" }]
         }
       }
@@ -1106,27 +1362,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
@@ -1424,25 +1680,30 @@ function createButtonGroup(options = {}) {
       ui: { colSpan: 2 }
     }
   ];
-  const iconsGroup = {
-    id: "icons",
-    type: "group",
-    label: "Icons",
-    required: false,
-    ui: { preset: "disclosure", colSpan: 2 },
-    schema: {
-      fields: [
-        { id: "iconLeft", type: "media", label: "Left icon", required: false, mediaKinds: ["image"] },
-        { id: "iconRight", type: "media", label: "Right icon", required: false, mediaKinds: ["image"] }
-      ]
+  const iconFields = [
+    {
+      id: "iconLeft",
+      type: "media",
+      label: "Left icon",
+      required: false,
+      mediaKinds: ["image"],
+      ui: { extras: true }
+    },
+    {
+      id: "iconRight",
+      type: "media",
+      label: "Right icon",
+      required: false,
+      mediaKinds: ["image"],
+      ui: { extras: true }
     }
-  };
+  ];
   return {
     id: groupId,
     type: "group",
     label: groupLabel,
     ui: { layout: "grid", columns: 2, flattenInRepeater, hideLabel: !showGroupLabel },
-    schema: { fields: [...mainFields, iconsGroup] },
+    schema: { fields: [...mainFields, ...iconFields] },
     required: false
   };
 }
@@ -2738,6 +2999,10 @@ var BACKGROUND_POSITION_PRESETS = [
 BACKGROUND_POSITION_PRESETS.map((p) => p.value);
 
 // ../blocks/src/system/fields/background.ts
+var BACKGROUND_WIDGETS = {
+  COLOR: "backgroundColor",
+  GRADIENT: "backgroundGradient"
+};
 function createBackgroundField(options = {}) {
   const {
     id = "background",
@@ -2763,8 +3028,7 @@ function createBackgroundField(options = {}) {
           required: false,
           multiline: false,
           ui: {
-            // Use BackgroundColorWidget via widget override
-            widget: "backgroundColor"
+            widget: BACKGROUND_WIDGETS.COLOR
           }
         }
       ]
@@ -2781,11 +3045,11 @@ function createBackgroundField(options = {}) {
           id: "gradient",
           type: "text",
           label: "Gradient",
-          description: "CSS gradient value (e.g., linear-gradient(to right, #ff0000, #00ff00)).",
+          description: "Select a gradient from theme presets.",
           required: false,
-          multiline: true,
+          multiline: false,
           ui: {
-            placeholder: "linear-gradient(to right, #ff0000, #00ff00)"
+            widget: BACKGROUND_WIDGETS.GRADIENT
           }
         }
       ]
@@ -2844,7 +3108,7 @@ function createBackgroundField(options = {}) {
         id: "position",
         type: "presetOrCustom",
         label: "Position",
-        description: 'Anchor point for the image. Relevant for "Fill" and "Custom size" options.',
+        description: 'Anchor point for scaled images. For "Fill" mode, the image focus point (if set) takes precedence.',
         required: false,
         presets: [...BACKGROUND_POSITION_PRESETS],
         customInput: {
@@ -2935,6 +3199,8 @@ function sectionStylesField(options = {}) {
     required: false,
     schema: { fields: fields4 },
     ui: {
+      // Render in block header instead of form body
+      renderInHeader: true,
       modalConfig: {
         buttonLabel: label,
         description: "Configure background and spacing for this section.",
@@ -5133,7 +5399,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,
@@ -5391,111 +5657,6 @@ var riverbankSiteConfigSchema = zod.z.object({
 
 // src/cli/push-config.ts
 init_load_config();
-async function pushToDashboard(dashboardUrl, siteId, apiKey, config3) {
-  const pushUrl = `${dashboardUrl}/api/sites/${siteId}/sdk-config`;
-  console.log(`Pushing config to ${pushUrl}...`);
-  let response;
-  try {
-    response = await fetch(pushUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({ config: config3 }),
-      signal: AbortSignal.timeout(3e4)
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    throw new Error(`Failed to connect to dashboard: ${message}`);
-  }
-  if (!response.ok) {
-    let errorMessage = `Dashboard returned ${response.status}`;
-    try {
-      const errorBody = await response.json();
-      if (errorBody.error) {
-        errorMessage = errorBody.error;
-        if (errorBody.details) {
-          errorMessage += ":\n" + errorBody.details.map((d) => `  - ${d.path}: ${d.message}`).join("\n");
-        }
-      }
-    } catch {
-    }
-    throw new Error(errorMessage);
-  }
-}
-async function pushConfigAction(options) {
-  try {
-    const rawConfig = await loadConfigFile(options.config);
-    console.log("Validating config...");
-    const parseResult = riverbankSiteConfigSchema.safeParse(rawConfig);
-    if (!parseResult.success) {
-      console.error("Invalid config:");
-      for (const issue of parseResult.error.issues) {
-        console.error(`  - ${issue.path.join(".")}: ${issue.message}`);
-      }
-      process.exit(1);
-    }
-    const conflicts = validateFieldIdConflicts(parseResult.data.blockFieldExtensions);
-    if (conflicts.length > 0) {
-      console.error("Field ID conflicts detected in blockFieldExtensions:");
-      for (const conflict of conflicts) {
-        console.error(`  - ${conflict.message}`);
-      }
-      process.exit(1);
-    }
-    const { siteId } = parseResult.data;
-    const apiKey = resolveManagementApiKey(options.apiKey, options.isRemote);
-    await pushToDashboard(options.dashboard, siteId, apiKey, parseResult.data);
-    console.log("Config pushed successfully!");
-  } catch (error) {
-    console.error("Error:", error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-}
-function resolveDashboardUrl(cliOption, isRemote) {
-  const envVar = isRemote ? "RIVERBANK_REMOTE_DASHBOARD_URL" : "RIVERBANK_LOCAL_DASHBOARD_URL";
-  const url = cliOption || process.env[envVar];
-  if (!url) {
-    console.error("Error: Dashboard URL is required.");
-    console.error(`Provide --dashboard <url> or set ${envVar} environment variable.`);
-    process.exit(1);
-  }
-  return url;
-}
-function resolveManagementApiKey(cliOption, isRemote) {
-  const envVar = isRemote ? "RIVERBANK_REMOTE_MGMT_API_KEY" : "RIVERBANK_LOCAL_MGMT_API_KEY";
-  const apiKey = cliOption || process.env[envVar];
-  if (!apiKey) {
-    console.error("Error: Management API key is required.");
-    console.error(`Provide --api-key <key> or set ${envVar} environment variable.`);
-    process.exit(1);
-  }
-  if (!apiKey.startsWith("bld_mgmt_sk_")) {
-    console.error(`Error: Invalid management API key format for ${envVar}.`);
-    console.error("Expected key starting with bld_mgmt_sk_.");
-    process.exit(1);
-  }
-  return apiKey;
-}
-var pushConfigCommand = new commander.Command("push-config").description("Push SDK config to dashboard").option("--api-key <key>", "Management API key (or set RIVERBANK_*_MGMT_API_KEY)").option("--dashboard <url>", "Dashboard URL (or set RIVERBANK_*_DASHBOARD_URL env var)").option("--config <path>", "Path to config file (default: ./riverbank.config.ts)").addHelpText("after", `
-Description:
-  Syncs your local riverbank.config.ts to the CMS dashboard, including:
-  - Custom blocks
-  - Block field extensions
-  - Block field options
-  - Content types, pages, entries, and navigation
-
-Examples:
-  $ npx riverbankcms push-config
-  $ npx riverbankcms push-config --api-key bld_mgmt_sk_... --dashboard https://www.riverbankcms.com
-  $ npx riverbankcms push-config --config ./src/riverbank.config.ts
-`).action((options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  const isRemote = globalOpts.remote ?? false;
-  const dashboard = resolveDashboardUrl(options.dashboard, isRemote);
-  return pushConfigAction({ ...options, dashboard, isRemote });
-});
 
 // src/client/management/http.ts
 var ManagementApiError = class extends Error {
@@ -5507,11 +5668,14 @@ var ManagementApiError = class extends Error {
     this.statusCode = statusCode;
   }
 };
+function is404Error(error) {
+  return error instanceof ManagementApiError && error.statusCode === 404;
+}
 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 +5743,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 });
     }
   };
 }
@@ -5612,7 +5776,7 @@ function createEntryOperations(http) {
           `/entries/${encodeURIComponent(contentType)}/${encodeURIComponent(identifier)}`
         );
       } catch (error) {
-        if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+        if (is404Error(error)) {
           return null;
         }
         throw error;
@@ -5654,7 +5818,7 @@ function createPageOperations(http) {
           `/pages/${encodeURIComponent(identifier)}`
         );
       } catch (error) {
-        if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+        if (is404Error(error)) {
           return null;
         }
         throw error;
@@ -5687,7 +5851,7 @@ function createBlockOperations(http) {
           `/pages/${encodeURIComponent(pageIdentifier)}/blocks/${encodeURIComponent(blockIdentifier)}`
         );
       } catch (error) {
-        if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+        if (is404Error(error)) {
           return null;
         }
         throw error;
@@ -5726,7 +5890,7 @@ function createNavigationOperations(http) {
           `/navigation/${encodeURIComponent(name)}`
         );
       } catch (error) {
-        if (error instanceof Error && "statusCode" in error && error.statusCode === 404) {
+        if (is404Error(error)) {
           return null;
         }
         throw error;
@@ -5795,6 +5959,9 @@ function createPullOperations(http) {
           truncationMessage: entriesResult?.meta?.truncationMessage
         }
       };
+    },
+    async siteInfo() {
+      return http.get("/pull/site-info");
     }
   };
 }
@@ -5817,43 +5984,164 @@ function createIdentifiersOperations(http) {
   };
 }
 
-// src/client/management/index.ts
-function createManagementClient(config3) {
-  if (!config3.dashboardUrl) {
-    throw new Error(
-      "dashboardUrl is required when creating a management client. Example: http://localhost:4000 or https://dashboard.riverbankcms.com"
-    );
-  }
-  if (!config3.managementApiKey) {
-    throw new Error(
-      "managementApiKey is required when creating a management client. A management API key starts with bld_mgmt_sk_"
-    );
-  }
-  if (!config3.managementApiKey.startsWith("bld_mgmt_sk_")) {
-    throw new Error(
-      "Invalid management API key format. A management API key must start with bld_mgmt_sk_"
-    );
-  }
-  if (!config3.siteId) {
-    throw new Error(
-      "siteId is required when creating a management client."
-    );
+// src/client/management/media.ts
+function createMediaOperations(config3) {
+  const baseUrl = `${config3.dashboardUrl}/api/sdk/${config3.siteId}`;
+  const timeout = config3.timeout ?? 6e4;
+  async function formDataRequest(path13, formData) {
+    const url = `${baseUrl}${path13}`;
+    const headers = {
+      "Authorization": `Bearer ${config3.managementApiKey}`
+      // Note: Don't set Content-Type - let fetch set it with boundary
+    };
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: formData,
+        signal: AbortSignal.timeout(timeout)
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "TimeoutError") {
+        throw new ManagementApiError(
+          `Request timed out after ${timeout}ms`,
+          "sdk:timeout",
+          void 0,
+          void 0
+        );
+      }
+      throw new ManagementApiError(
+        error instanceof Error ? error.message : "Network request failed",
+        "sdk:network-error",
+        void 0,
+        void 0
+      );
+    }
+    const json = await response.json();
+    if (!response.ok || !json.success) {
+      if (json.error) {
+        throw new ManagementApiError(
+          json.error.message,
+          json.error.code,
+          json.error.details,
+          response.status
+        );
+      }
+      throw new ManagementApiError(
+        `Request failed with status ${response.status}`,
+        "sdk:http-error",
+        void 0,
+        response.status
+      );
+    }
+    return json.data;
   }
-  const http = createHttpClient(config3);
-  return {
-    entries: createEntryOperations(http),
-    pages: createPageOperations(http),
-    blocks: createBlockOperations(http),
-    navigation: createNavigationOperations(http),
-    settings: createSettingsOperations(http),
-    pull: createPullOperations(http),
-    preview: createPreviewOperations(http),
-    identifiers: createIdentifiersOperations(http)
-  };
-}
-
-// src/cli/env.ts
-function getEnvPrefix(target) {
+  async function jsonRequest(path13, body) {
+    const url = `${baseUrl}${path13}`;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${config3.managementApiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(3e4)
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "TimeoutError") {
+        throw new ManagementApiError(
+          "Request timed out after 30000ms",
+          "sdk:timeout",
+          void 0,
+          void 0
+        );
+      }
+      throw new ManagementApiError(
+        error instanceof Error ? error.message : "Network request failed",
+        "sdk:network-error",
+        void 0,
+        void 0
+      );
+    }
+    const json = await response.json();
+    if (!response.ok || !json.success) {
+      if (json.error) {
+        throw new ManagementApiError(
+          json.error.message,
+          json.error.code,
+          json.error.details,
+          response.status
+        );
+      }
+      throw new ManagementApiError(
+        `Request failed with status ${response.status}`,
+        "sdk:http-error",
+        void 0,
+        response.status
+      );
+    }
+    return json.data;
+  }
+  return {
+    async upload(file) {
+      const formData = new FormData();
+      const blob = new Blob([new Uint8Array(file.data)], { type: file.contentType });
+      formData.append("file", blob, file.filename);
+      formData.append("storagePath", file.storagePath);
+      return formDataRequest("/media/upload", formData);
+    },
+    async exists(storagePath) {
+      const result = await jsonRequest("/media/exists", { storagePath });
+      return result.exists;
+    }
+  };
+}
+
+// src/client/management/index.ts
+function createManagementClient(config3) {
+  if (!config3.dashboardUrl) {
+    throw new Error(
+      "dashboardUrl is required when creating a management client. Example: http://localhost:4000 or https://dashboard.riverbankcms.com"
+    );
+  }
+  if (!config3.managementApiKey) {
+    throw new Error(
+      "managementApiKey is required when creating a management client. A management API key starts with bld_mgmt_sk_"
+    );
+  }
+  if (!config3.managementApiKey.startsWith("bld_mgmt_sk_")) {
+    throw new Error(
+      "Invalid management API key format. A management API key must start with bld_mgmt_sk_"
+    );
+  }
+  if (!config3.siteId) {
+    throw new Error(
+      "siteId is required when creating a management client."
+    );
+  }
+  const http = createHttpClient(config3);
+  return {
+    entries: createEntryOperations(http),
+    pages: createPageOperations(http),
+    blocks: createBlockOperations(http),
+    navigation: createNavigationOperations(http),
+    settings: createSettingsOperations(http),
+    pull: createPullOperations(http),
+    preview: createPreviewOperations(http),
+    identifiers: createIdentifiersOperations(http),
+    media: createMediaOperations(config3)
+  };
+}
+
+// src/cli/env.ts
+function getEnvVarName(key, remote) {
+  const target = remote ? "REMOTE" : "LOCAL";
+  return `RIVERBANK_${target}_${key}`;
+}
+function getEnvPrefix(target) {
   return target === "remote" ? "RIVERBANK_REMOTE" : "RIVERBANK_LOCAL";
 }
 function requireEnv(name) {
@@ -5863,12 +6151,16 @@ function requireEnv(name) {
   }
   return value;
 }
+function getEnv(name, fallback) {
+  return process.env[name] ?? fallback;
+}
 function loadEnvironment(remote) {
   const target = remote ? "remote" : "local";
   const prefix = getEnvPrefix(target);
   const siteId = requireEnv(`${prefix}_SITE_ID`);
   const dashboardUrl = requireEnv(`${prefix}_DASHBOARD_URL`);
   const managementApiKey = requireEnv(`${prefix}_MGMT_API_KEY`);
+  const supabaseUrl = getEnv(`${prefix}_SUPABASE_URL`);
   if (!managementApiKey.startsWith("bld_mgmt_sk_")) {
     throw new Error(
       `Invalid management API key format for ${prefix}_MGMT_API_KEY. Expected key starting with bld_mgmt_sk_`
@@ -5881,10 +6173,20 @@ function loadEnvironment(remote) {
       `Invalid dashboard URL in ${prefix}_DASHBOARD_URL: ${dashboardUrl}. Expected format: http://localhost:4000 or https://dashboard.example.com`
     );
   }
+  if (supabaseUrl) {
+    try {
+      new URL(supabaseUrl);
+    } catch {
+      throw new Error(
+        `Invalid Supabase URL in ${prefix}_SUPABASE_URL: ${supabaseUrl}. Expected format: http://127.0.0.1:54321 or https://xxx.supabase.co`
+      );
+    }
+  }
   return {
     siteId,
     dashboardUrl,
-    managementApiKey
+    managementApiKey,
+    supabaseUrl
   };
 }
 
@@ -6261,6 +6563,112 @@ function createListCommand(config3) {
   );
 }
 
+// src/cli/push-config.ts
+async function pushToDashboard(output, dashboardUrl, siteId, apiKey, config3) {
+  const pushUrl = `${dashboardUrl}/api/sites/${siteId}/sdk-config`;
+  output.info(`Pushing config to ${pushUrl}...`);
+  let response;
+  try {
+    response = await fetch(pushUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ config: config3 }),
+      signal: AbortSignal.timeout(3e4)
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to connect to dashboard: ${message}`);
+  }
+  if (!response.ok) {
+    let errorMessage = `Dashboard returned ${response.status}`;
+    try {
+      const errorBody = await response.json();
+      if (errorBody.error) {
+        errorMessage = errorBody.error;
+        if (errorBody.details) {
+          errorMessage += ":\n" + errorBody.details.map((d) => `  - ${d.path}: ${d.message}`).join("\n");
+        }
+      }
+    } catch {
+    }
+    throw new Error(errorMessage);
+  }
+}
+async function pushConfigAction(output, options) {
+  try {
+    const rawConfig = await loadConfigFile(options.config);
+    output.info("Validating config...");
+    const parseResult = riverbankSiteConfigSchema.safeParse(rawConfig);
+    if (!parseResult.success) {
+      output.error("Invalid config", {
+        issues: parseResult.error.issues.map((issue) => ({
+          path: issue.path.join("."),
+          message: issue.message
+        }))
+      });
+    }
+    const conflicts = validateFieldIdConflicts(parseResult.data.blockFieldExtensions);
+    if (conflicts.length > 0) {
+      output.error("Field ID conflicts detected in blockFieldExtensions", {
+        conflicts: conflicts.map((c) => c.message)
+      });
+    }
+    const { siteId } = parseResult.data;
+    const apiKey = resolveManagementApiKey(output, options.apiKey, options.isRemote);
+    await pushToDashboard(output, options.dashboard, siteId, apiKey, parseResult.data);
+    output.success("Config pushed successfully!");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    output.error(message);
+  }
+}
+function resolveDashboardUrl(output, cliOption, isRemote) {
+  const envVar = getEnvVarName("DASHBOARD_URL", isRemote);
+  const url = cliOption || process.env[envVar];
+  if (!url) {
+    output.error("Dashboard URL is required", {
+      suggestion: `Provide --dashboard <url> or set ${envVar} environment variable.`
+    });
+  }
+  return url;
+}
+function resolveManagementApiKey(output, cliOption, isRemote) {
+  const envVar = getEnvVarName("MGMT_API_KEY", isRemote);
+  const apiKey = cliOption || process.env[envVar];
+  if (!apiKey) {
+    output.error("Management API key is required", {
+      suggestion: `Provide --api-key <key> or set ${envVar} environment variable.`
+    });
+  }
+  if (!apiKey.startsWith("bld_mgmt_sk_")) {
+    output.error("Invalid management API key format", {
+      expected: "Key starting with bld_mgmt_sk_",
+      suggestion: `Check your ${envVar} environment variable.`
+    });
+  }
+  return apiKey;
+}
+var pushConfigCommand = new commander.Command("push-config").description("Push SDK config to dashboard").option("--api-key <key>", "Management API key (or set RIVERBANK_*_MGMT_API_KEY)").option("--dashboard <url>", "Dashboard URL (or set RIVERBANK_*_DASHBOARD_URL env var)").option("--config <path>", "Path to config file (default: ./riverbank.config.ts)").addHelpText("after", `
+Description:
+  Syncs your local riverbank.config.ts to the CMS dashboard, including:
+  - Custom blocks
+  - Block field extensions
+  - Block field options
+  - Content types, pages, entries, and navigation
+
+Examples:
+  $ npx riverbankcms push-config
+  $ npx riverbankcms push-config --api-key bld_mgmt_sk_... --dashboard https://www.riverbankcms.com
+  $ npx riverbankcms push-config --config ./src/riverbank.config.ts
+`).action((options, command) => {
+  const { output, isRemote } = getOutputContext(command);
+  const dashboard = resolveDashboardUrl(output, options.dashboard, isRemote);
+  return pushConfigAction(output, { ...options, dashboard, isRemote });
+});
+
 // src/cli/sync/mapper.ts
 function stripNavigationItemIds(items) {
   return items.map((item) => {
@@ -6364,6 +6772,53 @@ async function writeSettings(contentDir, pulledSettings) {
   await writeJsonFile(filePath, pulledSettings.settings);
   return filePath;
 }
+async function updateMetadataAfterPush(contentDir, remoteContent) {
+  const metaDir = path9__namespace.join(contentDir, ".meta");
+  await ensureDir(metaDir);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const [contentType, entries] of Object.entries(remoteContent.entries)) {
+    const metaPath = path9__namespace.join(metaDir, `${contentType}.json`);
+    const entriesMeta = {};
+    for (const entry of entries) {
+      entriesMeta[entry.identifier] = {
+        createdAt: entry.createdAt,
+        updatedAt: entry.updatedAt
+      };
+    }
+    await writeJsonFile(metaPath, {
+      pulledAt: now,
+      entries: entriesMeta
+    });
+  }
+  if (remoteContent.pages.length > 0) {
+    const metaPath = path9__namespace.join(metaDir, "pages.json");
+    const pagesMeta = {};
+    for (const page of remoteContent.pages) {
+      pagesMeta[page.identifier] = {
+        createdAt: page.createdAt,
+        updatedAt: page.updatedAt
+      };
+    }
+    await writeJsonFile(metaPath, {
+      pulledAt: now,
+      pages: pagesMeta
+    });
+  }
+  if (remoteContent.navigation.length > 0) {
+    const metaPath = path9__namespace.join(metaDir, "navigation.json");
+    const menusMeta = {};
+    for (const menu of remoteContent.navigation) {
+      menusMeta[menu.name] = {
+        createdAt: menu.createdAt,
+        updatedAt: menu.updatedAt
+      };
+    }
+    await writeJsonFile(metaPath, {
+      pulledAt: now,
+      menus: menusMeta
+    });
+  }
+}
 async function fileExists(filePath) {
   try {
     await fs3__namespace.access(filePath);
@@ -6512,6 +6967,107 @@ async function readNavigationMeta(contentDir) {
   }
 }
 
+// src/cli/sync/media.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  baseDelayMs: 1e3,
+  // 1 second
+  maxDelayMs: 1e4
+  // 10 seconds
+};
+function sleep(ms) {
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
+}
+function getBackoffDelay(attempt, baseDelayMs, maxDelayMs) {
+  const exponentialDelay = baseDelayMs * Math.pow(2, attempt);
+  const jitter = exponentialDelay * (0.75 + Math.random() * 0.5);
+  return Math.min(jitter, maxDelayMs);
+}
+async function withRetry(fn, options = {}) {
+  const { maxRetries, baseDelayMs, maxDelayMs } = { ...DEFAULT_RETRY_CONFIG, ...options };
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < maxRetries) {
+        const delay = getBackoffDelay(attempt, baseDelayMs, maxDelayMs);
+        options.onRetry?.(attempt + 1, lastError);
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError;
+}
+function extractMediaPaths(data) {
+  const paths = /* @__PURE__ */ new Set();
+  function walk(value) {
+    if (value === null || value === void 0) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        walk(item);
+      }
+      return;
+    }
+    if (typeof value === "object") {
+      const obj = value;
+      if (typeof obj.storagePath === "string" && obj.storagePath) {
+        paths.add(obj.storagePath);
+      }
+      for (const key of Object.keys(obj)) {
+        walk(obj[key]);
+      }
+    }
+  }
+  walk(data);
+  return paths;
+}
+function buildStorageUrl(supabaseUrl, relativePath, siteId, bucket = "media") {
+  const baseUrl = supabaseUrl.replace(/\/$/, "");
+  const fullPath = `sites/${siteId}/${relativePath}`;
+  return `${baseUrl}/storage/v1/object/public/${bucket}/${fullPath}`;
+}
+async function downloadMedia(url, options) {
+  try {
+    return await withRetry(
+      async () => {
+        const response = await fetch(url);
+        if (!response.ok) {
+          if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+            throw new DownloadError(`HTTP ${response.status}`, response.status, false);
+          }
+          throw new DownloadError(`HTTP ${response.status}`, response.status, true);
+        }
+        const contentType = response.headers.get("content-type") ?? "application/octet-stream";
+        const arrayBuffer = await response.arrayBuffer();
+        const data = Buffer.from(arrayBuffer);
+        return { data, contentType };
+      },
+      {
+        maxRetries: options?.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries,
+        onRetry: (attempt, error) => {
+          console.warn(`[media-sync] Retry ${attempt} for ${url}: ${error.message}`);
+        }
+      }
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[media-sync] Download failed after retries: ${url} - ${message}`);
+    return null;
+  }
+}
+var DownloadError = class extends Error {
+  constructor(message, status, retryable) {
+    super(message);
+    this.status = status;
+    this.retryable = retryable;
+    this.name = "DownloadError";
+  }
+};
+
 // src/cli/commands/pull.ts
 var DEFAULT_PAGE_LIMIT = 500;
 async function pullEntriesWithPagination(client, contentType, output) {
@@ -6596,21 +7152,105 @@ async function fetchAllContentPaginated(client, contentTypes, output) {
     meta: { pulledAt: (/* @__PURE__ */ new Date()).toISOString(), entries: allMeta }
   };
 }
-var pullCommand = new commander.Command("pull").description("Pull content from CMS").argument("[scope]", "What to pull: entries, pages, navigation, settings, or all (default)").argument("[type]", 'Content type (when scope is "entries")').option("--output <dir>", "Output directory", "./content").option("--force", "Overwrite existing files without prompting").option("--yes", "Skip confirmation prompt (same as --force)").addHelpText("after", `
+async function syncMediaFiles(content, sourceSupabaseUrl, sourceSiteId, targetSiteId, targetClient, output) {
+  const mediaPaths = extractMediaPaths(content);
+  if (mediaPaths.size === 0) {
+    output.info("No media files found in content");
+    return;
+  }
+  output.info(`Found ${mediaPaths.size} media files to sync`);
+  let synced = 0;
+  let skipped = 0;
+  let failed = 0;
+  for (const relativePath of mediaPaths) {
+    const filename = relativePath.split("/").pop() ?? "file";
+    const targetPath = `sites/${targetSiteId}/${relativePath}`;
+    try {
+      const exists = await targetClient.media.exists(targetPath);
+      if (exists) {
+        skipped++;
+        continue;
+      }
+    } catch (error) {
+      if (process.env.DEBUG) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.warn(`[media-sync] Could not check if ${filename} exists: ${message}`);
+      }
+    }
+    const url = buildStorageUrl(sourceSupabaseUrl, relativePath, sourceSiteId);
+    const downloaded = await downloadMedia(url);
+    if (!downloaded) {
+      output.warn(`  Failed to download: ${filename}`);
+      failed++;
+      continue;
+    }
+    try {
+      await targetClient.media.upload({
+        data: downloaded.data,
+        filename,
+        contentType: downloaded.contentType,
+        storagePath: targetPath
+      });
+      synced++;
+    } catch (error) {
+      output.warn(`  Failed to upload: ${filename}`);
+      failed++;
+    }
+  }
+  output.info(`Media sync: ${synced} synced, ${skipped} skipped (already exist), ${failed} failed`);
+}
+var pullCommand = new commander.Command("pull").description("Pull content from CMS").argument("[scope]", "What to pull: entries, pages, navigation, settings, or all (default)").argument("[type]", 'Content type (when scope is "entries")').option("--output <dir>", "Output directory", "./content").option("--force", "Overwrite existing files without prompting").option("--yes", "Skip confirmation prompt (same as --force)").option("--sync-media", "Sync media files from source to target environment").addHelpText("after", `
 Examples:
   $ riverbankcms pull                         # Pull all content
   $ riverbankcms pull --remote                # Pull from production
+  $ riverbankcms pull --remote --sync-media   # Pull from production and sync media to local
   $ riverbankcms pull entries                 # Pull all entries
   $ riverbankcms pull entries blog-post       # Pull specific content type
   $ riverbankcms pull pages                   # Pull pages with blocks
   $ riverbankcms pull navigation              # Pull navigation menus
   $ riverbankcms pull settings                # Pull site settings
   $ riverbankcms pull --output ./src/content  # Custom output directory
+
+Media Sync:
+  When using --sync-media, media files are:
+  1. Downloaded from the source environment's Supabase storage
+  2. Uploaded to the target environment via the management API
+
+  The storage URL is automatically fetched from the source CMS API.
+  No additional environment variables are required beyond the standard
+  RIVERBANK_*_DASHBOARD_URL, RIVERBANK_*_SITE_ID, and RIVERBANK_*_MGMT_API_KEY.
 `).action(
   withErrorHandling(
     async (scope, type, options, command) => {
-      const { output, client } = createCommandContext(command);
+      const { output, client, isRemote } = createCommandContext(command);
       const contentDir = path9__namespace.resolve(options.output ?? "./content");
+      let targetClient = null;
+      let sourceSupabaseUrl = null;
+      let sourceSiteId = null;
+      let targetSiteId = null;
+      if (options.syncMedia) {
+        const sourceEnv = loadEnvironment(isRemote);
+        const targetEnv = loadEnvironment(!isRemote);
+        output.info("Fetching storage configuration from source...");
+        try {
+          const siteInfo = await client.pull.siteInfo();
+          sourceSupabaseUrl = siteInfo.supabaseUrl;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Unknown error";
+          output.error(`Failed to get storage configuration from source: ${message}`, {
+            suggestion: "Ensure the source CMS is running and accessible"
+          });
+          return;
+        }
+        sourceSiteId = sourceEnv.siteId;
+        targetSiteId = targetEnv.siteId;
+        targetClient = createManagementClient({
+          dashboardUrl: targetEnv.dashboardUrl,
+          managementApiKey: targetEnv.managementApiKey,
+          siteId: targetEnv.siteId
+        });
+        output.info(`Media sync enabled: ${isRemote ? "remote" : "local"} -> ${isRemote ? "local" : "remote"}`);
+      }
       if (await contentDirExists(contentDir) && !options.force && !options.yes) {
         if (!process.stdin.isTTY) {
           output.error("Content directory already exists and --yes not specified", {
@@ -6693,6 +7333,17 @@ Examples:
             const contentTypes = Object.keys(result.entries);
             result = await fetchAllContentPaginated(client, contentTypes, output);
           }
+          if (targetClient && sourceSupabaseUrl && sourceSiteId && targetSiteId) {
+            output.info("Syncing media files...");
+            await syncMediaFiles(
+              result,
+              sourceSupabaseUrl,
+              sourceSiteId,
+              targetSiteId,
+              targetClient,
+              output
+            );
+          }
           const { totalCount: totalEntries } = await writeAllEntries(
             contentDir,
             result.entries,
@@ -6748,11 +7399,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;
@@ -7691,6 +8342,43 @@ Safety:
       output
     );
     reportSyncResults(output, result, result.errors.length > 0);
+    if (result.errors.length === 0) {
+      try {
+        output.info("Updating local metadata...");
+        const freshRemote = await client.pull.all();
+        const entriesForMeta = {};
+        if (freshRemote.meta.entries) {
+          for (const [key, meta] of Object.entries(freshRemote.meta.entries)) {
+            const [contentType, identifier] = key.split(":");
+            if (contentType && identifier) {
+              if (!entriesForMeta[contentType]) {
+                entriesForMeta[contentType] = [];
+              }
+              entriesForMeta[contentType].push({
+                identifier,
+                updatedAt: meta.updatedAt,
+                createdAt: meta.createdAt
+              });
+            }
+          }
+        }
+        await updateMetadataAfterPush(contentDir, {
+          entries: entriesForMeta,
+          pages: freshRemote.pages.map((p) => ({
+            identifier: p.identifier,
+            updatedAt: p.updatedAt,
+            createdAt: p.createdAt
+          })),
+          navigation: freshRemote.navigation.map((n) => ({
+            name: n.name,
+            updatedAt: n.updatedAt,
+            createdAt: n.createdAt
+          }))
+        });
+      } catch (metaError) {
+        output.warn('Push succeeded but metadata update failed. Run "pull" to sync metadata.');
+      }
+    }
   } catch (error) {
     handleCommandError(error, output);
   }
@@ -8505,7 +9193,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 +9380,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.1";
+
+// 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_CONFIG2 = {
+  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_CONFIG2.baseDelayMs;
+  const maxDelayMs = config3.maxDelayMs ?? DEFAULT_RETRY_CONFIG2.maxDelayMs;
+  const jitter = config3.jitter ?? DEFAULT_RETRY_CONFIG2.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_CONFIG2.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 sleep2(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 sleep2(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_CONFIG2.maxAttempts,
+    baseDelayMs: config3.resilience?.retry?.baseDelayMs ?? DEFAULT_RETRY_CONFIG2.baseDelayMs,
+    maxDelayMs: config3.resilience?.retry?.maxDelayMs ?? DEFAULT_RETRY_CONFIG2.maxDelayMs,
+    jitter: config3.resilience?.retry?.jitter ?? DEFAULT_RETRY_CONFIG2.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 +12818,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