@inneropen/marvin-astro 1.1.1 → 1.2.1

package/src/normalize.ts

@@ -0,0 +1,284 @@
+/**
+ * Reading Marvin payloads.
+ *
+ * The published API returns the same logical value in several shapes depending on which
+ * endpoint produced it (list item vs full read, SDK `Entry` wrapper vs raw JSON, placement
+ * metadata vs asset metadata). Every reader here is total: it takes `unknown`, checks, and
+ * returns `undefined` rather than throwing.
+ */
+
+import type { AssetSelectOptions, MarvinContentEntry } from './types.js';
+
+/** A non-empty string, or `undefined`. Empty/whitespace strings are treated as absent. */
+export function asString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
+}
+
+export function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' ? (value as Record<string, unknown>) : {};
+}
+
+export function asNumber(value: unknown): number | undefined {
+  if (typeof value === 'number') return Number.isFinite(value) ? value : undefined;
+  if (typeof value === 'string' && value.trim().length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return undefined;
+}
+
+export function asStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+
+  const items = value.filter(
+    (item): item is string => typeof item === 'string' && item.trim().length > 0
+  );
+  return items.length > 0 ? items : undefined;
+}
+
+/** `metadata_json` — the free-form blob every entry carries, whatever its schema. */
+export function entryMetadata(entry: MarvinContentEntry): Record<string, unknown> {
+  const value = entry as { metadata?: unknown; metadataJson?: unknown };
+  return asRecord(value.metadata ?? value.metadataJson);
+}
+
+/** `data_json` — the schema-defined fields. Absent on list items until hydrated. */
+export function entryData(entry: MarvinContentEntry): Record<string, unknown> {
+  const value = entry as { data?: unknown; dataJson?: unknown };
+  return asRecord(value.data ?? value.dataJson);
+}
+
+/**
+ * Read a schema field (`data_json`) from an entry, through the SDK's `Entry` accessor when
+ * present and off the raw payload otherwise.
+ */
+export function entryField<T = unknown>(entry: MarvinContentEntry, key: string): T | undefined {
+  const accessor = (entry as { field?: (key: string) => unknown }).field;
+  if (typeof accessor === 'function') {
+    return accessor.call(entry, key) as T | undefined;
+  }
+  return entryData(entry)[key] as T | undefined;
+}
+
+/**
+ * The precedence rule: structured schema field first (`data_json`), legacy blob second
+ * (`metadata_json`).
+ *
+ * An empty string counts as absent, which matters more than it sounds — an entry type that
+ * declares a field the author left blank stores `""`, and without this the legacy value that
+ * *is* set would never surface.
+ */
+export function field<T = unknown>(entry: MarvinContentEntry, key: string): T | undefined {
+  const value = entryField(entry, key);
+  if (value !== undefined && value !== null && value !== '') return value as T;
+  const fallback = entryMetadata(entry)[key];
+  return (fallback === '' ? undefined : fallback) as T | undefined;
+}
+
+/**
+ * Read a value off a published asset placement, checking every level the API might have put it
+ * at: the placement itself, its metadata blobs, then the underlying asset and its blobs.
+ */
+export function assetField<T = unknown>(asset: unknown, key: string): T | undefined {
+  if (!asset || typeof asset !== 'object') return undefined;
+
+  const value = asset as Record<string, unknown>;
+  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]) as T | undefined;
+}
+
+/** Same layered read as {@link assetField}, for resource relationships. */
+export function resourceField<T = unknown>(resource: unknown, key: string): T | undefined {
+  if (!resource || typeof resource !== 'object') return undefined;
+
+  const value = resource as Record<string, unknown>;
+  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]) as T | undefined;
+}
+
+/**
+ * The entry's collection memberships as slugs. Collections arrive as bare slugs on list items,
+ * flat `{slug}` objects, or the SDK's nested `{collection: {slug}}` — all three are read here.
+ */
+export function collectionSlugs(entry: MarvinContentEntry): string[] {
+  const direct = (entry as { collectionSlugs?: unknown }).collectionSlugs;
+  if (Array.isArray(direct)) {
+    return direct.filter((slug): slug is string => typeof slug === 'string');
+  }
+
+  const raw = (entry as { collections?: unknown }).collections;
+  if (!Array.isArray(raw)) return [];
+
+  return raw
+    .map((item) =>
+      typeof item === 'string' ? item : (asRecord(asRecord(item).collection).slug ?? asRecord(item).slug)
+    )
+    .filter((slug): slug is string => typeof slug === 'string');
+}
+
+/**
+ * The entry's membership role within one specific collection (e.g. `'legal'` in
+ * `footer-navigation`). A hydrated entry carries all of its memberships; this finds the one for
+ * the given collection.
+ */
+export function collectionRole(
+  entry: MarvinContentEntry,
+  collectionSlug: string
+): string | undefined {
+  const raw = (entry as { collections?: unknown }).collections;
+  if (!Array.isArray(raw)) return undefined;
+
+  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 undefined;
+}
+
+/**
+ * A CSS `object-position` value from a focal point. Marvin stores these either pre-formatted
+ * (`"40% 60%"`) or as `{x, y}` in 0–1 or 0–100 units.
+ */
+export function focalPoint(value: unknown): string | undefined {
+  const direct = asString(value);
+  if (direct) return direct;
+
+  const point = asRecord(value);
+  const x = typeof point.x === 'number' ? point.x : undefined;
+  const y = typeof point.y === 'number' ? point.y : undefined;
+  if (x == null || y == null) return undefined;
+
+  return `${x > 1 ? x : x * 100}% ${y > 1 ? y : y * 100}%`;
+}
+
+export function entryAssets(entry: MarvinContentEntry): Record<string, unknown>[] {
+  const assets = (entry as { assets?: unknown }).assets;
+  return Array.isArray(assets) ? (assets as Record<string, unknown>[]) : [];
+}
+
+export function entryResources(entry: MarvinContentEntry): Record<string, unknown>[] {
+  const resources = (entry as { resources?: unknown }).resources;
+  return Array.isArray(resources) ? (resources as Record<string, unknown>[]) : [];
+}
+
+function includesPreferred(actual: string | undefined, exact?: string, any?: string[]): boolean {
+  if (!exact && !any?.length) return true;
+  if (!actual) return false;
+  return actual === exact || Boolean(any?.includes(actual));
+}
+
+function assetMatches(asset: Record<string, unknown>, options: AssetSelectOptions): boolean {
+  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;
+
+  // Role and usage are alternatives, not a conjunction: an asset placed with `role: hero` and
+  // one placed with `usage: hero` both satisfy a hero request.
+  const relationshipMatches =
+    hasRoleCriteria || hasUsageCriteria ? roleMatches || usageMatches || unroledAllowed : true;
+
+  return relationshipMatches && typeMatches && mimeMatches;
+}
+
+export function selectEntryAsset(
+  entry: MarvinContentEntry,
+  options: AssetSelectOptions = {}
+): Record<string, unknown> | undefined {
+  return entryAssets(entry).find((asset) => assetMatches(asset, options));
+}
+
+/**
+ * Match on role ALONE, exactly. `selectEntryAsset` ORs role against a vacuously-true usage
+ * check, so `{roles: ['hero-grade']}` there matches the entry's first asset whatever its role.
+ * When you mean "the asset whose role is exactly this", use this.
+ */
+export function selectAssetByRole(
+  entry: MarvinContentEntry,
+  ...roles: string[]
+): Record<string, unknown> | undefined {
+  for (const role of roles) {
+    const found = entryAssets(entry).find((asset) => asString(assetField(asset, 'role')) === role);
+    if (found) return found;
+  }
+  return undefined;
+}
+
+/** The list-item shorthand: `featuredAsset` is present on collection entries. */
+export function selectFeaturedAsset(
+  entry: MarvinContentEntry
+): Record<string, unknown> | undefined {
+  const featured = asRecord((entry as { featuredAsset?: unknown }).featuredAsset);
+  return Object.keys(featured).length > 0 ? featured : undefined;
+}
+
+export function selectImageAsset(
+  entry: MarvinContentEntry,
+  options: Omit<AssetSelectOptions, 'type' | 'types'> = {}
+): Record<string, unknown> | undefined {
+  return (
+    selectEntryAsset(entry, { ...options, type: 'image' }) ??
+    selectEntryAsset(entry, { ...options, types: ['image'], allowUnroled: true })
+  );
+}
+
+export function selectIconAsset(entry: MarvinContentEntry): Record<string, unknown> | undefined {
+  return (
+    selectEntryAsset(entry, {
+      roles: ['icon'],
+      types: ['svg', 'image'],
+      mimeType: 'image/svg+xml',
+      allowUnroled: true,
+    }) ??
+    selectEntryAsset(entry, {
+      roles: ['icon'],
+      types: ['svg', 'image'],
+      allowUnroled: true,
+    })
+  );
+}
+
+export function assetUrl(asset: unknown): string | undefined {
+  return asString(assetField(asset, 'publicUrl'));
+}
+
+export function assetAlt(asset: unknown, fallback?: string): string | undefined {
+  return asString(assetField(asset, 'altText')) ?? fallback;
+}
+
+export function resourceRole(resource: unknown): string | undefined {
+  return asString(resourceField(resource, 'role'));
+}
+
+export function isExternalHref(href: string): boolean {
+  return /^(https?:|mailto:|tel:)/.test(href);
+}

