@inneropen/marvin-sdk 2.0.1 → 3.0.1

package/dist/publish.cjs

@@ -0,0 +1,1355 @@
+"use strict";
+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;
+};
+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/client/config.ts
+var config_exports = {};
+__export(config_exports, {
+  createConfigFromEnv: () => createConfigFromEnv,
+  validateConfig: () => validateConfig
+});
+function validateConfig(config) {
+  const receivedKeys = Object.keys(config).join(", ");
+  if (!config.apiUrl) {
+    throw new Error(
+      `Missing required config: 'apiUrl'
+
+The API URL is the base URL of your Marvin server.
+
+Examples:
+  - Production: https://marvin.example.com
+  - Development: http://localhost:8080
+
+Solutions:
+  1. Set environment variable: MARVIN_API_URL=https://marvin.example.com
+  2. Pass directly: createMarvinClient({ apiUrl: 'https://marvin.example.com' })
+
+Received config keys: ${receivedKeys || "(none)"}`
+    );
+  }
+  if (!config.siteClientToken) {
+    throw new Error(
+      `Missing required config: 'siteClientToken'
+
+The site client token provides read-only access to published content.
+
+How to get it:
+  1. Log into Marvin admin panel
+  2. Navigate to: Settings \u2192 API Clients
+  3. Copy the token for your workspace
+
+Examples:
+  - site_client_abc123xyz
+  - sc_1234567890abcdef
+
+Solutions:
+  1. Set environment variable: MARVIN_SITE_CLIENT_TOKEN=site_client_abc123
+  2. Pass directly: createMarvinClient({ siteClientToken: 'site_client_abc123' })
+
+Received config keys: ${receivedKeys}`
+    );
+  }
+  if (!config.workspaceSlug) {
+    throw new Error(
+      `Missing required config: 'workspaceSlug'
+
+The workspace slug identifies which workspace to access.
+
+Examples:
+  - my-blog
+  - company-website
+  - acme-corp
+
+How to find it:
+  1. Check your workspace URL: https://marvin.example.com/workspace/[slug]
+  2. Or find it in: Settings \u2192 General \u2192 Workspace Slug
+
+Solutions:
+  1. Set environment variable: MARVIN_WORKSPACE_SLUG=my-blog
+  2. Pass directly: createMarvinClient({ workspaceSlug: 'my-blog' })
+
+Received config keys: ${receivedKeys}`
+    );
+  }
+  if (config.apiUrl) {
+    try {
+      new URL(config.apiUrl);
+    } catch {
+      throw new Error(
+        `Invalid 'apiUrl' format: "${config.apiUrl}"
+
+The API URL must be a valid HTTP or HTTPS URL.
+
+Valid examples:
+  \u2713 https://marvin.example.com
+  \u2713 http://localhost:8080
+  \u2713 https://api.marvin.io
+
+Invalid examples:
+  \u2717 marvin.example.com (missing protocol)
+  \u2717 ftp://marvin.example.com (wrong protocol)
+  \u2717 /api (not a full URL)`
+      );
+    }
+    const url = new URL(config.apiUrl);
+    if (!["http:", "https:"].includes(url.protocol)) {
+      throw new Error(
+        `Invalid 'apiUrl' protocol: "${url.protocol}"
+
+Only HTTP and HTTPS protocols are supported.
+
+Your URL: ${config.apiUrl}
+Change to: ${config.apiUrl.replace(url.protocol, "https:")}`
+      );
+    }
+  }
+}
+function getEnv(key) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[key];
+  }
+  return void 0;
+}
+function createConfigFromEnv(overrides) {
+  return {
+    apiUrl: overrides?.apiUrl || getEnv("MARVIN_API_URL") || "",
+    siteClientToken: overrides?.siteClientToken || getEnv("MARVIN_SITE_CLIENT_TOKEN") || "",
+    workspaceSlug: overrides?.workspaceSlug || getEnv("MARVIN_WORKSPACE_SLUG") || "",
+    autoInitialize: overrides?.autoInitialize ?? false,
+    cacheDuration: overrides?.cacheDuration ?? 5 * 60 * 1e3,
+    // 5 minutes
+    debug: overrides?.debug ?? getEnv("MARVIN_DEBUG") === "true",
+    logger: overrides?.logger ?? console
+  };
+}
+var init_config = __esm({
+  "src/client/config.ts"() {
+    "use strict";
+  }
+});
+
+// src/publish.ts
+var publish_exports = {};
+__export(publish_exports, {
+  BearerTokenAuth: () => BearerTokenAuth,
+  Collection: () => Collection,
+  Entry: () => Entry,
+  HttpClient: () => HttpClient,
+  MarvinApiError: () => MarvinApiError,
+  MarvinAuthError: () => MarvinAuthError,
+  MarvinCache: () => MarvinCache,
+  MarvinClient: () => MarvinClient,
+  MarvinConfigError: () => MarvinConfigError,
+  MarvinError: () => MarvinError,
+  MarvinNetworkError: () => MarvinNetworkError,
+  MarvinNotFoundError: () => MarvinNotFoundError,
+  MarvinServerError: () => MarvinServerError,
+  MarvinValidationError: () => MarvinValidationError,
+  Resource: () => Resource,
+  Workspace: () => Workspace,
+  createConfigFromEnv: () => createConfigFromEnv,
+  createMarvinClient: () => createMarvinClient,
+  createPaginatedResponse: () => createPaginatedResponse,
+  extractData: () => extractData,
+  isPaginatedResponse: () => isPaginatedResponse,
+  offsetToPage: () => offsetToPage,
+  pageToOffset: () => pageToOffset
+});
+module.exports = __toCommonJS(publish_exports);
+
+// src/client/marvin.ts
+init_config();
+
+// src/core/errors/MarvinError.ts
+var MarvinError = class _MarvinError extends Error {
+  constructor(message, code, statusCode) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "MarvinError";
+    Object.setPrototypeOf(this, _MarvinError.prototype);
+  }
+  code;
+  statusCode;
+};
+var MarvinApiError = class _MarvinApiError extends MarvinError {
+  constructor(message, statusCode, endpoint, responseBody) {
+    super(message, "API_ERROR", statusCode);
+    this.statusCode = statusCode;
+    this.endpoint = endpoint;
+    this.responseBody = responseBody;
+    this.name = "MarvinApiError";
+    Object.setPrototypeOf(this, _MarvinApiError.prototype);
+  }
+  statusCode;
+  endpoint;
+  responseBody;
+  static fromResponse(status, statusText, endpoint, body) {
+    const message = `Marvin API error: ${status} ${statusText} at ${endpoint}${body ? `
+${body}` : ""}`;
+    return new _MarvinApiError(message, status, endpoint, body);
+  }
+};
+var MarvinAuthError = class _MarvinAuthError extends MarvinError {
+  constructor(message, statusCode) {
+    super(message, "AUTH_ERROR", statusCode);
+    this.name = "MarvinAuthError";
+    Object.setPrototypeOf(this, _MarvinAuthError.prototype);
+  }
+};
+var MarvinConfigError = class _MarvinConfigError extends MarvinError {
+  constructor(message) {
+    super(message, "CONFIG_ERROR");
+    this.name = "MarvinConfigError";
+    Object.setPrototypeOf(this, _MarvinConfigError.prototype);
+  }
+};
+var MarvinValidationError = class _MarvinValidationError extends MarvinError {
+  constructor(message, field) {
+    super(message, "VALIDATION_ERROR");
+    this.field = field;
+    this.name = "MarvinValidationError";
+    Object.setPrototypeOf(this, _MarvinValidationError.prototype);
+  }
+  field;
+};
+var MarvinNotFoundError = class _MarvinNotFoundError extends MarvinError {
+  constructor(message, endpoint) {
+    super(message, "NOT_FOUND", 404);
+    this.endpoint = endpoint;
+    this.name = "MarvinNotFoundError";
+    Object.setPrototypeOf(this, _MarvinNotFoundError.prototype);
+  }
+  endpoint;
+};
+var MarvinNetworkError = class _MarvinNetworkError extends MarvinError {
+  constructor(message, originalError) {
+    super(message, "NETWORK_ERROR");
+    this.originalError = originalError;
+    this.name = "MarvinNetworkError";
+    Object.setPrototypeOf(this, _MarvinNetworkError.prototype);
+  }
+  originalError;
+};
+var MarvinServerError = class _MarvinServerError extends MarvinError {
+  constructor(message, statusCode, endpoint) {
+    super(message, "SERVER_ERROR", statusCode);
+    this.endpoint = endpoint;
+    this.name = "MarvinServerError";
+    Object.setPrototypeOf(this, _MarvinServerError.prototype);
+  }
+  endpoint;
+};
+
+// src/core/http/HttpClient.ts
+var HttpClient = class {
+  baseUrl;
+  auth;
+  defaultHeaders;
+  credentials;
+  timeout;
+  debug;
+  retryConfig;
+  logger;
+  constructor(config) {
+    this.baseUrl = config.baseUrl;
+    this.auth = config.auth;
+    this.defaultHeaders = config.defaultHeaders || {};
+    this.credentials = config.credentials || "same-origin";
+    const MAX_TIMEOUT = 12e4;
+    this.timeout = Math.min(config.timeout || 3e4, MAX_TIMEOUT);
+    this.debug = config.debug ?? false;
+    this.logger = config.logger ?? console;
+    this.retryConfig = {
+      maxRetries: config.retry?.maxRetries ?? 3,
+      initialDelay: config.retry?.initialDelay ?? 1e3,
+      maxDelay: config.retry?.maxDelay ?? 1e4,
+      retryableStatuses: config.retry?.retryableStatuses ?? [408, 429, 500, 502, 503, 504]
+    };
+  }
+  /**
+   * Validate path parameter to prevent path traversal attacks
+   */
+  validatePathParam(param, paramName = "parameter") {
+    if (typeof param === "number") {
+      return String(param);
+    }
+    if (!param || typeof param !== "string") {
+      throw new MarvinValidationError(`Invalid ${paramName}: must be a non-empty string or number`);
+    }
+    if (param.includes("..") || param.includes("/") || param.includes("\\")) {
+      throw new MarvinValidationError(
+        `Invalid ${paramName}: cannot contain path traversal characters (.. / \\)`
+      );
+    }
+    if (param.includes("\0")) {
+      throw new MarvinValidationError(`Invalid ${paramName}: cannot contain null bytes`);
+    }
+    if (param.length > 255) {
+      throw new MarvinValidationError(`Invalid ${paramName}: exceeds maximum length of 255 characters`);
+    }
+    return param;
+  }
+  /**
+   * Build full URL from endpoint
+   */
+  buildUrl(endpoint) {
+    const base = this.baseUrl.replace(/\/$/, "");
+    const path = endpoint.replace(/^\//, "");
+    return `${base}/${path}`;
+  }
+  /**
+   * Build headers for request
+   */
+  buildHeaders(additionalHeaders, isFormData = false) {
+    const headerInit = {};
+    if (!isFormData) {
+      headerInit["Content-Type"] = "application/json";
+    }
+    const headers = new Headers({
+      ...headerInit,
+      ...this.defaultHeaders,
+      ...additionalHeaders
+    });
+    this.auth.injectAuth(headers);
+    return headers;
+  }
+  /**
+   * Build query string from params
+   */
+  buildQueryString(params) {
+    const filtered = Object.entries(params).filter(([_, value]) => value !== void 0).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    return filtered.length > 0 ? `?${filtered.join("&")}` : "";
+  }
+  /**
+   * Sanitize data for logging by redacting sensitive fields
+   */
+  sanitizeForLogging(data) {
+    if (!data || typeof data !== "object") {
+      return data;
+    }
+    const sensitiveFields = [
+      "token",
+      "access_token",
+      "refresh_token",
+      "password",
+      "secret",
+      "apiKey",
+      "api_key",
+      "bearer",
+      "authorization",
+      "csrf_token",
+      "session",
+      "cookie"
+    ];
+    const sanitize = (obj) => {
+      const sanitized = {};
+      for (const [key, value] of Object.entries(obj)) {
+        const keyLower = key.toLowerCase();
+        const isSensitive = sensitiveFields.some((field) => keyLower.includes(field));
+        if (isSensitive) {
+          sanitized[key] = "[REDACTED]";
+        } else if (value && typeof value === "object" && !Array.isArray(value)) {
+          sanitized[key] = sanitize(value);
+        } else if (Array.isArray(value)) {
+          sanitized[key] = value.map(
+            (item) => item && typeof item === "object" ? sanitize(item) : item
+          );
+        } else {
+          sanitized[key] = value;
+        }
+      }
+      return sanitized;
+    };
+    if (Array.isArray(data)) {
+      return data.map(
+        (item) => item && typeof item === "object" ? sanitize(item) : item
+      );
+    }
+    return sanitize(data);
+  }
+  /**
+   * Calculate delay for retry with exponential backoff
+   */
+  calculateRetryDelay(attempt) {
+    const delay = this.retryConfig.initialDelay * Math.pow(2, attempt);
+    return Math.min(delay, this.retryConfig.maxDelay);
+  }
+  /**
+   * Sleep for specified milliseconds
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Perform HTTP request with automatic retry on transient failures
+   */
+  async request(method, endpoint, options, retryAttempt = 0) {
+    const url = this.buildUrl(endpoint) + (options?.params ? this.buildQueryString(options.params) : "");
+    const isFormData = options?.body instanceof FormData;
+    const headers = this.buildHeaders(options?.headers, isFormData);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    const startTime = Date.now();
+    if (this.debug) {
+      this.logger.log(`[Marvin] ${method} ${url}`);
+    }
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: isFormData ? options.body : options?.body ? JSON.stringify(options.body) : void 0,
+        credentials: this.credentials,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const duration = Date.now() - startTime;
+      if (this.debug) {
+        this.logger.log(
+          `[Marvin] ${response.status} ${response.statusText} (${duration}ms)`
+        );
+      }
+      if (response.status === 401 && this.auth.handleUnauthorized) {
+        await this.auth.handleUnauthorized();
+      }
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "");
+        if (this.debug) {
+          this.logger.error(
+            `[Marvin] Error response: ${response.status} ${response.statusText}`,
+            errorText ? `Body: ${errorText}` : ""
+          );
+        }
+        const isRetryable = this.retryConfig.retryableStatuses.includes(response.status);
+        const canRetry = retryAttempt < this.retryConfig.maxRetries;
+        if (isRetryable && canRetry) {
+          const delay = this.calculateRetryDelay(retryAttempt);
+          if (this.debug) {
+            this.logger.warn(
+              `[Marvin] Retry ${retryAttempt + 1}/${this.retryConfig.maxRetries} after ${delay}ms (status: ${response.status})`
+            );
+          }
+          await this.sleep(delay);
+          return this.request(method, endpoint, options, retryAttempt + 1);
+        }
+        if (response.status === 404) {
+          throw new MarvinNotFoundError(
+            `Resource not found: ${endpoint}`,
+            endpoint
+          );
+        }
+        if (response.status === 401 || response.status === 403) {
+          throw new MarvinAuthError(
+            `Authentication failed: ${response.statusText}`,
+            response.status
+          );
+        }
+        if (response.status >= 500) {
+          throw new MarvinServerError(
+            `Server error: ${response.status} ${response.statusText}`,
+            response.status,
+            endpoint
+          );
+        }
+        throw MarvinApiError.fromResponse(
+          response.status,
+          response.statusText,
+          endpoint,
+          errorText
+        );
+      }
+      const contentType = response.headers.get("content-type");
+      if (!contentType || !contentType.includes("application/json")) {
+        return void 0;
+      }
+      const data = await response.json();
+      if (this.debug) {
+        const sanitized = this.sanitizeForLogging(data);
+        this.logger.log("[Marvin] Response:", JSON.stringify(sanitized, null, 2));
+      }
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof MarvinApiError || error instanceof MarvinNotFoundError || error instanceof MarvinAuthError || error instanceof MarvinServerError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        const canRetry = retryAttempt < this.retryConfig.maxRetries;
+        if (canRetry && error.name !== "AbortError") {
+          const delay = this.calculateRetryDelay(retryAttempt);
+          if (this.debug) {
+            this.logger.warn(
+              `[Marvin] Retry ${retryAttempt + 1}/${this.retryConfig.maxRetries} after ${delay}ms (network error)`
+            );
+          }
+          await this.sleep(delay);
+          return this.request(method, endpoint, options, retryAttempt + 1);
+        }
+        if (error.name === "AbortError") {
+          throw new MarvinNetworkError(
+            `Request timeout after ${this.timeout}ms`,
+            error
+          );
+        }
+        throw new MarvinNetworkError(
+          `Network error: ${error.message}`,
+          error
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * GET request
+   */
+  async get(endpoint, params) {
+    return this.request("GET", endpoint, { params });
+  }
+  /**
+   * POST request
+   */
+  async post(endpoint, body) {
+    return this.request("POST", endpoint, { body });
+  }
+  /**
+   * PUT request
+   */
+  async put(endpoint, body) {
+    return this.request("PUT", endpoint, { body });
+  }
+  /**
+   * PATCH request
+   */
+  async patch(endpoint, body) {
+    return this.request("PATCH", endpoint, { body });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(endpoint) {
+    return this.request("DELETE", endpoint);
+  }
+};
+
+// src/core/auth/AuthStrategy.ts
+var BearerTokenAuth = class {
+  constructor(token) {
+    this.token = token;
+  }
+  token;
+  injectAuth(headers) {
+    headers.set("Authorization", `Bearer ${this.token}`);
+  }
+  getDescription() {
+    return "Bearer token authentication";
+  }
+};
+
+// src/core/pagination/PaginatedResponse.ts
+function createPaginatedResponse(data, meta) {
+  return { data, meta };
+}
+function extractData(response) {
+  if (Array.isArray(response)) {
+    return response;
+  }
+  return response.data;
+}
+function isPaginatedResponse(response) {
+  return !Array.isArray(response) && "data" in response;
+}
+function pageToOffset(page, limit) {
+  return (page - 1) * limit;
+}
+function offsetToPage(offset, limit) {
+  return Math.floor(offset / limit) + 1;
+}
+
+// src/core/cache.ts
+var MarvinCache = class {
+  constructor(duration = 5 * 60 * 1e3, maxEntries = 1e3) {
+    this.duration = duration;
+    this.maxEntries = maxEntries;
+  }
+  duration;
+  maxEntries;
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Get cached data by key
+   * Returns undefined if not found or expired
+   */
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return void 0;
+    const age = Date.now() - entry.timestamp;
+    if (age > this.duration) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    return entry.data;
+  }
+  /**
+   * Set cached data with optional tags for invalidation
+   */
+  set(key, data, tags) {
+    if (this.cache.size >= this.maxEntries) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+      }
+    }
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now(),
+      tags
+    });
+  }
+  /**
+   * Check if key exists and is not expired
+   */
+  has(key) {
+    return this.get(key) !== void 0;
+  }
+  /**
+   * Clear all cached entries
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Delete a specific cache entry
+   */
+  delete(key) {
+    this.cache.delete(key);
+  }
+  /**
+   * Invalidate all cache entries with a specific tag
+   * Useful for invalidating related data after mutations
+   *
+   * @example
+   * ```typescript
+   * // Cache entries with tags
+   * cache.set('entry:1', data, ['entries', 'entry:1']);
+   * cache.set('entries:list', data, ['entries']);
+   *
+   * // Invalidate all entries
+   * cache.invalidateByTag('entries');
+   * ```
+   */
+  invalidateByTag(tag) {
+    let count = 0;
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.tags?.includes(tag)) {
+        this.cache.delete(key);
+        count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    let oldest = null;
+    let newest = null;
+    for (const entry of this.cache.values()) {
+      if (oldest === null || entry.timestamp < oldest) {
+        oldest = entry.timestamp;
+      }
+      if (newest === null || entry.timestamp > newest) {
+        newest = entry.timestamp;
+      }
+    }
+    return {
+      size: this.cache.size,
+      maxEntries: this.maxEntries,
+      oldestEntry: oldest,
+      newestEntry: newest
+    };
+  }
+  /**
+   * Remove expired entries (garbage collection)
+   * Returns number of entries removed
+   */
+  prune() {
+    let count = 0;
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      const age = now - entry.timestamp;
+      if (age > this.duration) {
+        this.cache.delete(key);
+        count++;
+      }
+    }
+    return count;
+  }
+};
+
+// src/client/http.ts
+var MarvinHttpClient = class extends HttpClient {
+  constructor(config) {
+    super({
+      baseUrl: config.apiUrl,
+      auth: new BearerTokenAuth(config.siteClientToken),
+      credentials: "same-origin",
+      debug: config.debug,
+      logger: config.logger
+    });
+  }
+  /**
+   * Fetch endpoint (backward compatibility)
+   */
+  async fetch(endpoint) {
+    return this.get(endpoint);
+  }
+};
+
+// src/entries/entry.ts
+var Entry = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  raw;
+  get title() {
+    return this.raw.title;
+  }
+  get slug() {
+    return this.raw.slug;
+  }
+  get summary() {
+    return this.raw.summary;
+  }
+  get entryType() {
+    return this.raw.entryType;
+  }
+  get entryTypeInfo() {
+    return this.raw.entryTypeInfo;
+  }
+  get data() {
+    return this.raw.data;
+  }
+  get metadataJson() {
+    return this.raw.metadataJson;
+  }
+  get publishedAt() {
+    return this.raw.publishedAt;
+  }
+  get order() {
+    return this.raw.order;
+  }
+  get assets() {
+    return this.raw.assets;
+  }
+  get collections() {
+    return this.raw.collections;
+  }
+  get resources() {
+    return this.raw.resources;
+  }
+  field(key) {
+    return this.raw.data[key];
+  }
+  get fields() {
+    return this.raw.data;
+  }
+  toJSON() {
+    return this.raw;
+  }
+};
+
+// src/entries/entries.ts
+var EntriesModule = class {
+  constructor(http, workspaceSlug) {
+    this.http = http;
+    this.workspaceSlug = workspaceSlug;
+  }
+  http;
+  workspaceSlug;
+  /**
+   * Get all published entries
+   */
+  async list(options = {}) {
+    const queryString = this.http.buildQueryString({
+      entry_type: options.entryType,
+      collection: options.collection,
+      limit: options.limit,
+      offset: options.offset
+    });
+    const endpoint = `/api/publish/${this.workspaceSlug}/entries${queryString}`;
+    const response = await this.http.fetch(endpoint);
+    return response.data || [];
+  }
+  /**
+   * Get a single entry by slug
+   * Returns null if entry is not found (404)
+   */
+  async get(slug) {
+    try {
+      const endpoint = `/api/publish/${this.workspaceSlug}/entries/${slug}`;
+      const data = await this.http.fetch(endpoint);
+      return new Entry(data);
+    } catch (error) {
+      if (error instanceof MarvinNotFoundError) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Convenience: Get all pages
+   */
+  async pages(options) {
+    return this.list({ ...options, entryType: "page" });
+  }
+  /**
+   * Convenience: Get all blog posts
+   */
+  async posts(options) {
+    return this.list({ ...options, entryType: "blog" });
+  }
+  /**
+   * Convenience: Get all projects
+   */
+  async projects(options) {
+    return this.list({ ...options, entryType: "project" });
+  }
+};
+
+// src/collections/collection.ts
+var Collection = class {
+  constructor(data) {
+    this.data = data;
+  }
+  data;
+  get name() {
+    return this.data.name;
+  }
+  get slug() {
+    return this.data.slug;
+  }
+  get description() {
+    return this.data.description;
+  }
+  get isSmart() {
+    return this.data.isSmart;
+  }
+  get smartRules() {
+    return this.data.smartRules;
+  }
+  get metadataJson() {
+    return this.data.metadataJson;
+  }
+  get entryCount() {
+    return this.data.entryCount;
+  }
+  get entries() {
+    return this.data.entries;
+  }
+  toJSON() {
+    return this.data;
+  }
+};
+
+// src/collections/collections.ts
+var CollectionsModule = class {
+  constructor(http, workspaceSlug) {
+    this.http = http;
+    this.workspaceSlug = workspaceSlug;
+  }
+  http;
+  workspaceSlug;
+  /**
+   * Get all collections
+   */
+  async list() {
+    const endpoint = `/api/publish/${this.workspaceSlug}/collections`;
+    const response = await this.http.fetch(endpoint);
+    return response.data || [];
+  }
+  /**
+   * Get a single collection by slug
+   * Returns null if collection is not found (404)
+   */
+  async get(slug) {
+    try {
+      const endpoint = `/api/publish/${this.workspaceSlug}/collections/${slug}`;
+      const data = await this.http.fetch(endpoint);
+      return new Collection(data);
+    } catch (error) {
+      if (error instanceof MarvinNotFoundError) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get entries in a collection
+   * Returns empty array if collection is not found
+   */
+  async entries(slug) {
+    const collection = await this.get(slug);
+    if (!collection) {
+      return [];
+    }
+    return collection.entries;
+  }
+  /**
+   * Try multiple collection slugs in fallback order
+   * Returns the first collection that exists and has entries
+   */
+  async fallback(slugs, options = {}) {
+    const { requireEntries = true } = options;
+    for (const slug of slugs) {
+      try {
+        const collection = await this.get(slug);
+        if (!collection) {
+          continue;
+        }
+        const entries = collection.entries;
+        if (!requireEntries || entries.length > 0) {
+          return entries;
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+    return [];
+  }
+};
+
+// src/assets/assets.ts
+var AssetsModule = class {
+  constructor(http, workspaceSlug) {
+    this.http = http;
+    this.workspaceSlug = workspaceSlug;
+  }
+  http;
+  workspaceSlug;
+  /**
+   * Get all published assets
+   */
+  async list(options = {}) {
+    const queryString = this.http.buildQueryString({
+      type: options.type,
+      limit: options.limit,
+      offset: options.offset
+    });
+    const endpoint = `/api/publish/${this.workspaceSlug}/assets${queryString}`;
+    const response = await this.http.fetch(endpoint);
+    return response.data || [];
+  }
+  /**
+   * Get a single published asset by slug or ID
+   */
+  async get(slugOrId) {
+    const endpoint = `/api/publish/${this.workspaceSlug}/assets/${slugOrId}`;
+    return this.http.fetch(endpoint);
+  }
+  /**
+   * Convenience: Get all images
+   */
+  async images(options) {
+    return this.list({ ...options, type: "image" });
+  }
+  /**
+   * Convenience: Get all videos
+   */
+  async videos(options) {
+    return this.list({ ...options, type: "video" });
+  }
+  /**
+   * Convenience: Get all documents
+   */
+  async documents(options) {
+    return this.list({ ...options, type: "document" });
+  }
+};
+
+// src/resources/resource.ts
+var Resource = class {
+  constructor(data) {
+    this.data = data;
+  }
+  data;
+  get name() {
+    return this.data.name;
+  }
+  get slug() {
+    return this.data.slug;
+  }
+  get resourceType() {
+    return this.data.resourceType;
+  }
+  get description() {
+    return this.data.description;
+  }
+  get externalId() {
+    return this.data.externalId;
+  }
+  get url() {
+    return this.data.url;
+  }
+  get metadataJson() {
+    return this.data.metadataJson;
+  }
+  get entries() {
+    return this.data.entries;
+  }
+  toJSON() {
+    return this.data;
+  }
+};
+
+// src/resources/resources.ts
+var ResourcesModule = class {
+  constructor(http, workspaceSlug) {
+    this.http = http;
+    this.workspaceSlug = workspaceSlug;
+  }
+  http;
+  workspaceSlug;
+  /**
+   * Get all published resources
+   */
+  async list(options = {}) {
+    const queryString = this.http.buildQueryString({
+      resource_type: options.resourceType,
+      limit: options.limit,
+      offset: options.offset
+    });
+    const endpoint = `/api/publish/${this.workspaceSlug}/resources${queryString}`;
+    const response = await this.http.fetch(endpoint);
+    return response.data || [];
+  }
+  /**
+   * Get a single resource by slug
+   */
+  async get(slug) {
+    const endpoint = `/api/publish/${this.workspaceSlug}/resources/${slug}`;
+    const data = await this.http.fetch(endpoint);
+    return new Resource(data);
+  }
+  /**
+   * Get entry slugs that reference this resource
+   */
+  async entries(slug) {
+    const resource = await this.get(slug);
+    return resource.entries;
+  }
+};
+
+// src/renderers/renderers.ts
+var RenderersModule = class {
+  constructor(http, workspaceSlug) {
+    this.http = http;
+    this.workspaceSlug = workspaceSlug;
+  }
+  http;
+  workspaceSlug;
+  async list() {
+    const endpoint = `/api/publish/${this.workspaceSlug}/entry-types`;
+    return this.http.fetch(endpoint);
+  }
+};
+
+// src/workspaces/workspace.ts
+var Workspace = class {
+  constructor(http, slug) {
+    this.http = http;
+    this._slug = slug;
+    this.entries = new EntriesModule(http, slug);
+    this.collections = new CollectionsModule(http, slug);
+    this.assets = new AssetsModule(http, slug);
+    this.resources = new ResourcesModule(http, slug);
+    this.renderers = new RenderersModule(http, slug);
+  }
+  http;
+  _site = null;
+  _slug;
+  entries;
+  collections;
+  assets;
+  resources;
+  renderers;
+  /**
+   * Get workspace slug
+   */
+  get slug() {
+    return this._slug;
+  }
+  /**
+   * Get site configuration (cached after first load)
+   */
+  get site() {
+    return this._site;
+  }
+  /**
+   * Load site configuration
+   */
+  async loadSite() {
+    const endpoint = `/api/publish/${this._slug}/site`;
+    this._site = await this.http.fetch(endpoint);
+    return this._site;
+  }
+  /**
+   * Get workspace info (name and slug only)
+   */
+  async getInfo() {
+    const endpoint = `/api/publish/${this._slug}`;
+    return this.http.fetch(endpoint);
+  }
+};
+
+// src/client/marvin.ts
+var MarvinClient = class {
+  http;
+  cache;
+  workspace;
+  initialized = false;
+  constructor(config) {
+    validateConfig(config);
+    this.http = new MarvinHttpClient(config);
+    this.cache = new MarvinCache(config.cacheDuration);
+    this.workspace = new Workspace(this.http, config.workspaceSlug);
+    if (config.autoInitialize) {
+      this.initialize();
+    }
+  }
+  /**
+   * Initialize the SDK
+   * Preloads site configuration and metadata
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      await this.workspace.loadSite();
+      this.initialized = true;
+    } catch (error) {
+      console.warn("Marvin SDK initialization warning:", error);
+    }
+  }
+  // ======================
+  // Workspace-First API
+  // ======================
+  /**
+   * Get the workspace object
+   */
+  async getWorkspace() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    return this.workspace;
+  }
+  /**
+   * Get site configuration (cached)
+   */
+  get site() {
+    return this.workspace.site;
+  }
+  /**
+   * Get workspace info (name and slug)
+   */
+  async getWorkspaceInfo() {
+    return this.workspace.getInfo();
+  }
+  /**
+   * Get entries module
+   */
+  get entries() {
+    return this.workspace.entries;
+  }
+  /**
+   * Get collections module
+   */
+  get collections() {
+    return this.workspace.collections;
+  }
+  /**
+   * Get assets module
+   */
+  get assets() {
+    return this.workspace.assets;
+  }
+  /**
+   * Get resources module
+   */
+  get resources() {
+    return this.workspace.resources;
+  }
+  /**
+   * Get renderers module
+   */
+  get renderers() {
+    return this.workspace.renderers;
+  }
+  // ======================
+  // Convenience Methods
+  // ======================
+  /**
+   * Get a single entry by slug
+   */
+  async entry(slug) {
+    return this.workspace.entries.get(slug);
+  }
+  /**
+   * Get a single collection by slug
+   */
+  async collection(slug) {
+    return this.workspace.collections.get(slug);
+  }
+  /**
+   * Get all pages
+   */
+  async pages(options) {
+    return this.workspace.entries.pages(options);
+  }
+  /**
+   * Get all blog posts
+   */
+  async posts(options) {
+    return this.workspace.entries.posts(options);
+  }
+  /**
+   * Get all projects
+   */
+  async projects(options) {
+    return this.workspace.entries.projects(options);
+  }
+  /**
+   * Get a single resource by slug
+   */
+  async resource(slug) {
+    return this.workspace.resources.get(slug);
+  }
+  /**
+   * Try multiple collection slugs in fallback order
+   * Returns entries from the first collection that exists and has content
+   */
+  async collectionFallback(slugs, options) {
+    return this.workspace.collections.fallback(slugs, options);
+  }
+  // ======================
+  // Backwards-Compatible Publishing API
+  // ======================
+  /**
+   * @deprecated Use workspace.site or marvin.site instead
+   */
+  async getSite() {
+    return this.workspace.loadSite();
+  }
+  /**
+   * @deprecated Use workspace.entries.list() instead
+   */
+  async getEntries(options) {
+    return this.workspace.entries.list(options);
+  }
+  /**
+   * @deprecated Use workspace.entries.get() instead
+   */
+  async getEntry(slug) {
+    const entry = await this.workspace.entries.get(slug);
+    if (!entry) {
+      return null;
+    }
+    return entry.toJSON();
+  }
+  /**
+   * @deprecated Use workspace.collections.list() instead
+   */
+  async getCollections() {
+    return this.workspace.collections.list();
+  }
+  /**
+   * @deprecated Use workspace.collections.get() instead
+   */
+  async getCollection(slug) {
+    const collection = await this.workspace.collections.get(slug);
+    if (!collection) {
+      return null;
+    }
+    return collection.toJSON();
+  }
+  /**
+   * @deprecated Use workspace.collections.entries() instead
+   */
+  async getCollectionEntries(slug) {
+    return this.workspace.collections.entries(slug);
+  }
+  /**
+   * @deprecated Use workspace.assets.list() instead
+   */
+  async getAssets(options) {
+    return this.workspace.assets.list(options);
+  }
+  /**
+   * @deprecated Use workspace.resources.list() instead
+   */
+  async getResources(options) {
+    return this.workspace.resources.list(options);
+  }
+  /**
+   * @deprecated Use workspace.resources.get() instead
+   */
+  async getResource(slug) {
+    const resource = await this.workspace.resources.get(slug);
+    return resource.toJSON();
+  }
+  /**
+   * @deprecated Use workspace.resources.entries() instead
+   */
+  async getResourceEntries(slug) {
+    return this.workspace.resources.entries(slug);
+  }
+};
+
+// src/publish.ts
+init_config();
+function createMarvinClient(config) {
+  const { createConfigFromEnv: createConfigFromEnv2 } = (init_config(), __toCommonJS(config_exports));
+  const finalConfig = createConfigFromEnv2(config);
+  return new MarvinClient(finalConfig);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BearerTokenAuth,
+  Collection,
+  Entry,
+  HttpClient,
+  MarvinApiError,
+  MarvinAuthError,
+  MarvinCache,
+  MarvinClient,
+  MarvinConfigError,
+  MarvinError,
+  MarvinNetworkError,
+  MarvinNotFoundError,
+  MarvinServerError,
+  MarvinValidationError,
+  Resource,
+  Workspace,
+  createConfigFromEnv,
+  createMarvinClient,
+  createPaginatedResponse,
+  extractData,
+  isPaginatedResponse,
+  offsetToPage,
+  pageToOffset
+});