@inneropen/marvin-astro 1.0.0

package/dist/index.js

@@ -0,0 +1,1055 @@
+// src/client.ts
+import { createMarvinClient } from "@inneropen/marvin-sdk";
+
+// src/config.ts
+var ENV_KEYS = {
+  apiUrl: "MARVIN_API_URL",
+  siteClientToken: "MARVIN_SITE_CLIENT_TOKEN",
+  workspaceSlug: "MARVIN_WORKSPACE_SLUG",
+  debug: "MARVIN_DEBUG"
+};
+var DEFAULT_DEV_RETRY_MS = 3e4;
+function metaEnv() {
+  try {
+    return import.meta.env;
+  } catch {
+    return void 0;
+  }
+}
+function processEnv() {
+  try {
+    return typeof process !== "undefined" ? process.env : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readEnv(key, override) {
+  return nonEmpty(override?.[key]) ?? nonEmpty(metaEnv()?.[key]) ?? nonEmpty(processEnv()?.[key]);
+}
+function isProduction(override) {
+  const prodFlag = metaEnv()?.PROD;
+  if (typeof prodFlag === "boolean") return prodFlag;
+  const mode = readEnv("NODE_ENV", override) ?? readEnv("MODE", override);
+  return mode === "production";
+}
+function resolveConfig(options = {}) {
+  const env = options.env;
+  const apiUrl = options.apiUrl ?? readEnv(ENV_KEYS.apiUrl, env) ?? "";
+  const siteClientToken = options.siteClientToken ?? readEnv(ENV_KEYS.siteClientToken, env) ?? "";
+  const workspaceSlug = options.workspaceSlug ?? readEnv(ENV_KEYS.workspaceSlug, env) ?? "";
+  const debug = options.debug ?? readEnv(ENV_KEYS.debug, env) === "true";
+  return {
+    apiUrl,
+    siteClientToken,
+    workspaceSlug,
+    debug,
+    retryAfterMs: options.retryAfterMs ?? (isProduction(env) ? Number.POSITIVE_INFINITY : DEFAULT_DEV_RETRY_MS),
+    logger: options.logger ?? console,
+    markdown: options.markdown,
+    now: options.now ?? (() => Date.now()),
+    createClient: options.createClient,
+    configured: Boolean(apiUrl && siteClientToken && workspaceSlug)
+  };
+}
+function describeConfig(config) {
+  const token = config.siteClientToken;
+  return {
+    [ENV_KEYS.apiUrl]: config.apiUrl || "MISSING",
+    [ENV_KEYS.siteClientToken]: token ? `${token.slice(0, 12)}${"*".repeat(20)}` : "MISSING",
+    [ENV_KEYS.workspaceSlug]: config.workspaceSlug || "MISSING",
+    hasAll: config.configured
+  };
+}
+
+// src/client.ts
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+function isNetworkFailure(error) {
+  const message = errorMessage(error).toLowerCase();
+  return message.includes("network error") || message.includes("fetch failed") || message.includes("econnrefused") || message.includes("enotfound") || message.includes("etimedout");
+}
+function createBackend(options = {}) {
+  const config = resolveConfig(options);
+  let client = null;
+  let latchedAt = null;
+  let envLogged = false;
+  function isLatched() {
+    if (latchedAt === null) return false;
+    if (config.retryAfterMs === Number.POSITIVE_INFINITY) return true;
+    if (config.now() - latchedAt < config.retryAfterMs) return true;
+    latchedAt = null;
+    return false;
+  }
+  function hasBackend() {
+    if (config.debug && !envLogged) {
+      envLogged = true;
+      config.logger.log("[marvin-astro] env check:", describeConfig(config));
+    }
+    if (!config.configured) return false;
+    return !isLatched();
+  }
+  return {
+    config,
+    hasBackend,
+    isLatched,
+    clearLatch() {
+      latchedAt = null;
+    },
+    remember(error) {
+      if (isNetworkFailure(error)) latchedAt = config.now();
+    },
+    warn(message) {
+      config.logger.warn(`[marvin-astro] ${message}`);
+    },
+    client() {
+      if (!config.configured) {
+        throw new Error(
+          "[marvin-astro] Marvin is not configured. Set MARVIN_API_URL, MARVIN_SITE_CLIENT_TOKEN and MARVIN_WORKSPACE_SLUG, or pass them to createMarvinContent()."
+        );
+      }
+      client ??= config.createClient ? config.createClient({
+        apiUrl: config.apiUrl,
+        siteClientToken: config.siteClientToken,
+        workspaceSlug: config.workspaceSlug,
+        debug: config.debug
+      }) : createMarvinClient({
+        apiUrl: config.apiUrl,
+        siteClientToken: config.siteClientToken,
+        workspaceSlug: config.workspaceSlug,
+        debug: config.debug
+      });
+      return client;
+    }
+  };
+}
+
+// src/normalize.ts
+function asString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function asNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const items = value.filter(
+    (item) => typeof item === "string" && item.trim().length > 0
+  );
+  return items.length > 0 ? items : void 0;
+}
+function entryMetadata(entry) {
+  const value = entry;
+  return asRecord(value.metadata ?? value.metadataJson);
+}
+function entryData(entry) {
+  const value = entry;
+  return asRecord(value.data ?? value.dataJson);
+}
+function entryField(entry, key) {
+  const accessor = entry.field;
+  if (typeof accessor === "function") {
+    return accessor.call(entry, key);
+  }
+  return entryData(entry)[key];
+}
+function field(entry, key) {
+  const value = entryField(entry, key);
+  if (value !== void 0 && value !== null && value !== "") return value;
+  const fallback = entryMetadata(entry)[key];
+  return fallback === "" ? void 0 : fallback;
+}
+function assetField(asset, key) {
+  if (!asset || typeof asset !== "object") return void 0;
+  const value = asset;
+  const nested = asRecord(value.asset);
+  return value[key] ?? asRecord(value.entryMetadata)[key] ?? asRecord(value.placementMetadata)[key] ?? asRecord(value.metadataJson)[key] ?? asRecord(value.metadata_)[key] ?? asRecord(value.metadata)[key] ?? nested[key] ?? asRecord(nested.metadataJson)[key] ?? asRecord(nested.metadata_)[key] ?? asRecord(nested.metadata)[key];
+}
+function resourceField(resource, key) {
+  if (!resource || typeof resource !== "object") return void 0;
+  const value = resource;
+  const nested = asRecord(value.resource);
+  return value[key] ?? asRecord(value.entryMetadata)[key] ?? asRecord(value.metadataJson)[key] ?? asRecord(value.metadata_)[key] ?? asRecord(value.metadata)[key] ?? nested[key] ?? asRecord(nested.metadataJson)[key] ?? asRecord(nested.metadata_)[key] ?? asRecord(nested.metadata)[key];
+}
+function collectionSlugs(entry) {
+  const direct = entry.collectionSlugs;
+  if (Array.isArray(direct)) {
+    return direct.filter((slug) => typeof slug === "string");
+  }
+  const raw = entry.collections;
+  if (!Array.isArray(raw)) return [];
+  return raw.map(
+    (item) => typeof item === "string" ? item : asRecord(asRecord(item).collection).slug ?? asRecord(item).slug
+  ).filter((slug) => typeof slug === "string");
+}
+function collectionRole(entry, collectionSlug) {
+  const raw = entry.collections;
+  if (!Array.isArray(raw)) return void 0;
+  for (const item of raw) {
+    if (typeof item === "string") continue;
+    const record = asRecord(item);
+    const slug = asString(record.slug) ?? asString(asRecord(record.collection).slug);
+    if (slug === collectionSlug) {
+      return asString(asRecord(record.entryMetadata).role) ?? asString(record.role);
+    }
+  }
+  return void 0;
+}
+function focalPoint(value) {
+  const direct = asString(value);
+  if (direct) return direct;
+  const point = asRecord(value);
+  const x = typeof point.x === "number" ? point.x : void 0;
+  const y = typeof point.y === "number" ? point.y : void 0;
+  if (x == null || y == null) return void 0;
+  return `${x > 1 ? x : x * 100}% ${y > 1 ? y : y * 100}%`;
+}
+function entryAssets(entry) {
+  const assets = entry.assets;
+  return Array.isArray(assets) ? assets : [];
+}
+function entryResources(entry) {
+  const resources = entry.resources;
+  return Array.isArray(resources) ? resources : [];
+}
+function includesPreferred(actual, exact, any) {
+  if (!exact && !any?.length) return true;
+  if (!actual) return false;
+  return actual === exact || Boolean(any?.includes(actual));
+}
+function assetMatches(asset, options) {
+  const role = asString(assetField(asset, "role"));
+  const usage = asString(assetField(asset, "usage"));
+  const type = asString(assetField(asset, "assetType"));
+  const mimeType = asString(assetField(asset, "mimeType"));
+  const hasRoleCriteria = Boolean(options.role || options.roles?.length);
+  const hasUsageCriteria = Boolean(options.usage || options.usages?.length);
+  const roleMatches = includesPreferred(role, options.role, options.roles);
+  const usageMatches = includesPreferred(usage, options.usage, options.usages);
+  const typeMatches = includesPreferred(type, options.type, options.types);
+  const mimeMatches = options.mimeType ? mimeType === options.mimeType : true;
+  const unroledAllowed = Boolean(options.allowUnroled) && !role && !usage;
+  const relationshipMatches = hasRoleCriteria || hasUsageCriteria ? roleMatches || usageMatches || unroledAllowed : true;
+  return relationshipMatches && typeMatches && mimeMatches;
+}
+function selectEntryAsset(entry, options = {}) {
+  return entryAssets(entry).find((asset) => assetMatches(asset, options));
+}
+function selectAssetByRole(entry, ...roles) {
+  for (const role of roles) {
+    const found = entryAssets(entry).find((asset) => asString(assetField(asset, "role")) === role);
+    if (found) return found;
+  }
+  return void 0;
+}
+function selectFeaturedAsset(entry) {
+  const featured = asRecord(entry.featuredAsset);
+  return Object.keys(featured).length > 0 ? featured : void 0;
+}
+function selectImageAsset(entry, options = {}) {
+  return selectEntryAsset(entry, { ...options, type: "image" }) ?? selectEntryAsset(entry, { ...options, types: ["image"], allowUnroled: true });
+}
+function selectIconAsset(entry) {
+  return selectEntryAsset(entry, {
+    roles: ["icon"],
+    types: ["svg", "image"],
+    mimeType: "image/svg+xml",
+    allowUnroled: true
+  }) ?? selectEntryAsset(entry, {
+    roles: ["icon"],
+    types: ["svg", "image"],
+    allowUnroled: true
+  });
+}
+function assetUrl(asset) {
+  return asString(assetField(asset, "publicUrl"));
+}
+function assetAlt(asset, fallback) {
+  return asString(assetField(asset, "altText")) ?? fallback;
+}
+function resourceRole(resource) {
+  return asString(resourceField(resource, "role"));
+}
+function isExternalHref(href) {
+  return /^(https?:|mailto:|tel:)/.test(href);
+}
+
+// src/chrome.ts
+function toNavigationLink(link) {
+  return {
+    label: link.label,
+    href: link.href,
+    description: link.description,
+    external: isExternalHref(link.href),
+    role: link.role
+  };
+}
+var defaultResolveHref = (_entry, context) => {
+  const owning = context.collections.find((slug) => !context.navCollections.has(slug));
+  return owning ? `/${owning}/${context.slug}` : `/${context.slug}`;
+};
+function metadataLink(value) {
+  const link = asRecord(value);
+  const label = asString(link.label);
+  const href = asString(link.href);
+  if (!label || !href) return void 0;
+  return {
+    label,
+    href,
+    description: asString(link.description) ?? asString(link.subject),
+    external: isExternalHref(href)
+  };
+}
+function socialLabel(key) {
+  return key.replace(/[-_]/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+function socialLinkFromKey(key, href) {
+  return {
+    label: socialLabel(key),
+    href,
+    icon: key,
+    external: isExternalHref(href)
+  };
+}
+function createChromeLoader(fetcher, siteLoader, options = {}) {
+  const mainCollection = options.mainCollection ?? "main-navigation";
+  const footerCollection = options.footerCollection ?? "footer-navigation";
+  const legalRole = options.legalRole ?? "legal";
+  const footerColumnThreshold = options.footerColumnThreshold ?? 4;
+  const resolveHref = options.resolveHref ?? defaultResolveHref;
+  const navCollections = /* @__PURE__ */ new Set([mainCollection, footerCollection]);
+  const fallback = options.fallback ?? {};
+  let promise = null;
+  function entryToLink(entry, collectionSlug, context) {
+    const slug = entry.slug ?? "";
+    const href = asString(entryField(entry, "href")) ?? asString(entryField(entry, "url")) ?? asString(entryField(entry, "path")) ?? resolveHref(entry, {
+      context,
+      collectionSlug,
+      slug,
+      collections: collectionSlugs(entry),
+      navCollections
+    });
+    const label = asString(entryField(entry, "label")) ?? asString(asRecord(entry.metadataJson).label) ?? asString(entry.title) ?? href;
+    return {
+      label,
+      href,
+      description: asString(entry.summary) ?? asString(entry.description),
+      external: isExternalHref(href),
+      role: collectionRole(entry, collectionSlug)
+    };
+  }
+  async function navigationCollection(slug, context, staticLinks) {
+    if (!fetcher.backend.hasBackend()) return { links: staticLinks, fromBackend: false };
+    const entries = await fetcher.hydratedCollectionEntries(slug);
+    if (entries.length === 0) return { links: staticLinks, fromBackend: false };
+    return { links: entries.map((entry) => entryToLink(entry, slug, context)), fromBackend: true };
+  }
+  function groupFooterLinks(links) {
+    if (links.length <= footerColumnThreshold) return [links];
+    const midpoint = Math.ceil(links.length / 2);
+    return [links.slice(0, midpoint), links.slice(midpoint)];
+  }
+  async function load() {
+    const site = await siteLoader.get();
+    const staticMain = (fallback.mainNavigation ?? []).map(toNavigationLink);
+    const staticFooter = (fallback.footerNavigation ?? []).map(
+      (group) => group.map(toNavigationLink)
+    );
+    const main = await navigationCollection(mainCollection, "main", staticMain);
+    const footer = await navigationCollection(footerCollection, "footer", staticFooter.flat());
+    const socialLinks = Object.entries(site.social).map(
+      ([key, href]) => socialLinkFromKey(key, href)
+    );
+    if (site.email && !socialLinks.some((link) => link.icon === "email")) {
+      socialLinks.push(socialLinkFromKey("email", `mailto:${site.email}`));
+    }
+    const legalLinks = footer.fromBackend ? footer.links.filter((link) => link.role === legalRole) : [];
+    const columnLinks = footer.links.filter((link) => link.role !== legalRole);
+    const staticLegal = (fallback.legalLinks ?? []).map(toNavigationLink);
+    return {
+      site,
+      mainNavigation: main.links,
+      footerNavigation: footer.fromBackend ? groupFooterLinks(columnLinks) : staticFooter,
+      legalLinks: legalLinks.length > 0 ? legalLinks : staticLegal,
+      socialLinks: socialLinks.length > 0 ? socialLinks : (fallback.socialLinks ?? []).map((link) => ({
+        ...toNavigationLink(link),
+        icon: link.icon
+      })),
+      inquiry: metadataLink(site.metadata.inquiry) ?? (fallback.inquiry ? toNavigationLink(fallback.inquiry) : void 0)
+    };
+  }
+  return {
+    get() {
+      promise ??= load();
+      return promise;
+    },
+    reset() {
+      promise = null;
+    }
+  };
+}
+
+// src/fetch.ts
+function createFetcher(backend) {
+  async function guarded(label, empty, run) {
+    if (!backend.hasBackend()) return empty;
+    try {
+      return await run();
+    } catch (error) {
+      backend.remember(error);
+      backend.warn(`${label} unavailable: ${errorMessage(error)}`);
+      return empty;
+    }
+  }
+  async function entry(slug) {
+    return guarded(`Entry "${slug}"`, null, () => backend.client().entry(slug));
+  }
+  async function hydrate(entries) {
+    const hydrated = await Promise.all(
+      entries.map(async (item) => {
+        if (typeof item.field === "function" || "data" in item || "dataJson" in item) {
+          return item;
+        }
+        return entry(item.slug ?? "");
+      })
+    );
+    return hydrated.filter((item) => Boolean(item));
+  }
+  return {
+    backend,
+    collections() {
+      return guarded("Collections", [], () => backend.client().collections.list());
+    },
+    async collection(slug) {
+      return guarded(`Collection "${slug}"`, null, async () => {
+        const found = await backend.client().collections.get(slug);
+        return Array.isArray(found) ? null : found;
+      });
+    },
+    collectionEntries(slug) {
+      return guarded(
+        `Collection entries "${slug}"`,
+        [],
+        () => backend.client().collections.entries(slug)
+      );
+    },
+    /** Try each collection slug in order; return the first that yields entries. */
+    async collectionEntriesFallback(slugs) {
+      for (const slug of slugs) {
+        const entries = await this.collectionEntries(slug);
+        if (entries.length > 0) return entries;
+      }
+      return [];
+    },
+    async hydratedCollectionEntries(slug) {
+      return hydrate(await this.collectionEntries(slug));
+    },
+    async hydratedCollectionEntriesFallback(slugs) {
+      for (const slug of slugs) {
+        const entries = await this.hydratedCollectionEntries(slug);
+        if (entries.length > 0) return entries;
+      }
+      return [];
+    },
+    hydrate,
+    entry,
+    site() {
+      return guarded("Site", null, () => backend.client().getSite());
+    },
+    workspace() {
+      return guarded("Workspace", null, () => backend.client().getWorkspace());
+    },
+    assets(type) {
+      return guarded("Assets", [], () => backend.client().assets.list({ type }));
+    },
+    asset(slugOrId) {
+      return guarded(`Asset "${slugOrId}"`, null, () => backend.client().assets.get(slugOrId));
+    },
+    resources(resourceType) {
+      return guarded("Resources", [], () => backend.client().resources.list({ resourceType }));
+    }
+  };
+}
+
+// src/markdown.ts
+import { Marked } from "marked";
+function createMarkdownRenderer(options = {}) {
+  const marked = new Marked();
+  marked.setOptions({ gfm: true, breaks: false, ...options });
+  return async (markdown) => {
+    const source = Array.isArray(markdown) ? markdown.join("\n\n") : markdown ?? "";
+    if (!source) return "";
+    return await marked.parse(source);
+  };
+}
+function preserveSoftBreaks(source) {
+  return source.replace(/(?<!\n)\n(?!\n)/g, "  \n");
+}
+
+// src/format.ts
+var MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+function formatDisplayDate(value) {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  const iso = /^(\d{4})-(\d{2})-(\d{2})/.exec(trimmed);
+  if (iso) {
+    const [, year, month, day] = iso;
+    const name = MONTHS[Number(month) - 1];
+    if (name) return `${name} ${day}, ${year}`;
+  }
+  return trimmed;
+}
+function selectValuesForPage(items, pageSlug, count = 4) {
+  const seeded = [...items];
+  let seed = 0;
+  for (const character of pageSlug) {
+    seed = seed * 31 + character.charCodeAt(0) >>> 0;
+  }
+  for (let index = seeded.length - 1; index > 0; index -= 1) {
+    seed = seed * 1664525 + 1013904223 >>> 0;
+    const target = seed % (index + 1);
+    [seeded[index], seeded[target]] = [seeded[target], seeded[index]];
+  }
+  return seeded.slice(0, count);
+}
+
+// src/fields.ts
+var DEFAULT_IMAGE_ROLES = ["hero", "featured", "card"];
+function createFieldAccessor(entry, context) {
+  const title = asString(entry.title);
+  const accessor = {
+    /** The entry itself, for anything the accessor doesn't cover. */
+    entry,
+    /** The route this entry resolves to (from the repository's `href` option). */
+    href: context.href,
+    collection: context.collection,
+    /** `data_json` → `metadata_json`, untyped. */
+    raw(key) {
+      return field(entry, key);
+    },
+    string(key) {
+      return asString(field(entry, key));
+    },
+    number(key) {
+      return asNumber(field(entry, key));
+    },
+    /** Booleans authored as strings (`"true"`, `"1"`, `"yes"`) read as booleans. */
+    bool(key) {
+      const value = field(entry, key);
+      if (typeof value === "boolean") return value;
+      if (typeof value === "string") {
+        return ["true", "1", "yes", "on"].includes(value.trim().toLowerCase());
+      }
+      if (typeof value === "number") return value !== 0;
+      return Boolean(value);
+    },
+    /** A string array, tolerating a single string authored in place of a list. */
+    list(key) {
+      const value = field(entry, key);
+      const array = asStringArray(value);
+      if (array) return array;
+      const single = asString(value);
+      return single ? [single] : void 0;
+    },
+    /**
+     * An enum-guarded read: the value if it's in `allowed`, else `fallback`. Replaces the
+     * per-field `normalizeStatus`/`normalizeCategory`/`normalizeTone` guards that every site
+     * ends up writing.
+     */
+    oneOf(key, allowed, fallback) {
+      const value = asString(field(entry, key));
+      const set = allowed instanceof Set ? allowed : new Set(allowed);
+      return value && set.has(value) ? value : fallback;
+    },
+    /** A field read as a display date ("Mon DD, YYYY"); already-formatted values pass through. */
+    date(key) {
+      return formatDisplayDate(asString(field(entry, key)));
+    },
+    /** The raw ISO publish timestamp, if any. */
+    publishedAt() {
+      const value = entry.publishedAt;
+      return value != null ? String(value) : void 0;
+    },
+    /**
+     * Render a markdown field to HTML. Falls back to the entry's `contentMarkdown` when the
+     * named field is absent. Returns `undefined` when there is nothing to render, so the
+     * caller can omit the property rather than emit an empty string.
+     */
+    async markdown(key = "body", options = {}) {
+      const raw = field(entry, key) ?? entry.contentMarkdown;
+      const source = Array.isArray(raw) ? raw.join("\n\n") : asString(raw);
+      if (!source) return void 0;
+      return context.renderMarkdown(options.softBreaks ? preserveSoftBreaks(source) : source);
+    },
+    /**
+     * The entry's primary image. Checks, in order: a hand-authored `metadata_json.featuredImage`,
+     * the exact `preferRoles`, a role/usage match over the entry's image assets, and finally the
+     * list item's `featuredAsset`.
+     */
+    image(options = {}) {
+      const {
+        preferRoles,
+        metadataKey = "featuredImage",
+        alt: altFallback,
+        fallbackToFeatured = true,
+        roles = DEFAULT_IMAGE_ROLES,
+        usages = DEFAULT_IMAGE_ROLES,
+        allowUnroled = true,
+        ...rest
+      } = options;
+      const fallbackAlt = altFallback ?? title ?? "";
+      if (metadataKey) {
+        const authored = asRecord(entryMetadata(entry)[metadataKey]);
+        const src2 = asString(authored.src);
+        if (src2) {
+          return {
+            src: src2,
+            alt: asString(authored.alt) ?? fallbackAlt,
+            focalPoint: focalPoint(authored.focalPoint)
+          };
+        }
+      }
+      const asset = (preferRoles?.length ? selectAssetByRole(entry, ...preferRoles) : void 0) ?? selectImageAsset(entry, { ...rest, roles, usages, allowUnroled }) ?? (fallbackToFeatured ? selectFeaturedAsset(entry) : void 0);
+      const src = assetUrl(asset);
+      if (!src) return void 0;
+      return {
+        src,
+        alt: assetAlt(asset, fallbackAlt) ?? fallbackAlt,
+        focalPoint: focalPoint(assetField(asset, "focalPoint"))
+      };
+    },
+    /** URL of the entry's icon asset (`role: icon`, SVG preferred). */
+    icon(options = {}) {
+      const { roles = ["icon"], fallbackToFeatured = false } = options;
+      const asset = selectAssetByRole(entry, ...roles) ?? selectIconAsset(entry);
+      return assetUrl(asset) ?? (fallbackToFeatured ? assetUrl(selectFeaturedAsset(entry)) : void 0);
+    },
+    /** The raw asset placement matching `options` — when you need more than src/alt/focal. */
+    asset(options = {}) {
+      return selectImageAsset(entry, options) ?? selectFeaturedAsset(entry);
+    },
+    /** The asset whose role is EXACTLY one of `roles`, in preference order. */
+    assetByRole(...roles) {
+      return selectAssetByRole(entry, ...roles);
+    },
+    /** All asset placements on the entry. */
+    assets() {
+      return entryAssets(entry);
+    },
+    /** Every image asset resolved, filtered by role/usage — support/detail galleries. */
+    images(options = {}) {
+      const wanted = /* @__PURE__ */ new Set([...options.roles ?? [], ...options.usages ?? []]);
+      const fallbackAlt = options.alt ?? title ?? "";
+      const images = [];
+      for (const asset of entryAssets(entry)) {
+        const usage = asString(assetField(asset, "usage")) ?? asString(assetField(asset, "role"));
+        const src = assetUrl(asset);
+        if (!src) continue;
+        if (wanted.size > 0 && (!usage || !wanted.has(usage))) continue;
+        images.push({
+          src,
+          alt: assetAlt(asset, fallbackAlt) ?? fallbackAlt,
+          focalPoint: focalPoint(assetField(asset, "focalPoint")),
+          usage
+        });
+      }
+      return images;
+    },
+    /** Attached resources, normalized to name/type/role/href. */
+    resources(options = {}) {
+      const types = options.types?.length ? new Set(options.types) : void 0;
+      return entryResources(entry).map((relationship) => {
+        const nested = asRecord(relationship.resource);
+        const source = Object.keys(nested).length > 0 ? nested : relationship;
+        const slug = asString(resourceField(source, "slug"));
+        return {
+          name: asString(resourceField(source, "name")) ?? "",
+          type: asString(resourceField(source, "resourceType")) ?? "",
+          role: asString(assetField(relationship, "role")),
+          slug,
+          href: slug && options.href ? options.href(slug) : void 0
+        };
+      }).filter((resource) => Boolean(resource.name)).filter((resource) => !types || types.has(resource.type)).filter((resource) => !options.role || resource.role === options.role);
+    },
+    /** The first attached resource matching `options`. */
+    resource(options = {}) {
+      return accessor.resources(options)[0];
+    },
+    /** The `metadata_json` blob. */
+    metadata() {
+      return entryMetadata(entry);
+    },
+    /** The `data_json` blob. Empty on a list item that was not hydrated. */
+    data() {
+      return entryData(entry);
+    },
+    /** Slugs of every collection the entry belongs to. */
+    collections() {
+      return collectionSlugs(entry);
+    },
+    /** The entry's membership role within `collectionSlug`. */
+    role(collectionSlug) {
+      return collectionRole(entry, collectionSlug);
+    }
+  };
+  return accessor;
+}
+
+// src/repository.ts
+function defaultSlugOf(item) {
+  const slug = item.slug;
+  return typeof slug === "string" ? slug : void 0;
+}
+function defaultIsFeatured(item) {
+  return Boolean(item.featured);
+}
+function createRepository(context, options) {
+  const { fetcher, renderMarkdown } = context;
+  const collections = options.collections ?? (options.collection ? [options.collection] : []);
+  const slugOf = options.slugOf ?? defaultSlugOf;
+  const isFeatured = options.isFeatured ?? defaultIsFeatured;
+  let allPromise = null;
+  const bySlugCache = /* @__PURE__ */ new Map();
+  function arrange(items) {
+    const filtered = options.filter ? items.filter(options.filter) : items;
+    return options.sort ? [...filtered].sort(options.sort) : filtered;
+  }
+  function transform(entry, collection) {
+    const slug = entry.slug ?? "";
+    const fields = createFieldAccessor(entry, {
+      renderMarkdown,
+      href: options.href?.(slug, entry),
+      collection
+    });
+    return Promise.resolve(options.transform(entry, fields));
+  }
+  async function useFallback() {
+    return arrange(await options.fallback?.() ?? []);
+  }
+  async function load() {
+    if (collections.length > 0 && fetcher.backend.hasBackend()) {
+      try {
+        const entries = options.hydrate ? await fetcher.hydratedCollectionEntriesFallback(collections) : await fetcher.collectionEntriesFallback(collections);
+        if (entries.length > 0) {
+          const items = await Promise.all(entries.map((entry) => transform(entry)));
+          return arrange(items);
+        }
+      } catch (error) {
+        fetcher.backend.remember(error);
+        fetcher.backend.warn(
+          `Collection "${collections[0]}" failed, using fallback: ${errorMessage(error)}`
+        );
+      }
+    }
+    return useFallback();
+  }
+  async function loadBySlug(slug) {
+    if (fetcher.backend.hasBackend()) {
+      try {
+        const entry = await fetcher.entry(slug);
+        if (entry) return await transform(entry);
+      } catch (error) {
+        fetcher.backend.remember(error);
+        fetcher.backend.warn(`Entry "${slug}" failed, using fallback: ${errorMessage(error)}`);
+      }
+    }
+    return (await all()).find((item) => slugOf(item) === slug);
+  }
+  function all() {
+    allPromise ??= load();
+    return allPromise;
+  }
+  return {
+    all,
+    bySlug(slug) {
+      let cached = bySlugCache.get(slug);
+      if (!cached) {
+        cached = loadBySlug(slug);
+        bySlugCache.set(slug, cached);
+      }
+      return cached;
+    },
+    async allFeatured() {
+      return (await all()).filter(isFeatured);
+    },
+    async featured() {
+      const items = await all();
+      return items.find(isFeatured) ?? items[0];
+    },
+    reset() {
+      allPromise = null;
+      bySlugCache.clear();
+    }
+  };
+}
+
+// src/sections.ts
+async function loadSectionLanding(fetcher, slug, renderMarkdown = createMarkdownRenderer(), options = {}) {
+  const entry = await fetcher.entry(slug);
+  if (!entry) return {};
+  const source = asString(entryField(entry, options.bodyField ?? "body")) ?? asString(entry.summary);
+  return {
+    title: asString(entry.title),
+    introHtml: source ? await renderMarkdown(preserveSoftBreaks(source)) : void 0,
+    hero: assetUrl(selectAssetByRole(entry, options.heroRole ?? "hero"))
+  };
+}
+
+// src/site.ts
+function buildSeo(raw, identity) {
+  const seo = raw ?? {};
+  const verification = asRecord(seo.verification);
+  return {
+    title: asString(seo.title) ?? identity.title,
+    titleTemplate: asString(seo.titleTemplate),
+    description: asString(seo.description) ?? identity.description,
+    keywords: Array.isArray(seo.keywords) ? seo.keywords.filter((keyword) => typeof keyword === "string") : [],
+    robots: asString(seo.robots) ?? "index,follow",
+    image: asString(seo.image),
+    imageAlt: asString(seo.imageAlt),
+    ogType: asString(seo.ogType) ?? "website",
+    siteName: asString(seo.siteName) ?? identity.siteName,
+    twitterCard: asString(seo.twitterCard) ?? "summary_large_image",
+    twitterHandle: asString(seo.twitterHandle),
+    twitterCreator: asString(seo.twitterCreator),
+    fbAppId: asString(seo.fbAppId),
+    themeColor: asString(seo.themeColor),
+    publisher: asString(seo.publisher),
+    canonicalUrl: identity.canonicalUrl,
+    verification: {
+      google: asString(verification.google),
+      bing: asString(verification.bing),
+      pinterest: asString(verification.pinterest),
+      yandex: asString(verification.yandex)
+    }
+  };
+}
+function normalizeSocial(social) {
+  return Object.fromEntries(
+    Object.entries(asRecord(social)).filter(
+      (entry) => typeof entry[1] === "string" && entry[1].length > 0
+    )
+  );
+}
+function buildFallbackSite(options = {}) {
+  const provided = typeof options.fallback === "function" ? options.fallback() : options.fallback;
+  const fallback = provided ?? {};
+  const title = fallback.title ?? fallback.name ?? "Untitled site";
+  const description = fallback.description ?? "";
+  return {
+    ...fallback,
+    name: fallback.name ?? title,
+    title,
+    description,
+    locale: fallback.locale ?? options.defaultLocale ?? "en-US",
+    timezone: fallback.timezone ?? options.defaultTimezone ?? "UTC",
+    social: fallback.social ?? {},
+    metadata: fallback.metadata ?? {},
+    seo: fallback.seo ?? buildSeo(void 0, { title, description, siteName: fallback.name ?? title })
+  };
+}
+function transformMarvinSite(marvinSite, fallback) {
+  const config = marvinSite.site;
+  const metadata = asRecord(config.metadataJson);
+  const title = asString(config.title) ?? asString(marvinSite.workspace?.name) ?? fallback.title;
+  const description = asString(config.description) ?? fallback.description;
+  return {
+    workspaceSlug: asString(marvinSite.workspace?.slug),
+    workspaceName: asString(marvinSite.workspace?.name),
+    name: title,
+    title,
+    tagline: asString(config.tagline) ?? fallback.tagline,
+    description,
+    canonicalUrl: asString(config.canonicalUrl) ?? fallback.canonicalUrl,
+    logo: asString(config.logo) ?? fallback.logo,
+    favicon: asString(config.favicon) ?? fallback.favicon,
+    locale: asString(config.locale) ?? fallback.locale,
+    timezone: asString(config.timezone) ?? fallback.timezone,
+    email: asString(config.contactEmail) ?? fallback.email,
+    imprint: asString(metadata.imprint) ?? fallback.imprint,
+    social: { ...fallback.social, ...normalizeSocial(config.social) },
+    // Typed `config.seo` when the SDK declares it, else the raw `metadata.seo` blob — older
+    // SDKs drop the typed field but pass the blob through untouched, and workspaces configured
+    // before the typed field existed still only have the blob.
+    seo: buildSeo(asRecord(config.seo ?? metadata.seo), {
+      title,
+      description,
+      canonicalUrl: asString(config.canonicalUrl),
+      siteName: title
+    }),
+    metadata
+  };
+}
+function looksLikeAssetSlug(value) {
+  return !/^https?:\/\//.test(value) && !value.startsWith("/") && !value.startsWith("data:");
+}
+function createSiteLoader(fetcher, options = {}) {
+  const fallback = buildFallbackSite(options);
+  let promise = null;
+  async function resolveAssetSlug(slug) {
+    if (!slug) return void 0;
+    return assetUrl(await fetcher.asset(slug));
+  }
+  async function load() {
+    const marvinSite = await fetcher.site();
+    if (!marvinSite) return fallback;
+    const site = transformMarvinSite(marvinSite, fallback);
+    const brandPairs = Object.entries(asRecord(site.metadata.brand)).filter(
+      (entry) => typeof entry[1] === "string" && entry[1].trim().length > 0
+    );
+    const resolved = await Promise.all(
+      brandPairs.map(async ([name, slug]) => [name, await resolveAssetSlug(slug)])
+    );
+    const brand = {};
+    const brandBySlug = /* @__PURE__ */ new Map();
+    for (const [index, [name, url]] of resolved.entries()) {
+      if (!url) continue;
+      brand[name] = url;
+      brandBySlug.set(brandPairs[index][1], url);
+    }
+    const rawImage = site.seo.image;
+    const ogImage = rawImage && looksLikeAssetSlug(rawImage) ? brandBySlug.get(rawImage) ?? await resolveAssetSlug(rawImage) : void 0;
+    return {
+      ...site,
+      brand,
+      // Convenience aliases for common callers; all of these also live in `site.brand`.
+      logo: brand.logo ?? site.logo,
+      favicon: brand.favicon ?? site.favicon,
+      seal: brand.seal ?? site.seal,
+      seo: { ...site.seo, image: ogImage ?? site.seo.image }
+    };
+  }
+  return {
+    get() {
+      promise ??= load();
+      return promise;
+    },
+    reset() {
+      promise = null;
+    }
+  };
+}
+
+// src/index.ts
+function createMarvinContent(options = {}) {
+  const backend = createBackend(options);
+  const fetcher = createFetcher(backend);
+  const renderMarkdown = createMarkdownRenderer(backend.config.markdown);
+  const siteLoader = createSiteLoader(fetcher, options.site);
+  const chromeLoader = createChromeLoader(fetcher, siteLoader, options.chrome);
+  const repositories = [];
+  return {
+    /** The resolved configuration, with the token still in place — don't log it. */
+    config: backend.config,
+    /** Latch control and the raw SDK client. */
+    backend,
+    /** Guarded, never-throwing wrappers around every published endpoint. */
+    fetch: fetcher,
+    renderMarkdown,
+    /** True when Marvin is configured and not currently latched out as unreachable. */
+    hasBackend: () => backend.hasBackend(),
+    /** Resolved site identity, SEO and brand assets. Memoized per process. */
+    getSite() {
+      return siteLoader.get();
+    },
+    /** Navigation, footer, legal, social and inquiry links. Memoized per process. */
+    getSiteChrome() {
+      return chromeLoader.get();
+    },
+    /** Title/intro/hero for an index page, driven by a `page` entry of the same slug. */
+    getSectionLanding(slug, sectionOptions) {
+      return loadSectionLanding(fetcher, slug, renderMarkdown, sectionOptions);
+    },
+    /** A collection-backed content repository: `all()` / `bySlug()` / `featured()`. */
+    repository(repositoryOptions) {
+      const repository = createRepository({ fetcher, renderMarkdown }, repositoryOptions);
+      repositories.push(repository);
+      return repository;
+    },
+    /** Drop every memoized result and re-open the failure latch. */
+    reset() {
+      backend.clearLatch();
+      siteLoader.reset();
+      chromeLoader.reset();
+      for (const repository of repositories) repository.reset();
+    }
+  };
+}
+export {
+  DEFAULT_DEV_RETRY_MS,
+  ENV_KEYS,
+  asNumber,
+  asRecord,
+  asString,
+  asStringArray,
+  assetAlt,
+  assetField,
+  assetUrl,
+  buildFallbackSite,
+  buildSeo,
+  collectionRole,
+  collectionSlugs,
+  createBackend,
+  createChromeLoader,
+  createFetcher,
+  createFieldAccessor,
+  createMarkdownRenderer,
+  createMarvinContent,
+  createRepository,
+  createSiteLoader,
+  defaultResolveHref,
+  describeConfig,
+  entryAssets,
+  entryData,
+  entryField,
+  entryMetadata,
+  entryResources,
+  errorMessage,
+  field,
+  focalPoint,
+  formatDisplayDate,
+  isExternalHref,
+  isNetworkFailure,
+  loadSectionLanding,
+  metadataLink,
+  preserveSoftBreaks,
+  readEnv,
+  resolveConfig,
+  resourceField,
+  resourceRole,
+  selectAssetByRole,
+  selectEntryAsset,
+  selectFeaturedAsset,
+  selectIconAsset,
+  selectImageAsset,
+  selectValuesForPage,
+  socialLinkFromKey,
+  toNavigationLink
+};
+//# sourceMappingURL=index.js.map