package/src/renderers/debug.ts

@@ -0,0 +1,6 @@
+const isDebug = typeof process !== 'undefined' && process.env?.MARVIN_DEBUG === 'true';
+
+/** Trace renderer resolution when `MARVIN_DEBUG=true`. */
+export function debug(...args: unknown[]): void {
+  if (isDebug) console.debug('[Marvin renderers]', ...args);
+}

package/src/renderers/index.ts

@@ -0,0 +1,48 @@
+/**
+ * `@inneropen/marvin-astro/renderers` — framework-agnostic renderer logic: resolve an entry's
+ * renderer, build registries, and validate a registry against a workspace's entry types.
+ * (Formerly `@inneropen/marvin-renderers-core/logic`.) The Astro components live in
+ * `@inneropen/marvin-astro/components`.
+ */
+
+export type {
+  CoreRendererName,
+  EntryTypeInfo,
+  RendererEntry,
+  RendererPackage,
+  RendererPackageOptions,
+  RendererPackageRegistry,
+  RendererProps,
+  RendererRegistry,
+} from './types.js';
+
+export {
+  resolveRendererName,
+  resolveRendererRequirement,
+  resolveRendererConfig,
+  extractBody,
+  extractField,
+  getFeaturedAsset,
+  isRoutable,
+  shouldRenderEntry,
+} from './resolve.js';
+
+export {
+  CORE_RENDERER_PACKAGE,
+  CORE_RENDERER_PACKAGES,
+  isCoreRendererPackage,
+  createPackageRegistry,
+  createRegistry,
+  createRendererPackage,
+  resolveRenderer,
+} from './registry.js';
+
+export type {
+  MissingRenderer,
+  RendererCheckOptions,
+  ValidationResult,
+} from './validation-types.js';
+
+export { validateRenderers } from './validation.js';
+
+export { debug } from './debug.js';

