@inneropen/marvin-sdk 2.0.1 → 3.0.0

package/dist/chunk-SGZG7U7V.js

@@ -0,0 +1,1015 @@
+import {
+  BearerTokenAuth,
+  HttpClient,
+  MarvinCache,
+  MarvinNotFoundError,
+  __esm,
+  __export,
+  init_core,
+  init_errors
+} from "./chunk-WJC4X7TB.js";
+
+// 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/entries/entry.ts
+var Entry;
+var init_entry = __esm({
+  "src/entries/entry.ts"() {
+    "use strict";
+    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/collections/collection.ts
+var Collection;
+var init_collection = __esm({
+  "src/collections/collection.ts"() {
+    "use strict";
+    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/resources/resource.ts
+var Resource;
+var init_resource = __esm({
+  "src/resources/resource.ts"() {
+    "use strict";
+    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/entries/entries.ts
+var EntriesModule;
+var init_entries = __esm({
+  "src/entries/entries.ts"() {
+    "use strict";
+    init_entry();
+    init_errors();
+    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/collections.ts
+var CollectionsModule;
+var init_collections = __esm({
+  "src/collections/collections.ts"() {
+    "use strict";
+    init_collection();
+    init_errors();
+    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;
+var init_assets = __esm({
+  "src/assets/assets.ts"() {
+    "use strict";
+    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/resources.ts
+var ResourcesModule;
+var init_resources = __esm({
+  "src/resources/resources.ts"() {
+    "use strict";
+    init_resource();
+    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/renderers/renderers.ts
+var RenderersModule;
+var init_renderers = __esm({
+  "src/renderers/renderers.ts"() {
+    "use strict";
+    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;
+var init_workspace = __esm({
+  "src/workspaces/workspace.ts"() {
+    "use strict";
+    init_entries();
+    init_collections();
+    init_assets();
+    init_resources();
+    init_renderers();
+    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);
+      }
+      /**
+       * Get workspace settings (future)
+       */
+      async settings() {
+        throw new Error("Workspace settings not yet implemented");
+      }
+    };
+  }
+});
+
+// src/client/http.ts
+var MarvinHttpClient;
+var init_http = __esm({
+  "src/client/http.ts"() {
+    "use strict";
+    init_core();
+    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/client/marvin.ts
+var marvin_exports = {};
+__export(marvin_exports, {
+  MarvinClient: () => MarvinClient
+});
+var MarvinClient;
+var init_marvin = __esm({
+  "src/client/marvin.ts"() {
+    "use strict";
+    init_config();
+    init_http();
+    init_core();
+    init_workspace();
+    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;
+      }
+      /**
+       * 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
+       *
+       * @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);
+      }
+    };
+  }
+});
+
+export {
+  createConfigFromEnv,
+  config_exports,
+  init_config,
+  Entry,
+  init_entry,
+  Collection,
+  init_collection,
+  Resource,
+  init_resource,
+  Workspace,
+  init_workspace,
+  MarvinClient,
+  marvin_exports,
+  init_marvin
+};