@lemonadecms/client 0.1.0 → 0.2.0

package/bin/cli/run.mjs

@@ -2,7 +2,13 @@ import { resolve } from 'node:path';
 import { createRequire } from 'node:module';
 const { version } = createRequire(import.meta.url)('../../package.json');
 import { access } from 'node:fs/promises';
-import { parseArgs, connection } from './config.mjs';
+import {
+  parseArgs,
+  connection,
+  typeGenerationEnv,
+  readConfiguration,
+} from './config.mjs';
+import { canPickTarget, pickTarget } from './picker.mjs';
 import { CLIError, fail } from './errors.mjs';
 import { parseJSON, readText, writeOutput, MAX_SCHEMA_BYTES } from './io.mjs';
 import {
@@ -23,7 +29,7 @@ lemonade schema pull --out schema.json [connection options]
 lemonade schema export --out schema.json [connection options]
 lemonade schema validate --file schema.json
 lemonade schema diff --file schema.json [connection options]
-lemonade types generate [--file schema.json | connection options] --out FILE [--language typescript|csharp|python] [--check]
+lemonade types generate [--file schema.json | connection options] [--out FILE] [--language typescript|csharp|python] [--check]
 
 lemonade schema migrate status [--before MIGRATION_ID] [connection options]
 lemonade schema migrate create --baseline current.json --file desired.json --status status.json --id YYYYMMDDHHMMSS_description --out migration.json
@@ -36,9 +42,17 @@ Migration commands require an environment UUID and a separate management credent
 Connection: --config FILE --target NAME, or --url URL --workspace UUID --environment KEY_OR_UUID
 Credential: --credential-env ENV_NAME (default LEMONADE_TOKEN). Never pass a token value.
 Targets live in lemonade.config.json. URL/workspace/environment also accept LEMONADE_* environment variables.
+Types generate: loads cwd/.env (process values win); workspace falls back to CMS_PROJECT_ID,
+environment to CMS_ENVIRONMENT or production, credential to CMS_PUBLIC_KEY when LEMONADE_TOKEN is unset.
+Default output: src/types/cms-models.ts (csharp: cms-models.cs; python: cms_models.py).
+Explicit options, named targets and existing LEMONADE_* settings take precedence. --out is a file path.
+Offline generation and other commands do not load .env. Use the selected environment's credential.
+Interactive types generate offers configured targets (production first) when no connection selection is explicit.
+Use arrows/Enter to choose; Escape/Ctrl+C/EOF cancels without network or output-file writes.
+CI, --json, --check, piped input/output, --file and explicit connection/environment settings never prompt.
 All commands: --json. Informational: --help, --version.
-Exit codes: 0 success, 2 usage/config, 3 drift, 4 connection/auth/context, 5 invalid schema/input, 6 output failure.
-Only schema migrate apply writes compatible schema additions or reviewed missing-draft backfills. No content publication, prompts, automatic retries or credential persistence. Node.js 22+ required.
+Exit codes: 0 success, 2 usage/config, 3 drift, 4 connection/auth/context, 5 invalid schema/input, 6 output failure, 130 selection cancelled.
+Only schema migrate apply writes compatible schema additions or reviewed missing-draft backfills. No content publication, automatic retries or credential persistence. Node.js 22+ required.
 `;
 export async function run(
   args,
@@ -48,6 +62,11 @@ export async function run(
     fetcher = fetch,
     stdout = (text) => process.stdout.write(text),
     stderr = (text) => process.stderr.write(text),
+    terminal = {
+      input: process.stdin,
+      output: process.stderr,
+      stdoutIsTTY: process.stdout.isTTY,
+    },
   } = {},
 ) {
   let opts = {},
@@ -94,7 +113,37 @@ export async function run(
     const inputPath = opts.file && resolve(cwd, opts.file);
     const readSchema = async () => validateSchema(parseJSON(await readText(inputPath)));
     const remote = async () => {
-      const target = await connection(opts, env, cwd);
+      const generation = command === 'types generate';
+      const selectedEnv = generation ? await typeGenerationEnv(env, cwd) : env;
+      const defaults = generation
+        ? {
+            workspace: selectedEnv.CMS_PROJECT_ID,
+            environment: selectedEnv.CMS_ENVIRONMENT || 'production',
+            credentialEnv: Object.hasOwn(selectedEnv, 'LEMONADE_TOKEN')
+              ? 'LEMONADE_TOKEN'
+              : 'CMS_PUBLIC_KEY',
+          }
+        : {};
+      const configuration = await readConfiguration(opts, cwd);
+      let selected = opts;
+      if (
+        generation &&
+        canPickTarget(opts, selectedEnv, terminal) &&
+        Object.keys(configuration.targets).length
+      ) {
+        selected = {
+          ...opts,
+          target: await pickTarget(configuration.targets, terminal),
+        };
+      }
+      const target = await connection(
+        selected,
+        selectedEnv,
+        cwd,
+        false,
+        defaults,
+        configuration,
+      );
       key = target.key;
       return fetchSchema(target, fetcher);
     };
@@ -167,6 +216,7 @@ export async function run(
         await writeOutput(path, output, [
           inputPath,
           resolve(cwd, opts.config || 'lemonade.config.json'),
+          resolve(cwd, '.env'),
         ]);
         result.written = true;
         human = `Types generated successfully (${language}).`;

package/bin/cli/schema.mjs

@@ -73,7 +73,7 @@ function bounded(value) {
   let nodes = 0;
   while (stack.length) {
     const [item, depth] = stack.pop();
-    if (++nodes > 150000 || depth > 16) invalid();
+    if (++nodes > 150000 || depth > 24) invalid();
     if (
       typeof item === 'string' &&
       /(?:pk|sk)_[A-Za-z0-9_-]{43}|lmd_(?:pk|sk|mgmt)_[0-9a-f-]{36}\.[A-Za-z0-9_-]{43}/.test(
@@ -85,7 +85,7 @@ function bounded(value) {
       for (const child of Object.values(item)) stack.push([child, depth + 1]);
   }
 }
-function fields(values, keys, component = false) {
+function fields(values, keys, component = false, ancestors = []) {
   if (
     !Array.isArray(values) ||
     values.length > 24 ||
@@ -135,6 +135,7 @@ function fields(values, keys, component = false) {
         'help_text',
         'validation',
         ...(!component ? ['group'] : []),
+        ...(!component && field.type === 'blocks' ? ['composer'] : []),
         ...extra,
         ...seo,
         ...(field.type === 'text' && !component ? ['slug'] : []),
@@ -155,8 +156,7 @@ function fields(values, keys, component = false) {
           !['text', 'long_text', 'markdown', 'rich_text'].includes(field.type)))
     )
       invalid();
-    if (component && (composed.includes(field.type) || field.localized === true))
-      invalid();
+    if (Object.hasOwn(field, 'composer') && typeof field.composer !== 'boolean') invalid();
     if (Object.hasOwn(field, 'default')) {
       const value = field.default;
       if (field.type === 'choices' && value === null) invalid();
@@ -207,12 +207,12 @@ function fields(values, keys, component = false) {
       for (const definition of field.components) {
         if (
           !own(definition, ['key', 'name', 'fields']) ||
-          !apiKey(definition.key) ||
+          !apiKey(definition.key) || ancestors.includes(definition.key) || ancestors.length >= 3 ||
           !string(definition.name, 80) ||
           !definition.fields?.length
         )
           invalid();
-        fields(definition.fields, keys, true);
+        fields(definition.fields, keys, true, [...ancestors, definition.key]);
       }
     }
   }

package/bin/generate-types.mjs

@@ -18,13 +18,15 @@ export function generateTypes(schema) {
   )
     throw new Error('Invalid schema export.');
   const keys = new Set(schema.models.map((model) => model.key));
-  function type(field) {
+  let fieldNodes = 0;
+  function type(field, ancestors = []) {
+    if (++fieldNodes > 150000) throw new Error('Schema exceeds generation budget.');
     switch (field.type) {
       case 'component':
       case 'components':
       case 'blocks': {
         if (
-          !Array.isArray(field.components) ||
+          ancestors.length >= 3 || !Array.isArray(field.components) ||
           field.components.length < 1 ||
           field.components.length > 12 ||
           (field.type !== 'blocks' && field.components.length !== 1)
@@ -33,19 +35,18 @@ export function generateTypes(schema) {
         const variants = field.components
           .map((component) => {
             if (
-              !identifier.test(component.key) ||
+              !identifier.test(component.key) || ancestors.includes(component.key) ||
               !Array.isArray(component.fields) ||
               component.fields.length < 1 ||
               component.fields.length > 24 ||
               component.fields.some(
                 (child) =>
-                  !identifier.test(child.key) ||
-                  ['component', 'components', 'blocks'].includes(child.type),
+                  !identifier.test(child.key),
               )
             )
               throw new Error('Invalid component fields.');
             const fields = component.fields
-              .map((child) => `${JSON.stringify(child.key)}?: ${type(child)} | null`)
+              .map((child) => `${JSON.stringify(child.key)}?: ${type(child, [...ancestors, component.key])} | null`)
               .join('; ');
             return `{ id: string; type: ${JSON.stringify(component.key)}; fields: { ${fields} } }`;
           })
@@ -130,7 +131,7 @@ export function generateTypes(schema) {
       return [model.key, mappings];
     }),
   );
-  return `// Generated by @lemonadecms/client codegen. Do not edit.\n// Every field allows historical absence/null; previews may be incomplete.\nexport interface ContentReference<Fields> { id: string; fields?: Fields; published_at?: string | null }\nexport interface ContentRendition { key: string; preset: "hero" | "card" | "social"; width: number; height: number; content_type: string; url: string }\nexport interface ContentAsset { id: string; url: string; content_type: string; byte_size: number; metadata: { title?: string; alt?: string; description?: string; focal_point?: { x: number; y: number } }; renditions?: ContentRendition[] }\nexport type RichTextMark = { type: 'bold' | 'italic' | 'underline' | 'strike' | 'code' } | { type: 'link'; attrs: { href: string } };\nexport type RichTextInline = { type: 'text'; text: string; marks?: RichTextMark[] } | { type: 'hardBreak' };\nexport type RichTextEntry<Target extends keyof Models> = { [K in Target]: { type: 'entry'; attrs: { id: string; target: K }; resource?: ContentReference<Models[K]> | null } }[Target];\nexport type RichTextBlock<Target extends keyof Models = keyof Models> = { type: 'paragraph'; content?: RichTextInline[] } | { type: 'heading'; attrs: { level: 2 | 3 | 4 }; content?: RichTextInline[] } | { type: 'bulletList' | 'orderedList'; attrs?: { start: 1 }; content: { type: 'listItem'; content: RichTextBlock<Target>[] }[] } | { type: 'image'; attrs: { id: string; alt: string }; resource?: ContentAsset | null } | RichTextEntry<Target>;\nexport interface ContentRichText<Target extends keyof Models = keyof Models> { version: 1; document: { type: 'doc'; content?: RichTextBlock<Target>[] } }\nexport interface Models {\n${models}\n}\n\n// Presentation roles, refreshed by codegen after schema changes.\nexport const seoModels = ${JSON.stringify(seoModels, null, 2)} as const;\n`;
+  return `// Generated by @lemonadecms/client codegen. Do not edit.\n// Every field allows historical absence/null; previews may be incomplete.\nexport interface ContentReference<Fields> { id: string; fields?: Fields; published_at?: string | null; content_type?: { id: string; key: string; name: string }; project_id?: string; environment?: { id: string; key: string }; locale?: string }\nexport interface ContentRendition { key: string; preset: "hero" | "card" | "social"; width: number; height: number; content_type: string; url: string }\nexport interface ContentAsset { id: string; url: string; content_type: string; byte_size: number; metadata: { title?: string; alt?: string; description?: string; focal_point?: { x: number; y: number } }; renditions?: ContentRendition[] }\nexport type RichTextMark = { type: 'bold' | 'italic' | 'underline' | 'strike' | 'code' } | { type: 'link'; attrs: { href: string } };\nexport type RichTextInline = { type: 'text'; text: string; marks?: RichTextMark[] } | { type: 'hardBreak' };\nexport type RichTextEntry<Target extends keyof Models> = { [K in Target]: { type: 'entry'; attrs: { id: string; target: K }; resource?: ContentReference<Models[K]> | null } }[Target];\nexport type RichTextBlock<Target extends keyof Models = keyof Models> = { type: 'paragraph'; content?: RichTextInline[] } | { type: 'heading'; attrs: { level: 2 | 3 | 4 }; content?: RichTextInline[] } | { type: 'bulletList' | 'orderedList'; attrs?: { start: 1 }; content: { type: 'listItem'; content: RichTextBlock<Target>[] }[] } | { type: 'image'; attrs: { id: string; alt: string }; resource?: ContentAsset | null } | RichTextEntry<Target>;\nexport interface ContentRichText<Target extends keyof Models = keyof Models> { version: 1; document: { type: 'doc'; content?: RichTextBlock<Target>[] } }\nexport interface Models {\n${models}\n}\n\n// Presentation roles, refreshed by codegen after schema changes.\nexport const seoModels = ${JSON.stringify(seoModels, null, 2)} as const;\n`;
 }
 async function main() {
   const args = process.argv.slice(2);
@@ -146,7 +147,7 @@ async function main() {
       throw new Error('Use --help for codegen options.');
     options[args[i].slice(2)] = args[i + 1];
   }
-  const url = new URL(options.url || process.env.CMS_URL || 'https://lemonadecms.com');
+  const url = new URL(options.url || process.env.CMS_URL || 'https://api.lemonadecms.com');
   if (
     !['http:', 'https:'].includes(url.protocol) ||
     url.username ||

package/dist/composer.d.ts

@@ -0,0 +1,27 @@
+/** Optional browser-only Composer bridge. Website code owns rendering.
+ * Enable only on an authenticated preview. No credentials or framework imports.
+ */
+export interface ComposerUpdate {
+    channel: string;
+    entry: string;
+    locale: string;
+    root: string;
+    fields: Record<string, unknown>;
+    model_version: number;
+    entry_version: number;
+    renderer_revision: string;
+}
+export interface VisualComposerOptions {
+    studioOrigin: string;
+    channel: string;
+    entry: string;
+    locale: string;
+    roots: readonly string[];
+    components: readonly string[];
+    rendererRevision: string;
+    root?: HTMLElement;
+    /** Return a synchronous commit function; the bridge calls it only for the
+     * latest successful render. Honor signal and keep DOM changes in commit. */
+    render: (update: ComposerUpdate, signal: AbortSignal) => Promise<() => void>;
+}
+export declare function enableVisualComposer(options: VisualComposerOptions): () => void;

package/dist/composer.js

@@ -0,0 +1,240 @@
+export function enableVisualComposer(options) {
+    const keyPattern = /^[a-z][a-z0-9_]{0,47}$/;
+    const idPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    const { studioOrigin, channel, entry, locale, roots, components, rendererRevision } = options;
+    let origin;
+    try {
+        origin = new URL(studioOrigin);
+    }
+    catch {
+        return () => { };
+    }
+    if (origin.origin !== studioOrigin || !['http:', 'https:'].includes(origin.protocol) ||
+        window.parent === window || !idPattern.test(channel) || !idPattern.test(entry) ||
+        !/^[a-zA-Z0-9-]{2,20}$/.test(locale) || !/^[a-f0-9]{64}$/.test(rendererRevision) ||
+        roots.length < 1 || roots.length > 24 || components.length < 1 || components.length > 128 ||
+        ![...roots, ...components].every(key => keyPattern.test(key)) || typeof options.render !== 'function') {
+        return () => { };
+    }
+    const root = options.root ?? document.body;
+    let active = true;
+    let enabled = false;
+    let selectedRoot = '';
+    let generation = '';
+    let latest = 0;
+    let busy = false;
+    let pending;
+    let controller;
+    const originals = new Map();
+    const send = (type, extra = {}) => window.parent.postMessage({ type, version: 1, channel, entry, locale, root: selectedRoot, ...extra }, studioOrigin);
+    const announce = (request) => send('lemonade:composer-ready', {
+        roots: [...roots], components: [...components], renderer_revision: rendererRevision,
+        ...(request ? { request } : {}),
+    });
+    const restore = () => {
+        for (const [element, attrs] of originals)
+            for (const [name, value] of attrs) {
+                if (value === null)
+                    element.removeAttribute(name);
+                else
+                    element.setAttribute(name, value);
+            }
+        originals.clear();
+    };
+    const enhance = () => {
+        restore();
+        if (!enabled)
+            return;
+        for (const element of Array.from(root.querySelectorAll('[data-lemonade-block]')).slice(0, 100)) {
+            const id = element.dataset.lemonadeBlock ?? '';
+            if (!idPattern.test(id))
+                continue;
+            const attrs = new Map();
+            for (const name of ['tabindex', 'role', 'aria-label', 'draggable', 'style'])
+                attrs.set(name, element.getAttribute(name));
+            originals.set(element, attrs);
+            if (!element.matches('a[href],button,input,textarea,select'))
+                element.setAttribute('role', 'button');
+            element.tabIndex = 0;
+            element.setAttribute('aria-label', `Edit ${element.dataset.lemonadeName ?? 'section'} in Studio`);
+            element.draggable = true;
+            element.style.outline = '1px dashed currentColor';
+            element.style.outlineOffset = '3px';
+        }
+    };
+    const run = async () => {
+        if (!active || !enabled || busy || !pending)
+            return;
+        const work = pending;
+        pending = undefined;
+        busy = true;
+        const abort = new AbortController();
+        controller = abort;
+        let timeout;
+        try {
+            const commit = await Promise.race([
+                options.render(work.update, abort.signal),
+                new Promise((_, reject) => { timeout = setTimeout(() => { abort.abort(); reject(new Error('Composer render timed out')); }, 10000); }),
+            ]);
+            if (active && enabled && !abort.signal.aborted && work.sequence === latest && work.generation === generation) {
+                if (typeof commit !== 'function')
+                    throw new Error('Composer renderer must return a commit function');
+                commit();
+                enhance();
+                send('lemonade:composer-rendered', { sequence: work.sequence, generation });
+            }
+        }
+        catch {
+            if (active && enabled && work.sequence === latest && work.generation === generation) {
+                send('lemonade:composer-error', { sequence: work.sequence, generation });
+            }
+        }
+        finally {
+            clearTimeout(timeout);
+            if (controller === abort)
+                controller = undefined;
+            busy = false;
+            void run();
+        }
+    };
+    const disable = () => {
+        enabled = false;
+        pending = undefined;
+        controller?.abort();
+        restore();
+    };
+    const receive = (event) => {
+        if (!active || event.source !== window.parent || event.origin !== studioOrigin || event.data?.channel !== channel)
+            return;
+        const data = event.data;
+        if (data.type === 'lemonade:preview-connect') {
+            if (typeof data.request === 'string' && data.request.length <= 64)
+                announce(data.request);
+            return;
+        }
+        if (data.version !== 1 || data.entry !== entry || data.locale !== locale)
+            return;
+        if (data.type === 'lemonade:composer-disable') {
+            disable();
+            return;
+        }
+        if (data.type === 'lemonade:composer-enable') {
+            if (!roots.includes(data.root) || typeof data.generation !== 'string' || data.generation.length > 64)
+                return;
+            if (generation !== data.generation) {
+                controller?.abort();
+                pending = undefined;
+                latest = 0;
+            }
+            enabled = true;
+            generation = data.generation;
+            selectedRoot = data.root;
+            enhance();
+            return;
+        }
+        if (!enabled || data.generation !== generation || data.root !== selectedRoot)
+            return;
+        if (data.type === 'lemonade:composer-highlight' && idPattern.test(data.id)) {
+            for (const element of originals.keys()) {
+                element.style.outlineWidth = element.dataset.lemonadeBlock === data.id ? '3px' : '1px';
+            }
+            return;
+        }
+        if (data.type === 'lemonade:composer-drop') {
+            if (!Number.isFinite(data.x) || !Number.isFinite(data.y) || data.x < 0 || data.y < 0 ||
+                data.x >= window.innerWidth || data.y >= window.innerHeight)
+                return;
+            const element = document.elementFromPoint(data.x, data.y);
+            if (element)
+                emitDrop(element, data.payload);
+            return;
+        }
+        if (data.type !== 'lemonade:composer-update' || !Number.isSafeInteger(data.sequence) || data.sequence <= latest ||
+            !data.fields || typeof data.fields !== 'object' || Array.isArray(data.fields) ||
+            data.renderer_revision !== rendererRevision || !Number.isSafeInteger(data.model_version) || !Number.isSafeInteger(data.entry_version))
+            return;
+        try {
+            if (new TextEncoder().encode(JSON.stringify(data.fields)).length > 65536)
+                return;
+        }
+        catch {
+            return;
+        }
+        latest = data.sequence;
+        pending = { update: { channel, entry, locale, root: selectedRoot, fields: data.fields,
+                model_version: data.model_version, entry_version: data.entry_version, renderer_revision: rendererRevision }, sequence: latest, generation };
+        controller?.abort();
+        void run();
+    };
+    const select = (event) => {
+        if (!enabled || !(event.target instanceof Element))
+            return;
+        if (event instanceof KeyboardEvent && !['Enter', ' '].includes(event.key))
+            return;
+        if (event instanceof MouseEvent && (event.button !== 0 || event.metaKey || event.ctrlKey || event.altKey || event.shiftKey))
+            return;
+        const element = event.target.closest('[data-lemonade-block]');
+        if (!element || !originals.has(element))
+            return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        send('lemonade:composer-select', { id: element.dataset.lemonadeBlock, root: selectedRoot, generation });
+    };
+    const dragstart = (event) => {
+        if (!enabled || !(event.target instanceof Element))
+            return;
+        const element = event.target.closest('[data-lemonade-block]');
+        if (!element || !originals.has(element))
+            return;
+        event.dataTransfer?.setData('application/x-lemonade-composer', JSON.stringify({ id: element.dataset.lemonadeBlock, channel, root: selectedRoot }));
+    };
+    const dragover = (event) => {
+        if (enabled && event.target instanceof Element && event.target.closest('[data-lemonade-slot]'))
+            event.preventDefault();
+    };
+    const emitDrop = (element, data) => {
+        const slot = element.closest('[data-lemonade-slot]');
+        const path = slot?.dataset.lemonadeSlot;
+        if (!slot || !path || path.length > 512 || !root.contains(slot) || !data ||
+            !(idPattern.test(data.id ?? '') || keyPattern.test(data.component ?? '')))
+            return;
+        if (path !== selectedRoot && !path.startsWith(selectedRoot + '.'))
+            return;
+        const block = element.closest('[data-lemonade-block]');
+        send('lemonade:composer-action', { action: data.id ? 'move' : 'add', id: data.id, component: data.component,
+            target: path, before: block?.dataset.lemonadeBlock, root: selectedRoot, generation });
+    };
+    const drop = (event) => {
+        if (!enabled || !(event.target instanceof Element))
+            return;
+        try {
+            const raw = event.dataTransfer?.getData('application/x-lemonade-composer') ?? '';
+            if (raw.length > 1024)
+                return;
+            const data = JSON.parse(raw);
+            if (data.channel !== channel || data.root !== selectedRoot)
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+            emitDrop(event.target, data);
+        }
+        catch { /* Foreign drag payloads are not composition commands. */ }
+    };
+    window.addEventListener('message', receive);
+    root.addEventListener('click', select, true);
+    root.addEventListener('keydown', select, true);
+    root.addEventListener('dragstart', dragstart);
+    root.addEventListener('dragover', dragover);
+    root.addEventListener('drop', drop);
+    announce();
+    return () => {
+        active = false;
+        disable();
+        window.removeEventListener('message', receive);
+        root.removeEventListener('click', select, true);
+        root.removeEventListener('keydown', select, true);
+        root.removeEventListener('dragstart', dragstart);
+        root.removeEventListener('dragover', dragover);
+        root.removeEventListener('drop', drop);
+    };
+}

package/dist/errors.d.ts

@@ -10,6 +10,12 @@ export declare class CMSRequestError extends Error {
 export declare class CMSResponseError extends Error {
     readonly name = "CMSResponseError";
 }
+/** A successful findOneOrThrow query had no matching entry. */
+export declare class CMSNotFoundError extends Error {
+    readonly model: string;
+    readonly name = "CMSNotFoundError";
+    constructor(model: string);
+}
 /** The configured request deadline expired, including response-body reading. */
 export declare class CMSTimeoutError extends Error {
     readonly timeoutMs: number;

package/dist/errors.js

@@ -19,6 +19,15 @@ export class CMSRequestError extends Error {
 export class CMSResponseError extends Error {
     name = "CMSResponseError";
 }
+/** A successful findOneOrThrow query had no matching entry. */
+export class CMSNotFoundError extends Error {
+    model;
+    name = "CMSNotFoundError";
+    constructor(model) {
+        super("No content entry matched the query.");
+        this.model = model;
+    }
+}
 /** The configured request deadline expired, including response-body reading. */
 export class CMSTimeoutError extends Error {
     timeoutMs;

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 import type { CMSClient, CMSClientOptions, ModelMap, UntypedModels } from "./types.js";
 export * from "./errors.js";
 export type { RemoteValue } from "./types.js";
-export type { CMSClient, CMSClientOptions, ContentCollection, ContentEntry, ContentPage, ListOptions, PaginationOptions, ContentFilter, ContentSort } from "./types.js";
+export type { CountOptions, GetManyOptions, ContentSearch, SearchOptions, TextField } from "./types.js";
+export type { CMSClient, CMSClientOptions, ContentCollection, ContentEntry, ContentPage, ContentTypeIdentity, ContentEnvironment, ListOptions, FindOneOptions, PaginationOptions, ContentFilter, ContentSort } from "./types.js";
 /** Published content only. Framework environment variables must be passed explicitly. */
 export declare function createCMSClient<Models extends ModelMap<Models> = UntypedModels>(options: CMSClientOptions): CMSClient<Models>;
 export { imageSrcSet } from "./images.js";
 export type { ContentRendition } from "./images.js";
+export { richTextToHtml, richTextToPlainText } from "./rich-text.js";

package/dist/index.js

@@ -14,3 +14,4 @@ export function createCMSClient(options) {
     return createTransport(options, options?.publicKey, "content");
 }
 export { imageSrcSet } from "./images.js";
+export { richTextToHtml, richTextToPlainText } from "./rich-text.js";

package/dist/rich-text.d.ts

@@ -0,0 +1,4 @@
+/** Escaped HTML for rich-text v1, including safe expanded images/entry captions. */
+export declare function richTextToHtml(value: unknown): string;
+/** Authored text with block/hard-break newlines; excludes embeds and link URLs. */
+export declare function richTextToPlainText(value: unknown): string;