package/src/renderers/registry.ts

@@ -0,0 +1,133 @@
+import type {
+  RendererDefinition,
+  RendererPackage,
+  RendererPackageOptions,
+  RendererPackageRegistry,
+  RendererRegistry,
+} from './types.js';
+
+/**
+ * The renderer-package name Marvin's system entry types declare (`renderingJson.package`). The
+ * core renderers moved into `@inneropen/marvin-astro`, but existing workspaces still name the old
+ * package, so both identify the core set.
+ */
+export const CORE_RENDERER_PACKAGE = '@inneropen/marvin-renderers-core';
+export const CORE_RENDERER_PACKAGES: readonly string[] = [
+  CORE_RENDERER_PACKAGE,
+  '@inneropen/marvin-astro',
+];
+
+export function isCoreRendererPackage(packageName: string | null | undefined): boolean {
+  return Boolean(packageName) && CORE_RENDERER_PACKAGES.includes(packageName as string);
+}
+
+function isRendererRegistry<T>(value: RendererRegistry<T> | Record<string, T> | undefined): value is RendererRegistry<T> {
+  return Boolean(value) && typeof value === 'object' && 'get' in value && typeof value.get === 'function';
+}
+
+export function resolveRenderer<T>(
+  name: string,
+  customRegistry?: RendererRegistry<T> | Record<string, T>,
+  fallbackRegistry?: RendererRegistry<T> | Record<string, T>,
+): T | undefined {
+  const getValue = (registry: RendererRegistry<T> | Record<string, T> | undefined) => {
+    if (!registry) return undefined;
+    if (isRendererRegistry(registry)) {
+      return registry.get(name);
+    }
+    return registry[name];
+  };
+
+  return getValue(customRegistry) ?? getValue(fallbackRegistry);
+}
+
+export function createRegistry<T>(
+  map: Record<string, T>,
+): RendererRegistry<T> {
+  const registryMap = { ...map };
+
+  const instance: RendererRegistry<T> = {
+    get(name: string): T | undefined {
+      return registryMap[name];
+    },
+    has(name: string): boolean {
+      return name in registryMap;
+    },
+    names(): string[] {
+      return Object.keys(registryMap);
+    },
+    use(packageDefinition: RendererPackage<T>): RendererRegistry<T> {
+      for (const [name, value] of Object.entries(packageDefinition.registry.names().reduce<Record<string, T>>((acc, item) => {
+        acc[item] = packageDefinition.registry.get(item)!;
+        return acc;
+      }, {}))) {
+        if (!registryMap[name]) {
+          registryMap[name] = value;
+        }
+      }
+      return instance;
+    },
+    register(definition: RendererDefinition<T>): RendererRegistry<T> {
+      if (registryMap[definition.key]) {
+        throw new Error(`Duplicate renderer registration for "${definition.key}"`);
+      }
+      registryMap[definition.key] = definition.component;
+      return instance;
+    },
+    override(overrides: Record<string, T>): RendererRegistry<T> {
+      for (const [name, value] of Object.entries(overrides)) {
+        registryMap[name] = value;
+      }
+      return instance;
+    },
+  };
+
+  return instance;
+}
+
+export function createRendererPackage<T>(
+  options: RendererPackageOptions<T>,
+): RendererPackage<T> {
+  return {
+    packageName: options.packageName,
+    version: options.version,
+    registry: createRegistry(options.renderers),
+  };
+}
+
+export function createPackageRegistry<T>(
+  packages: RendererPackage<T>[],
+): RendererPackageRegistry<T> {
+  const byPackage = new Map(packages.map((item) => [item.packageName, item]));
+
+  function getPackage(packageName: string): RendererPackage<T> | undefined {
+    return byPackage.get(packageName);
+  }
+
+  function findLocalRenderer(name: string): T | undefined {
+    for (const item of packages) {
+      const renderer = item.registry.get(name);
+      if (renderer) return renderer;
+    }
+    return undefined;
+  }
+
+  return {
+    get(name: string, packageName?: string | null): T | undefined {
+      if (packageName) {
+        return getPackage(packageName)?.registry.get(name);
+      }
+      return findLocalRenderer(name);
+    },
+    has(name: string, packageName?: string | null): boolean {
+      return Boolean(this.get(name, packageName));
+    },
+    names(): string[] {
+      return packages.flatMap((item) => item.registry.names());
+    },
+    packages(): RendererPackage<T>[] {
+      return packages;
+    },
+    getPackage,
+  };
+}

