@inneropen/marvin-sdk 2.0.0-next.18 → 2.0.0-next.2

package/dist/publish.cjs

@@ -1,1487 +0,0 @@
-"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 createConfigFromEnv(overrides) {
-  return {
-    apiUrl: overrides?.apiUrl || process.env.MARVIN_API_URL || "",
-    siteClientToken: overrides?.siteClientToken || process.env.MARVIN_SITE_CLIENT_TOKEN || "",
-    workspaceSlug: overrides?.workspaceSlug || process.env.MARVIN_WORKSPACE_SLUG || "",
-    autoInitialize: overrides?.autoInitialize ?? false,
-    cacheDuration: overrides?.cacheDuration ?? 5 * 60 * 1e3,
-    // 5 minutes
-    debug: overrides?.debug ?? process.env.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(data, http, workspaceSlug) {
-    this.data = data;
-    this.http = http;
-    this.workspaceSlug = workspaceSlug;
-  }
-  data;
-  http;
-  workspaceSlug;
-  // Expose all entry data as properties
-  get id() {
-    return this.data.id;
-  }
-  get title() {
-    return this.data.title;
-  }
-  get slug() {
-    return this.data.slug;
-  }
-  get summary() {
-    return this.data.summary;
-  }
-  get description() {
-    return this.data.description;
-  }
-  /**
-   * @deprecated Use field('body') or dataJson instead. Will be removed in v3.0.0
-   */
-  get contentMarkdown() {
-    return this.data.contentMarkdown;
-  }
-  /**
-   * Schema-driven content data (replaces contentMarkdown in v2.0.0).
-   * Access specific fields using the field() helper method.
-   * @since 2.0.0
-   */
-  get dataJson() {
-    return this.data.dataJson;
-  }
-  get metadata() {
-    return this.data.metadata;
-  }
-  get status() {
-    return this.data.status;
-  }
-  get publishedAt() {
-    return this.data.publishedAt;
-  }
-  get createdAt() {
-    return this.data.createdAt;
-  }
-  get updatedAt() {
-    return this.data.updatedAt;
-  }
-  get entryTypeId() {
-    return this.data.entryTypeId;
-  }
-  get entryType() {
-    return this.data.entryType;
-  }
-  /**
-   * Get entry assets
-   */
-  get assets() {
-    return this.data.assets || [];
-  }
-  /**
-   * Get entry collections
-   */
-  get collections() {
-    return this.data.collections || [];
-  }
-  /**
-   * Get a specific field value from the entry's schema-driven content (dataJson).
-   *
-   * @param key - Field key as defined in the entry type's schema
-   * @returns The field value, or undefined if not present
-   * @since 2.0.0
-   *
-   * @example
-   * ```typescript
-   * const entry = await client.entries.get('my-entry');
-   * const body = entry.field('body');           // Get markdown body
-   * const difficulty = entry.field('difficulty'); // Get difficulty level
-   * const heroImage = entry.field('heroImage');  // Get hero image UUID
-   * ```
-   */
-  field(key) {
-    return this.data.dataJson?.[key];
-  }
-  /**
-   * Get all fields from the entry's schema-driven content.
-   * @since 2.0.0
-   */
-  get fields() {
-    return this.data.dataJson || {};
-  }
-  /**
-   * Get related entries (future)
-   */
-  async relatedEntries() {
-    throw new Error("Related entries not yet implemented");
-  }
-  /**
-   * Get raw entry data
-   */
-  toJSON() {
-    return this.data;
-  }
-};
-
-// 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
-      // Don't send status - backend always returns published
-    });
-    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, this.http, this.workspaceSlug);
-    } 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, http, workspaceSlug) {
-    this.data = data;
-    this.http = http;
-    this.workspaceSlug = workspaceSlug;
-  }
-  data;
-  http;
-  workspaceSlug;
-  // Expose all collection data as properties
-  get id() {
-    return this.data.id;
-  }
-  get name() {
-    return this.data.name;
-  }
-  get slug() {
-    return this.data.slug;
-  }
-  get description() {
-    return this.data.description;
-  }
-  get icon() {
-    return this.data.icon;
-  }
-  get color() {
-    return this.data.color;
-  }
-  get sortOrder() {
-    return this.data.sortOrder;
-  }
-  get isSmart() {
-    return this.data.isSmart;
-  }
-  get smartRules() {
-    return this.data.smartRules;
-  }
-  get createdAt() {
-    return this.data.createdAt;
-  }
-  get updatedAt() {
-    return this.data.updatedAt;
-  }
-  /**
-   * Get all entries in this collection
-   */
-  async entries() {
-    return this.data.entries || [];
-  }
-  /**
-   * Get assets in this collection (future)
-   */
-  async assets() {
-    throw new Error("Collection assets not yet implemented");
-  }
-  /**
-   * Get collection metadata (future)
-   */
-  async metadata() {
-    throw new Error("Collection metadata not yet implemented");
-  }
-  /**
-   * Get raw collection data
-   */
-  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, this.http, this.workspaceSlug);
-    } 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
-   *
-   * @param slugs - Collection slugs to try in order
-   * @param options - Options for fallback behavior
-   * @returns Entries from the first matching collection, or empty array
-   *
-   * @example
-   * ```ts
-   * // Try bench-notes, then journal, then blog
-   * const entries = await collections.fallback(['bench-notes', 'journal', 'blog']);
-   * ```
-   */
-  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 = await 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, http, workspaceSlug) {
-    this.data = data;
-    this.http = http;
-    this.workspaceSlug = workspaceSlug;
-  }
-  data;
-  http;
-  workspaceSlug;
-  // Expose all resource data as properties
-  get id() {
-    return this.data.id;
-  }
-  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 metadata() {
-    return this.data.metadata;
-  }
-  get createdAt() {
-    return this.data.createdAt;
-  }
-  get updatedAt() {
-    return this.data.updatedAt;
-  }
-  /**
-   * Get all entries that reference this resource
-   */
-  async entries() {
-    const endpoint = `/api/publish/${this.workspaceSlug}/resources/${this.data.slug}/entries`;
-    return this.http.fetch(endpoint);
-  }
-  /**
-   * Get assets related to this resource (future)
-   */
-  async assets() {
-    throw new Error("Resource assets not yet implemented");
-  }
-  /**
-   * Get raw resource data
-   */
-  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, this.http, this.workspaceSlug);
-  }
-  /**
-   * Get entries that reference this resource
-   */
-  async entries(slug) {
-    const resource = await this.get(slug);
-    return resource.entries();
-  }
-};
-
-// 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);
-  }
-  http;
-  _site = null;
-  _slug;
-  entries;
-  collections;
-  assets;
-  resources;
-  /**
-   * 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);
-  }
-  /**
-   * Get workspace settings (future)
-   */
-  async settings() {
-    throw new Error("Workspace settings not yet implemented");
-  }
-};
-
-// src/client/marvin.ts
-var MarvinClient = class {
-  constructor(config) {
-    this.config = 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();
-    }
-  }
-  config;
-  http;
-  cache;
-  workspace;
-  initialized = false;
-  /**
-   * 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;
-  }
-  // ======================
-  // 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
-   *
-   * @param slugs - Collection slugs to try in order
-   * @param options - Options for fallback behavior
-   * @returns Entries from the first matching collection, or empty array
-   *
-   * @example
-   * ```ts
-   * // Try bench-notes, then journal, then blog
-   * const entries = await client.collectionFallback(['bench-notes', 'journal', 'blog']);
-   * ```
-   */
-  async collectionFallback(slugs, options) {
-    return this.workspace.collections.fallback(slugs, options);
-  }
-  // ======================
-  // Backwards-Compatible Publishing API
-  // ======================
-  /**
-   * @deprecated Use workspace.site or marvin.site instead
-   * Get site configuration
-   */
-  async getSite() {
-    return this.workspace.loadSite();
-  }
-  /**
-   * @deprecated Use workspace.entries.list() instead
-   * Get all published entries
-   */
-  async getEntries(options) {
-    return this.workspace.entries.list(options);
-  }
-  /**
-   * @deprecated Use workspace.entries.get() instead
-   * Get a single published entry by slug
-   */
-  async getEntry(slug) {
-    const entry = await this.workspace.entries.get(slug);
-    if (!entry) {
-      return null;
-    }
-    return entry.toJSON();
-  }
-  /**
-   * @deprecated Use workspace.collections.list() instead
-   * Get all collections
-   */
-  async getCollections() {
-    return this.workspace.collections.list();
-  }
-  /**
-   * @deprecated Use workspace.collections.get() instead
-   * Get a single collection by slug
-   */
-  async getCollection(slug) {
-    const collection = await this.workspace.collections.get(slug);
-    if (!collection) {
-      return null;
-    }
-    return collection.toJSON();
-  }
-  /**
-   * @deprecated Use workspace.collections.entries() instead
-   * Get all entries in a collection
-   */
-  async getCollectionEntries(slug) {
-    return this.workspace.collections.entries(slug);
-  }
-  /**
-   * @deprecated Use workspace.assets.list() instead
-   * Get all published assets
-   */
-  async getAssets(options) {
-    return this.workspace.assets.list(options);
-  }
-  /**
-   * @deprecated Use workspace.resources.list() instead
-   * Get all published resources
-   */
-  async getResources(options) {
-    return this.workspace.resources.list(options);
-  }
-  /**
-   * @deprecated Use workspace.resources.get() instead
-   * Get a single resource by slug
-   */
-  async getResource(slug) {
-    const resource = await this.workspace.resources.get(slug);
-    return resource.toJSON();
-  }
-  /**
-   * @deprecated Use workspace.resources.entries() instead
-   * Get entries that reference a resource
-   */
-  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
-});