@gradial/aci 0.1.20-preview.3 → 0.1.20

package/dist/react/index.js

@@ -1,3 +1,89 @@
-export { GradialPicture } from './GradialPicture.js';
-export { GradialVideoPlayer } from './GradialVideoPlayer.js';
-export { GradialMedia } from './GradialMedia.js';
+import { createElement, Fragment, } from 'react';
+import sanitizeHtml from 'sanitize-html';
+import MarkdownIt from 'markdown-it';
+import { imageAttrs } from '../types/image.js';
+import { resolveHref, normalizeLinkRel, assertSafeHref } from '../types/link.js';
+export { Picture } from './Picture.js';
+export { Media } from './Media.js';
+export { VideoPlayer } from './VideoPlayer.js';
+export function Image({ image, value, ...attrs }) {
+    const resolved = image ?? value ?? {
+        $type: 'gradial.image',
+        assetId: '',
+        versionId: '',
+        alt: '',
+        sources: [],
+    };
+    if (!resolved.sources.length) {
+        return createElement('img', {
+            src: '',
+            alt: resolved.alt,
+            ...attrs,
+        });
+    }
+    return createElement('img', imageAttrs(resolved, attrs));
+}
+export function Link({ link, resolveLink, children }) {
+    const href = resolveHref(link, resolveLink);
+    if (typeof href === 'string') {
+        assertSafeHref(href);
+    }
+    return createElement('a', {
+        href,
+        target: link.target,
+        rel: normalizeLinkRel(link),
+        title: link.title,
+    }, children);
+}
+export function Heading({ heading, value }) {
+    const resolved = heading ?? value;
+    if (!resolved) {
+        return null;
+    }
+    return createElement(`h${resolved.level}`, null, renderInlineContent(resolved.content));
+}
+export function headingPlainText(value) {
+    return inlinePlainText(value.content);
+}
+const markdown = new MarkdownIt({ html: false, linkify: true, typographer: true });
+export function RichText({ value }) {
+    const richText = typeof value === 'string' ? { format: 'markdown', markdown: value } : value;
+    const rendered = richText.format === 'markdown'
+        ? markdown.render(richText.markdown)
+        : richText.html;
+    const clean = sanitizeHtml(rendered, {
+        allowedTags: sanitizeHtml.defaults.allowedTags.concat(['img']),
+        allowedAttributes: {
+            ...sanitizeHtml.defaults.allowedAttributes,
+            a: ['href', 'name', 'target', 'rel'],
+            img: ['src', 'alt', 'width', 'height', 'loading'],
+        },
+        transformTags: {
+            a: sanitizeHtml.simpleTransform('a', { rel: 'noopener noreferrer' }, true),
+        },
+    });
+    return createElement('div', { dangerouslySetInnerHTML: { __html: clean } });
+}
+function renderInlineContent(content) {
+    return content.map((node, index) => {
+        const children = 'content' in node ? renderInlineContent(node.content) : node.text;
+        switch (node.type) {
+            case 'strong':
+                return createElement('strong', { key: index }, children);
+            case 'em':
+                return createElement('em', { key: index }, children);
+            case 'link':
+                return createElement('a', { key: index, href: node.href }, children);
+            case 'span':
+                return createElement('span', { key: index, 'data-aci-variant': node.variant }, children);
+            case 'text':
+            default:
+                return createElement(Fragment, { key: index }, children);
+        }
+    });
+}
+function inlinePlainText(content) {
+    return content
+        .map((node) => node.type === 'text' ? node.text : inlinePlainText(node.content))
+        .join('');
+}

package/dist/registry.d.ts

@@ -1,7 +1,7 @@
 import type { ComponentContract, InferComponentProps } from './types/component.js';
 export type AnyComponent = (abstract new (...args: any[]) => any) | ((props: any) => any) | Record<string, any>;
 export interface RegistryEntry {
-    name: string;
+    id: string;
     component: AnyComponent;
     contract: ComponentContract;
 }