package/src/renderers/resolve.ts

@@ -0,0 +1,134 @@
+import type { MarvinAsset } from '@inneropen/marvin-sdk';
+import type { RendererEntry, RendererRequirement } from './types.js';
+import { debug } from './debug.js';
+
+const DEFAULT_RENDERER = 'page';
+
+export function resolveRendererRequirement(entry: RendererEntry): RendererRequirement {
+  const config = entry.entryTypeInfo?.config ?? {};
+  const key = entry.entryTypeInfo?.renderer ?? DEFAULT_RENDERER;
+
+  return {
+    key,
+    packageName: entry.entryTypeInfo?.package ?? undefined,
+    versionRange: entry.entryTypeInfo?.version ?? undefined,
+    config,
+  };
+}
+
+export function resolveRendererName(entry: RendererEntry): string {
+  const name = entry.entryTypeInfo?.renderer ?? DEFAULT_RENDERER;
+  debug('resolveRendererName', { slug: entry.slug, renderer: name });
+  return name;
+}
+
+export function resolveRendererConfig(
+  entry: RendererEntry,
+  overrides?: Record<string, unknown>,
+): Record<string, unknown> {
+  const base = entry.entryTypeInfo?.config ?? {};
+  const merged = overrides ? { ...base, ...overrides } : base;
+  debug('resolveRendererConfig', { slug: entry.slug, config: merged });
+  return merged;
+}
+
+/**
+ * The entry's field bag, merging `dataJson` under `data` (per-key, `data` wins).
+ *
+ * `data` is a REQUIRED field on a published entry, so the older
+ * `entry.data ?? entry.dataJson` short-circuited on an empty `{}` and never
+ * consulted `dataJson` — making that fallback dead. Merging keeps published
+ * behaviour identical (published entries carry no `dataJson`) while letting a
+ * platform-shaped entry's `dataJson` supply keys `data` doesn't have, matching
+ * how `extractField` already resolves values.
+ */
+function entryData(entry: RendererEntry): Record<string, unknown> {
+  return { ...(entry.dataJson ?? {}), ...(entry.data ?? {}) };
+}
+
+export function extractBody(entry: RendererEntry): string | undefined {
+  const body = entryData(entry).body;
+  if (typeof body === 'string') return body;
+  return entry.contentMarkdown;
+}
+
+export function extractField<T = unknown>(
+  entry: RendererEntry,
+  key: string,
+): T | undefined {
+  return (entry.data?.[key] ?? entry.dataJson?.[key]) as T | undefined;
+}
+
+export function getFeaturedAsset(
+  entry: RendererEntry,
+): MarvinAsset | undefined {
+  const featuredAsset = normalizeEntryAsset(entry.featuredAsset);
+  if (featuredAsset?.publicUrl) {
+    debug('getFeaturedAsset', { slug: entry.slug, source: 'featuredAsset', url: featuredAsset.publicUrl });
+    return featuredAsset as unknown as MarvinAsset;
+  }
+
+  const assets = entry.assets;
+  if (!assets?.length) return undefined;
+
+  const featured = assets.find(
+    (a) => {
+      const value = a as unknown as Record<string, unknown>;
+      const role = value.role ?? (value.metadata as Record<string, unknown> | undefined)?.role;
+      return role === 'featured' || role === 'hero';
+    },
+  );
+  const result = normalizeEntryAsset(featured ?? assets[0]) as unknown as MarvinAsset | undefined;
+  debug('getFeaturedAsset', { slug: entry.slug, source: featured ? 'role-match' : 'first-asset', url: result?.publicUrl });
+  return result;
+}
+
+export function isRoutable(entry: RendererEntry): boolean {
+  return entry.entryTypeInfo?.routable !== false;
+}
+
+export function shouldRenderEntry(entry: RendererEntry, rendererName?: string): boolean {
+  const data = entryData(entry);
+  const flags = [
+    rendererName && typeof rendererName === 'string' ? data[rendererName] : undefined,
+    data.enabled,
+    data.visible,
+    data.show,
+    data.display,
+    data.include,
+  ].filter((value): value is unknown => value !== undefined);
+
+  for (const value of flags) {
+    if (typeof value === 'boolean') {
+      return value;
+    }
+
+    if (typeof value === 'string') {
+      const normalized = value.trim().toLowerCase();
+      if (['false', '0', 'no', 'off'].includes(normalized)) return false;
+      if (['true', '1', 'yes', 'on'].includes(normalized)) return true;
+    }
+
+    if (typeof value === 'number') {
+      return value !== 0;
+    }
+  }
+
+  return true;
+}
+
+function normalizeEntryAsset(asset: unknown): Record<string, unknown> | undefined {
+  if (!asset || typeof asset !== 'object') return undefined;
+
+  const value = asset as Record<string, unknown>;
+  const nestedAsset = value.asset as Record<string, unknown> | undefined;
+  if (!nestedAsset) return value;
+
+  return {
+    ...nestedAsset,
+    role: value.role,
+    position: value.position,
+    metadata: value.metadata ?? value.metadataJson,
+    metadataJson: value.metadataJson ?? nestedAsset.metadataJson,
+  };
+}

