@gradial/aci 0.1.20-preview.3 → 0.1.21

package/dist/types/image.d.ts

@@ -1,23 +1,25 @@
 import { z } from 'zod';
 export interface ImageSource {
+    /** Derivative URL. */
     src: string;
+    /** Intrinsic width in pixels. */
     width: number;
+    /** Intrinsic height in pixels. */
     height: number;
+    /** MIME type hint, e.g. image/webp. */
     type: string;
 }
-export interface PictureSource {
-    media?: string;
-    type: string;
-    srcset: string;
-    sizes?: string;
-}
-export interface GradialImage {
+export interface Image {
+    /** Discriminator — always 'gradial.image'. */
     $type: 'gradial.image';
+    /** DAM asset identifier. */
     assetId: string;
+    /** DAM version identifier. */
     versionId: string;
+    /** Accessible description of the image content. */
     alt: string;
-    fallback: ImageSource;
-    sources: PictureSource[] | null;
+    /** Responsive derivative variants produced for the asset slot. */
+    sources: ImageSource[];
 }
 export interface ImageSlotContract {
     outputs: SlotOutput[];
@@ -29,23 +31,34 @@ export interface SlotOutput {
     widths: number[];
     media?: string;
 }
-export declare const GradialImageSchema: z.ZodObject<{
+export declare const ImageSourceSchema: z.ZodObject<{
+    src: z.ZodString;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    type: z.ZodString;
+}, z.core.$strip>;
+export declare const ImageSchema: z.ZodObject<{
     $type: z.ZodLiteral<"gradial.image">;
     assetId: z.ZodString;
     versionId: z.ZodString;
     alt: z.ZodString;
-    fallback: z.ZodObject<{
+    sources: z.ZodArray<z.ZodObject<{
         src: z.ZodString;
         width: z.ZodNumber;
         height: z.ZodNumber;
         type: z.ZodString;
-    }, z.core.$strip>;
-    sources: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodObject<{
-        media: z.ZodOptional<z.ZodString>;
-        type: z.ZodString;
-        srcset: z.ZodString;
-        sizes: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
-export type ImageHTMLAttributes = Record<string, string | number | boolean | undefined | null>;
-export declare function renderImageHTML(image: GradialImage, attrs?: ImageHTMLAttributes): string;
+export type ImageAttrs = Record<string, unknown>;
+/**
+ * Picks the primary variant from an image's sources.
+ * Uses the largest width; ties fall back to the first entry.
+ */
+export declare function primaryImageSource(image: Image): ImageSource;
+/**
+ * Computes the full set of <img> attributes for an Image.
+ *
+ * Framework components (React <Picture>, Astro <img>, Svelte <img>) call this
+ * and spread the result into their native element.  No HTML string serialization.
+ */
+export declare function imageAttrs(image: Image, overrides?: ImageAttrs): ImageAttrs;

package/dist/types/image.js

@@ -1,58 +1,50 @@
 import { z } from 'zod';
-export const GradialImageSchema = z.object({
+// ---------------------------------------------------------------------------
+// Zod schema
+// ---------------------------------------------------------------------------
+export const ImageSourceSchema = z.object({
+    src: z.string().min(1),
+    width: z.number().int().nonnegative(),
+    height: z.number().int().nonnegative(),
+    type: z.string().min(1),
+});
+export const ImageSchema = z.object({
     $type: z.literal('gradial.image'),
     assetId: z.string().min(1),
     versionId: z.string().min(1),
     alt: z.string(),
-    fallback: z.object({
-        src: z.string().min(1),
-        width: z.number().int().nonnegative(),
-        height: z.number().int().nonnegative(),
-        type: z.string().min(1),
-    }),
-    sources: z.array(z.object({
-        media: z.string().optional(),
-        type: z.string().min(1),
-        srcset: z.string().min(1),
-        sizes: z.string().optional(),
-    })).nullable().default([]),
+    sources: z.array(ImageSourceSchema).min(1),
 });
-export function renderImageHTML(image, attrs = {}) {
-    const imgAttrs = renderAttrs({
-        ...attrs,
-        src: image.fallback.src,
-        alt: image.alt,
-        width: image.fallback.width > 0 ? image.fallback.width : undefined,
-        height: image.fallback.height > 0 ? image.fallback.height : undefined,
-    });
-    const img = `<img${imgAttrs}>`;
-    if (!image.sources?.length) {
-        return img;
-    }
-    const sources = image.sources.map((source) => `<source${renderAttrs({
-        media: source.media,
-        type: source.type,
-        srcset: source.srcset,
-        sizes: source.sizes,
-    })}>`).join('');
-    return `<picture>${sources}${img}</picture>`;
-}
-function renderAttrs(attrs) {
-    const rendered = Object.entries(attrs)
-        .filter(([, value]) => value !== undefined && value !== null && value !== false)
-        .map(([name, value]) => value === true ? escapeName(name) : `${escapeName(name)}="${escapeAttr(String(value))}"`);
-    if (!rendered.length) {
-        return '';
-    }
-    return ' ' + rendered.join(' ');
+/**
+ * Picks the primary variant from an image's sources.
+ * Uses the largest width; ties fall back to the first entry.
+ */
+export function primaryImageSource(image) {
+    return image.sources.reduce((largest, source) => source.width > largest.width ? source : largest, image.sources[0]);
 }
-function escapeName(name) {
-    return name.replace(/[^A-Za-z0-9_:-]/g, '');
-}
-function escapeAttr(value) {
-    return value
-        .replace(/&/g, '&amp;')
-        .replace(/"/g, '&quot;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;');
+/**
+ * Computes the full set of <img> attributes for an Image.
+ *
+ * Framework components (React <Picture>, Astro <img>, Svelte <img>) call this
+ * and spread the result into their native element.  No HTML string serialization.
+ */
+export function imageAttrs(image, overrides = {}) {
+    const primary = primaryImageSource(image);
+    const srcset = image.sources
+        .map((s) => `${s.src} ${s.width}w`)
+        .join(', ');
+    const sizes = image.sources
+        .map((s) => `(max-width: ${s.width}px) ${s.width}px`)
+        .join(', ');
+    return {
+        src: primary.src,
+        alt: image.alt,
+        width: primary.width > 0 ? primary.width : undefined,
+        height: primary.height > 0 ? primary.height : undefined,
+        srcSet: srcset || undefined,
+        sizes: sizes || undefined,
+        loading: 'lazy',
+        decoding: 'async',
+        ...overrides,
+    };
 }

package/dist/types/index.d.ts

@@ -3,6 +3,7 @@ export * from './component.js';
 export * from './data.js';
 export * from './layout.js';
 export * from './page.js';
+export * from './rich-text.js';
 export * from './renderer.js';
 export * from './render-mode.js';
 export * from './image.js';

package/dist/types/index.js

@@ -3,6 +3,7 @@ export * from './component.js';
 export * from './data.js';
 export * from './layout.js';
 export * from './page.js';
+export * from './rich-text.js';
 export * from './renderer.js';
 export * from './render-mode.js';
 export * from './image.js';

package/dist/types/link.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export type LinkTarget = '_self' | '_blank' | '_parent' | '_top';
+export interface Link {
+    href: string;
+    target?: LinkTarget;
+    title?: string;
+    rel?: string;
+}
+export declare const LinkSchema: z.ZodObject<{
+    href: z.ZodString;
+    target: z.ZodOptional<z.ZodEnum<{
+        _self: "_self";
+        _blank: "_blank";
+        _parent: "_parent";
+        _top: "_top";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    rel: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export interface LinkResolverContext {
+    /** Resolved path for an aci:page:{slug} reference, if found. */
+    resolvePageSlug?: (slug: string) => string | undefined;
+}
+export declare function resolveLink(reference: string | Link, ctx?: LinkResolverContext): Link;
+/**
+ * Resolve a Link object to its final href string.
+ * An optional resolver can perform async or domain-specific resolution.
+ */
+export declare function resolveHref(link: Link, resolver?: (link: Link) => string | Promise<string>): string | Promise<string>;
+/**
+ * Throw if the href uses an unsafe protocol (javascript:, data:, vbscript:).
+ */
+export declare function assertSafeHref(href: string): void;
+/**
+ * Normalize the rel attribute for a Link.
+ * Adds noopener noreferrer for target="_blank" automatically.
+ */
+export declare function normalizeLinkRel(link: Link): string | undefined;

package/dist/types/link.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+// ---------------------------------------------------------------------------
+// Zod schema
+// ---------------------------------------------------------------------------
+export const LinkSchema = z.object({
+    href: z.string().min(1),
+    target: z.enum(['_self', '_blank', '_parent', '_top']).optional(),
+    title: z.string().optional(),
+    rel: z.string().optional(),
+});
+export function resolveLink(reference, ctx = {}) {
+    if (typeof reference !== 'string')
+        return reference;
+    if (reference.startsWith('aci:external:')) {
+        return { href: reference.slice('aci:external:'.length), target: '_blank' };
+    }
+    if (reference.startsWith('aci:page:')) {
+        const slug = reference.slice('aci:page:'.length);
+        const path = ctx.resolvePageSlug?.(slug);
+        return { href: path ?? `/${slug}` };
+    }
+    return { href: reference };
+}
+/**
+ * Resolve a Link object to its final href string.
+ * An optional resolver can perform async or domain-specific resolution.
+ */
+export function resolveHref(link, resolver) {
+    if (resolver) {
+        return resolver(link);
+    }
+    return link.href;
+}
+// ---------------------------------------------------------------------------
+// Shared helpers — consumed by React, Astro, and Svelte components
+// ---------------------------------------------------------------------------
+/**
+ * Throw if the href uses an unsafe protocol (javascript:, data:, vbscript:).
+ */
+export function assertSafeHref(href) {
+    const protocol = href.split(':')[0].toLowerCase();
+    if (protocol === 'javascript' || protocol === 'data' || protocol === 'vbscript') {
+        throw new Error(`unsafe Link protocol: ${protocol}`);
+    }
+}
+/**
+ * Normalize the rel attribute for a Link.
+ * Adds noopener noreferrer for target="_blank" automatically.
+ */
+export function normalizeLinkRel(link) {
+    if (link.target !== '_blank') {
+        return link.rel;
+    }
+    const rel = new Set((link.rel ?? '').split(/\s+/).filter(Boolean));
+    rel.add('noopener');
+    rel.add('noreferrer');
+    return [...rel].join(' ');
+}

package/dist/types/media.d.ts

@@ -1,25 +1,20 @@
 import { z } from 'zod';
-import { type GradialImage } from './image.js';
-import { type GradialVideo } from './video.js';
+import { type Image } from './image.js';
+import { type Video } from './video.js';
 /** Discriminated union of all compiler-resolved asset types. */
-export type GradialAsset = GradialImage | GradialVideo;
-export declare const GradialAssetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export type Asset = Image | Video;
+/** Zod schema for a resolved asset value. */
+export declare const AssetSchema: z.ZodUnion<readonly [z.ZodObject<{
     $type: z.ZodLiteral<"gradial.image">;
     assetId: z.ZodString;
     versionId: z.ZodString;
     alt: z.ZodString;
-    fallback: z.ZodObject<{
+    sources: z.ZodArray<z.ZodObject<{
         src: z.ZodString;
         width: z.ZodNumber;
         height: z.ZodNumber;
         type: z.ZodString;
-    }, z.core.$strip>;
-    sources: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodObject<{
-        media: z.ZodOptional<z.ZodString>;
-        type: z.ZodString;
-        srcset: z.ZodString;
-        sizes: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     $type: z.ZodLiteral<"gradial.video">;
     assetId: z.ZodString;
@@ -34,36 +29,22 @@ export declare const GradialAssetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         assetId: z.ZodString;
         versionId: z.ZodString;
         alt: z.ZodString;
-        fallback: z.ZodObject<{
+        sources: z.ZodArray<z.ZodObject<{
             src: z.ZodString;
             width: z.ZodNumber;
             height: z.ZodNumber;
             type: z.ZodString;
-        }, z.core.$strip>;
-        sources: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodObject<{
-            media: z.ZodOptional<z.ZodString>;
-            type: z.ZodString;
-            srcset: z.ZodString;
-            sizes: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
         src: z.ZodString;
         type: z.ZodString;
     }, z.core.$strip>>>;
     duration: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>], "$type">;
-export declare function isGradialImage(value: unknown): value is GradialImage;
-export declare function isGradialVideo(value: unknown): value is GradialVideo;
-export declare function isGradialAsset(value: unknown): value is GradialAsset;
-/**
- * Renders a GradialVideo to an HTML string.
- * Uses poster.fallback.src for the poster attribute.
- * Includes <source> elements for format variants.
- */
-export declare function renderVideoHTML(video: GradialVideo, attrs?: Record<string, string | number | boolean | undefined | null>): string;
-/**
- * Renders any GradialAsset to an HTML string.
- * Delegates to renderImageHTML or renderVideoHTML based on $type.
- */
-export declare function renderAssetHTML(asset: GradialAsset, attrs?: Record<string, string | number | boolean | undefined | null>): string;
+}, z.core.$strip>]>;
+/** Runtime guard: value is a resolved asset. */
+export declare function isAsset(value: unknown): value is Asset;
+/** Runtime guard: value is a resolved image asset. */
+export declare function isImage(value: unknown): value is Image;
+/** Runtime guard: value is a resolved video asset. */
+export declare function isVideo(value: unknown): value is Video;

package/dist/types/media.js

@@ -1,86 +1,17 @@
 import { z } from 'zod';
-import { GradialImageSchema, renderImageHTML } from './image.js';
-import { GradialVideoSchema } from './video.js';
-// ---------------------------------------------------------------------------
-// Zod schema — discriminated on $type
-// ---------------------------------------------------------------------------
-export const GradialAssetSchema = z.discriminatedUnion('$type', [
-    GradialImageSchema,
-    GradialVideoSchema,
-]);
-// ---------------------------------------------------------------------------
-// Type guards
-// ---------------------------------------------------------------------------
-export function isGradialImage(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        value.$type === 'gradial.image');
-}
-export function isGradialVideo(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        value.$type === 'gradial.video');
-}
-export function isGradialAsset(value) {
-    return isGradialImage(value) || isGradialVideo(value);
-}
-// ---------------------------------------------------------------------------
-// HTML string renderers (framework-agnostic)
-// ---------------------------------------------------------------------------
-/**
- * Renders a GradialVideo to an HTML string.
- * Uses poster.fallback.src for the poster attribute.
- * Includes <source> elements for format variants.
- */
-export function renderVideoHTML(video, attrs = {}) {
-    const posterSrc = video.poster?.fallback.src;
-    const attrPairs = [
-        ...Object.entries(attrs),
-        ['src', video.sources?.length ? undefined : video.src],
-        ['poster', posterSrc],
-        ['width', video.width > 0 ? video.width : undefined],
-        ['height', video.height > 0 ? video.height : undefined],
-    ];
-    const attrString = renderAttrs(attrPairs);
-    const sources = (video.sources ?? [])
-        .map((s) => `<source${renderAttrs([['src', s.src], ['type', s.type]])}>`)
-        .join('');
-    // If no format variants, src is on the <video> element itself
-    if (!sources) {
-        return `<video${attrString}></video>`;
-    }
-    return `<video${attrString}>${sources}</video>`;
-}
-/**
- * Renders any GradialAsset to an HTML string.
- * Delegates to renderImageHTML or renderVideoHTML based on $type.
- */
-export function renderAssetHTML(asset, attrs = {}) {
-    if (asset.$type === 'gradial.image') {
-        return renderImageHTML(asset, attrs);
-    }
-    return renderVideoHTML(asset, attrs);
-}
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-function renderAttrs(pairs) {
-    const rendered = pairs
-        .filter(([, value]) => value !== undefined && value !== null && value !== false)
-        .map(([name, value]) => value === true
-        ? escapeName(name)
-        : `${escapeName(name)}="${escapeAttr(String(value))}"`);
-    if (!rendered.length)
-        return '';
-    return ' ' + rendered.join(' ');
-}
-function escapeName(name) {
-    return name.replace(/[^A-Za-z0-9_:-]/g, '');
-}
-function escapeAttr(value) {
-    return value
-        .replace(/&/g, '&amp;')
-        .replace(/"/g, '&quot;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;');
+import { ImageSchema } from './image.js';
+import { VideoSchema } from './video.js';
+/** Zod schema for a resolved asset value. */
+export const AssetSchema = z.union([ImageSchema, VideoSchema]);
+/** Runtime guard: value is a resolved asset. */
+export function isAsset(value) {
+    return ImageSchema.safeParse(value).success || VideoSchema.safeParse(value).success;
+}
+/** Runtime guard: value is a resolved image asset. */
+export function isImage(value) {
+    return ImageSchema.safeParse(value).success;
+}
+/** Runtime guard: value is a resolved video asset. */
+export function isVideo(value) {
+    return VideoSchema.safeParse(value).success;
 }

package/dist/types/renderer.d.ts

@@ -7,7 +7,7 @@ export interface RenderCapabilities {
     clientIslands: boolean;
     fragmentRender: boolean;
 }
-export interface GradialRenderer {
+export interface Renderer {
     renderPage(request: RenderPageRequest): Promise<RenderPageResult>;
     renderFragment?(request: RenderFragmentRequest): Promise<RenderResult>;
     renderIsland?(request: RenderIslandRequest): Promise<RenderResult>;

package/dist/types/rich-text.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export type InlineContent = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'span';
+    content: InlineContent[];
+    variant?: string;
+} | {
+    type: 'strong';
+    content: InlineContent[];
+} | {
+    type: 'em';
+    content: InlineContent[];
+} | {
+    type: 'link';
+    href: string;
+    content: InlineContent[];
+};
+export type Heading = {
+    type: 'heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    content: InlineContent[];
+    variant?: string;
+};
+export type RichTextValue = {
+    format: 'html';
+    html: string;
+} | {
+    format: 'markdown';
+    markdown: string;
+};
+export declare const InlineContentSchema: z.ZodType<InlineContent>;
+export declare const HeadingSchema: z.ZodObject<{
+    type: z.ZodLiteral<"heading">;
+    level: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
+    content: z.ZodArray<z.ZodType<InlineContent, unknown, z.core.$ZodTypeInternals<InlineContent, unknown>>>;
+    variant: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const RichTextValueSchema: z.ZodType<RichTextValue>;

package/dist/types/rich-text.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export const InlineContentSchema = z.lazy(() => z.object({
+    type: z.literal('text'),
+    text: z.string(),
+}).or(z.object({
+    type: z.literal('span'),
+    content: z.array(InlineContentSchema),
+    variant: z.string().optional(),
+})).or(z.object({
+    type: z.literal('strong'),
+    content: z.array(InlineContentSchema),
+})).or(z.object({
+    type: z.literal('em'),
+    content: z.array(InlineContentSchema),
+})).or(z.object({
+    type: z.literal('link'),
+    href: z.string().min(1),
+    content: z.array(InlineContentSchema),
+})));
+export const HeadingSchema = z.object({
+    type: z.literal('heading'),
+    level: z.union([
+        z.literal(1),
+        z.literal(2),
+        z.literal(3),
+        z.literal(4),
+        z.literal(5),
+        z.literal(6),
+    ]),
+    content: z.array(InlineContentSchema),
+    variant: z.string().optional(),
+});
+export const RichTextValueSchema = z.object({
+    format: z.literal('html'),
+    html: z.string(),
+}).or(z.object({
+    format: z.literal('markdown'),
+    markdown: z.string(),
+}));

package/dist/types/video.d.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
-import { type GradialImage } from './image.js';
+import { type Image } from './image.js';
 export interface VideoSource {
     src: string;
     type: string;
 }
-export interface GradialVideo {
+export interface Video {
     /** Discriminator — always 'gradial.video'. */
     $type: 'gradial.video';
     /** DAM asset identifier. */
@@ -22,10 +22,10 @@ export interface GradialVideo {
     /** Intrinsic height in pixels. */
     height: number;
     /**
-     * Poster frame — a full GradialImage with responsive srcset.
+     * Poster frame — a full Image with responsive srcset.
      * The compiler extracts or generates this from the video asset.
      */
-    poster?: GradialImage;
+    poster?: Image;
     /** Format variants (e.g. mp4 + webm). Maps to <video><source> elements. */
     sources?: VideoSource[];
     /** Duration in seconds (if known). */
@@ -35,7 +35,7 @@ export declare const VideoSourceSchema: z.ZodObject<{
     src: z.ZodString;
     type: z.ZodString;
 }, z.core.$strip>;
-export declare const GradialVideoSchema: z.ZodObject<{
+export declare const VideoSchema: z.ZodObject<{
     $type: z.ZodLiteral<"gradial.video">;
     assetId: z.ZodString;
     versionId: z.ZodString;
@@ -49,18 +49,12 @@ export declare const GradialVideoSchema: z.ZodObject<{
         assetId: z.ZodString;
         versionId: z.ZodString;
         alt: z.ZodString;
-        fallback: z.ZodObject<{
+        sources: z.ZodArray<z.ZodObject<{
             src: z.ZodString;
             width: z.ZodNumber;
             height: z.ZodNumber;
             type: z.ZodString;
-        }, z.core.$strip>;
-        sources: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodObject<{
-            media: z.ZodOptional<z.ZodString>;
-            type: z.ZodString;
-            srcset: z.ZodString;
-            sizes: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
         src: z.ZodString;

package/dist/types/video.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { GradialImageSchema } from './image.js';
+import { ImageSchema } from './image.js';
 // ---------------------------------------------------------------------------
 // Zod schema
 // ---------------------------------------------------------------------------
@@ -7,7 +7,7 @@ export const VideoSourceSchema = z.object({
     src: z.string().min(1),
     type: z.string().min(1),
 });
-export const GradialVideoSchema = z.object({
+export const VideoSchema = z.object({
     $type: z.literal('gradial.video'),
     assetId: z.string().min(1),
     versionId: z.string().min(1),
@@ -16,7 +16,7 @@ export const GradialVideoSchema = z.object({
     type: z.string().min(1),
     width: z.number().int().nonnegative(),
     height: z.number().int().nonnegative(),
-    poster: GradialImageSchema.optional(),
+    poster: ImageSchema.optional(),
     sources: z.array(VideoSourceSchema).optional(),
     duration: z.number().nonnegative().optional(),
 });