@@ -11,5 +11,5 @@ type ValidatedEntries<T extends readonly (readonly [ComponentContract, AnyCompon
     [K in keyof T]: ValidatedEntry<T[K]>;
 };
 export declare function createRegistry<const T extends readonly (readonly [ComponentContract, AnyComponent])[]>(entries: ValidatedEntries<T> & T): Registry;
-export declare function registryLookup(registry: Registry, name: string): AnyComponent | undefined;
+export declare function registryLookup(registry: Registry, id: string): AnyComponent | undefined;
 export {};

package/dist/registry.js

@@ -1,10 +1,10 @@
 export function createRegistry(entries) {
     return entries.map(([contract, component]) => ({
-        name: contract.name,
+        id: contract.id,
         component,
         contract,
     }));
 }
-export function registryLookup(registry, name) {
-    return registry.find((r) => r.name === name)?.component;
+export function registryLookup(registry, id) {
+    return registry.find((r) => r.id === id)?.component;
 }

package/dist/types/block-ref.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import type { ComponentContract } from './component.js';
+export interface BlockRefMeta {
+    allowed: readonly string[];
+    multiple: boolean;
+}
+declare const blockRefBase: z.ZodObject<{
+    id: z.ZodString;
+    component: z.ZodString;
+    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+type InferContractProps<T> = T extends ComponentContract<string, infer Schema> ? Schema extends z.ZodType<infer P> ? P : Record<string, unknown> : Record<string, unknown>;
+type InferContractId<T> = T extends ComponentContract<infer Id, unknown> ? Id : never;
+export type BlockRefEntry<T extends ComponentContract> = {
+    id: string;
+    component: InferContractId<T>;
+    props: InferContractProps<T>;
+};
+export type BlockRefUnion<T extends readonly ComponentContract[]> = {
+    [K in keyof T]: BlockRefEntry<T[K]>;
+}[number];
+export declare function blockRefArray<const T extends readonly ComponentContract[]>(contracts: T): z.ZodArray<z.ZodType<BlockRefUnion<T>>>;
+export declare function blockRef<const T extends readonly ComponentContract[]>(contracts: T): z.ZodType<BlockRefUnion<T>>;
+export declare function getBlockRefMeta(schema: unknown): BlockRefMeta | null;
+export type BlockRef = z.infer<typeof blockRefBase>;
+export {};

package/dist/types/block-ref.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+const BLOCK_REF_KEY = '_gradialBlockRef';
+const blockRefBase = z.object({
+    id: z.string().min(1),
+    component: z.string().min(1),
+    props: z.record(z.string(), z.unknown()),
+});
+function attachMeta(schema, allowed, multiple) {
+    Object.defineProperty(schema, BLOCK_REF_KEY, {
+        value: { allowed, multiple },
+        enumerable: false,
+        writable: false,
+        configurable: false,
+    });
+    return schema;
+}
+export function blockRefArray(contracts) {
+    return attachMeta(z.array(blockRefBase), contracts.map((c) => c.id), true);
+}
+export function blockRef(contracts) {
+    return attachMeta(blockRefBase, contracts.map((c) => c.id), false);
+}
+export function getBlockRefMeta(schema) {
+    if (schema && typeof schema === 'object' && BLOCK_REF_KEY in schema) {
+        return schema[BLOCK_REF_KEY];
+    }
+    return null;
+}

package/dist/types/component.d.ts

@@ -1,39 +1,43 @@
-import type { IslandMode, VaryDimension } from './render-mode.js';
 import type { ImageSlotContract } from './image.js';
+import type { BlockRefMeta } from './block-ref.js';
 import type { z } from 'zod';
-/**
- * A CMS-registered component — sync or async (server components).
- * Accepts content props derived from the Zod schema.
- */
-type CmsComponentFn<TProps = any> = ((props: TProps) => import('react').ReactElement | null) | ((props: TProps) => Promise<import('react').ReactElement | null>);
-/**
- * Infers the props type from a schema.
- * If TSchema is a Zod type, returns z.infer<TSchema>.
- * Otherwise returns Record<string, unknown>.
- */
 type InferContentProps<TSchema> = TSchema extends z.ZodType<infer T> ? T : Record<string, unknown>;
-export interface ComponentDefinition<TSchema = unknown> {
-    name: string;
-    /**
-     * The React component that renders this CMS block.
-     * Accepts at least the schema-derived props, but may accept additional
-     * composition params (className, etc.) passed by parent sections.
-     */
-    component?: CmsComponentFn<any>;
-    schema: TSchema;
-    defaultIslandMode?: IslandMode;
-    varyDimensions?: VaryDimension[];
-    vary?: VaryDimension[];
+export interface ComponentContractValidator<TProps = Record<string, unknown>> {
+    (context: ComponentValidationContext<TProps>): void | Promise<void>;
+}
+export interface ComponentValidationContext<TProps = Record<string, unknown>> {
+    component: string;
+    props: TProps;
+    blockId?: string;
+    path: readonly string[];
+    report(issue: ComponentValidationIssue): void;
+}
+export interface ComponentValidationIssue {
+    path?: readonly string[];
+    code?: string;
+    message: string;
+    severity?: 'error' | 'warning';
+}
+export interface ComponentDefinition<TId extends string = string, TSchema = unknown> {
+    id: TId;
+    displayName?: string;
+    props: TSchema;
     imageSlots?: Record<string, ImageSlotContract>;
+    validate?: readonly ComponentContractValidator<InferContentProps<TSchema>>[];
 }
-export interface ComponentContract<TSchema = unknown> {
-    name: string;
-    component?: CmsComponentFn<any>;
-    schema: TSchema;
-    defaultIslandMode?: IslandMode;
-    varyDimensions?: VaryDimension[];
-    vary?: VaryDimension[];
+export interface ComponentContract<TId extends string = string, TSchema = unknown> {
+    readonly id: TId;
+    readonly displayName?: string;
+    props: TSchema;
+    blockSlots?: Record<string, BlockRefMeta>;
     imageSlots?: Record<string, ImageSlotContract>;
+    validate: readonly ComponentContractValidator<InferContentProps<TSchema>>[];
 }
-export type InferComponentProps<TContract> = TContract extends ComponentContract<infer TSchema> ? InferContentProps<TSchema> : Record<string, unknown>;
-export type { CmsComponentFn, InferContentProps };
+export type InferComponentProps<TContract> = TContract extends ComponentContract<string, infer TSchema> ? InferContentProps<TSchema> : Record<string, unknown>;
+export type ComponentContractID<TContract> = TContract extends ComponentContract<infer TId, unknown> ? TId : never;
+export type ComponentRegistry<TContracts extends Record<string, ComponentContract>> = {
+    readonly [K in keyof TContracts]: TContracts[K] & {
+        readonly id: K & string;
+    };
+};
+export type { InferContentProps };

package/dist/types/config.d.ts

@@ -1,5 +1,5 @@
 import type { RenderCapabilities } from './renderer.js';
-export interface BareMetalConfig {
+export interface Config {
     version: '1';
     siteId: string;
     framework: 'astro' | 'next' | 'sveltekit' | 'custom';

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;