package/src/renderers/types.ts

@@ -0,0 +1,71 @@
+import type { MarvinEntry } from '@inneropen/marvin-sdk';
+import type { MarvinEmbeds } from '../embeds.js';
+
+export interface EntryTypeInfo {
+  slug: string;
+  renderer?: string;
+  package?: string;
+  version?: string;
+  config?: Record<string, unknown>;
+  publishable: boolean;
+  submittable: boolean;
+  routable: boolean;
+}
+
+export interface RendererEntry extends MarvinEntry {
+  data: Record<string, unknown>;
+  dataJson?: Record<string, unknown>;
+  contentMarkdown?: string;
+  featuredAsset?: unknown;
+  entryTypeInfo?: EntryTypeInfo;
+  /** Resolved media embeds, keyed by the URL as written (Marvin with media embeds only). */
+  embeds?: MarvinEmbeds;
+}
+
+export type CoreRendererName = 'page' | 'article' | 'faq' | 'navigation';
+
+export interface RendererProps {
+  entry: RendererEntry;
+  config?: Record<string, unknown>;
+  class?: string;
+}
+
+export interface RendererRequirement {
+  key: string;
+  packageName?: string;
+  versionRange?: string;
+  config: Record<string, unknown>;
+}
+
+export interface RendererDefinition<T = unknown> {
+  key: string;
+  component: T;
+  defaultConfig?: Record<string, unknown>;
+  description?: string;
+}
+
+export interface RendererRegistry<T = unknown> {
+  get(name: string, packageName?: string | null): T | undefined;
+  has(name: string, packageName?: string | null): boolean;
+  names(): string[];
+  use?(packageDefinition: RendererPackage<T>): RendererRegistry<T>;
+  register?(definition: RendererDefinition<T>): RendererRegistry<T>;
+  override?(overrides: Record<string, T>): RendererRegistry<T>;
+}
+
+export interface RendererPackage<T = unknown> {
+  packageName: string;
+  version: string;
+  registry: RendererRegistry<T>;
+}
+
+export interface RendererPackageOptions<T = unknown> {
+  packageName: string;
+  version: string;
+  renderers: Record<string, T>;
+}
+
+export interface RendererPackageRegistry<T = unknown> extends RendererRegistry<T> {
+  packages(): RendererPackage<T>[];
+  getPackage(packageName: string): RendererPackage<T> | undefined;
+}

package/src/renderers/validation-types.ts

@@ -0,0 +1,23 @@
+import type { RendererRegistry } from './types.js';
+
+export interface RendererCheckOptions {
+  registry: RendererRegistry | Record<string, unknown>;
+  apiUrl?: string;
+  siteToken?: string;
+  strict?: boolean;
+  ignore?: string[];
+}
+
+export interface MissingRenderer {
+  entryTypeSlug: string;
+  entryTypeName: string;
+  renderer: string;
+  package?: string;
+  version?: string;
+}
+
+export interface ValidationResult {
+  total: number;
+  covered: number;
+  missing: MissingRenderer[];
+}