@gradial/aci 0.1.0 → 0.1.2

package/dist/react/GradialMedia.d.ts

@@ -0,0 +1,24 @@
+import { type CSSProperties, type ImgHTMLAttributes, type VideoHTMLAttributes } from 'react';
+import type { GradialAsset } from '../types/media.js';
+export interface GradialMediaProps {
+    /** The compiler-resolved asset to render. */
+    asset: GradialAsset;
+    /** CSS class applied to the rendered element. */
+    className?: string;
+    /** Inline styles applied to the rendered element. */
+    style?: CSSProperties;
+    /** Loading strategy for images. Defaults to 'lazy'. */
+    loading?: 'eager' | 'lazy';
+    /** Additional image attributes (only applied when asset is an image). */
+    imgProps?: Omit<ImgHTMLAttributes<HTMLImageElement>, 'src' | 'alt'>;
+    /** Additional video attributes (only applied when asset is a video). */
+    videoProps?: Omit<VideoHTMLAttributes<HTMLVideoElement>, 'src' | 'poster' | 'width' | 'height'>;
+}
+/**
+ * Polymorphic media component — renders a GradialAsset as the appropriate
+ * HTML element based on $type.
+ *
+ * - gradial.image → <picture> or <img> via GradialPicture
+ * - gradial.video → <video> via GradialVideoPlayer
+ */
+export declare function GradialMedia({ asset, className, style, loading, imgProps, videoProps, }: GradialMediaProps): import("react").FunctionComponentElement<import("./GradialPicture.js").GradialPictureProps> | import("react").FunctionComponentElement<import("./GradialVideoPlayer.js").GradialVideoPlayerProps> | null;

package/dist/react/GradialMedia.js

@@ -0,0 +1,31 @@
+import { createElement } from 'react';
+import { GradialPicture } from './GradialPicture.js';
+import { GradialVideoPlayer } from './GradialVideoPlayer.js';
+/**
+ * Polymorphic media component — renders a GradialAsset as the appropriate
+ * HTML element based on $type.
+ *
+ * - gradial.image → <picture> or <img> via GradialPicture
+ * - gradial.video → <video> via GradialVideoPlayer
+ */
+export function GradialMedia({ asset, className, style, loading = 'lazy', imgProps, videoProps, }) {
+    switch (asset.$type) {
+        case 'gradial.image':
+            return createElement(GradialPicture, {
+                image: asset,
+                className,
+                style,
+                loading,
+                ...imgProps,
+            });
+        case 'gradial.video':
+            return createElement(GradialVideoPlayer, {
+                video: asset,
+                className,
+                style,
+                ...videoProps,
+            });
+        default:
+            return null;
+    }
+}

package/dist/react/GradialPicture.d.ts

@@ -0,0 +1,14 @@
+import { type ImgHTMLAttributes } from 'react';
+import type { GradialImage } from '../types/image.js';
+export interface GradialPictureProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, 'src' | 'alt'> {
+    image: GradialImage;
+}
+/**
+ * Renders a GradialImage as a <picture> element with responsive <source> entries,
+ * or a plain <img> when no art-directed sources exist.
+ *
+ * The compiler output determines the rendering:
+ * - sources[] populated → <picture> with <source> elements (art direction / format variants)
+ * - sources[] empty → <img> with fallback src
+ */
+export declare function GradialPicture({ image, ...attrs }: GradialPictureProps): import("react").DetailedReactHTMLElement<import("react").HTMLAttributes<HTMLElement>, HTMLElement>;

package/dist/react/GradialPicture.js

@@ -0,0 +1,30 @@
+import { createElement } from 'react';
+/**
+ * Renders a GradialImage as a <picture> element with responsive <source> entries,
+ * or a plain <img> when no art-directed sources exist.
+ *
+ * The compiler output determines the rendering:
+ * - sources[] populated → <picture> with <source> elements (art direction / format variants)
+ * - sources[] empty → <img> with fallback src
+ */
+export function GradialPicture({ image, ...attrs }) {
+    const img = createElement('img', {
+        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,
+        loading: 'lazy',
+        decoding: 'async',
+        ...attrs,
+    });
+    if (!image.sources?.length) {
+        return img;
+    }
+    return createElement('picture', null, ...image.sources.map((source, index) => createElement('source', {
+        key: index,
+        media: source.media,
+        type: source.type,
+        srcSet: source.srcset,
+        sizes: source.sizes,
+    })), img);
+}

package/dist/react/GradialVideoPlayer.d.ts

@@ -0,0 +1,13 @@
+import { type VideoHTMLAttributes } from 'react';
+import type { GradialVideo } from '../types/video.js';
+export interface GradialVideoPlayerProps extends Omit<VideoHTMLAttributes<HTMLVideoElement>, 'src' | 'poster' | 'width' | 'height'> {
+    video: GradialVideo;
+}
+/**
+ * Renders a GradialVideo as a <video> element.
+ *
+ * - Uses poster.fallback.src for the poster attribute (single URL — browser limitation).
+ * - Includes <source> elements for format variants when available.
+ * - Falls back to src attribute on <video> when no source variants exist.
+ */
+export declare function GradialVideoPlayer({ video, ...attrs }: GradialVideoPlayerProps): import("react").DetailedReactHTMLElement<Record<string, unknown>, HTMLElement>;

package/dist/react/GradialVideoPlayer.js

@@ -0,0 +1,28 @@
+import { createElement } from 'react';
+/**
+ * Renders a GradialVideo as a <video> element.
+ *
+ * - Uses poster.fallback.src for the poster attribute (single URL — browser limitation).
+ * - Includes <source> elements for format variants when available.
+ * - Falls back to src attribute on <video> when no source variants exist.
+ */
+export function GradialVideoPlayer({ video, ...attrs }) {
+    const posterSrc = video.poster?.fallback.src;
+    const hasSources = video.sources && video.sources.length > 0;
+    const videoAttrs = {
+        poster: posterSrc,
+        width: video.width > 0 ? video.width : undefined,
+        height: video.height > 0 ? video.height : undefined,
+        ...attrs,
+    };
+    // If no format variants, put src directly on <video>
+    if (!hasSources) {
+        videoAttrs.src = video.src;
+    }
+    const children = (video.sources ?? []).map((source, index) => createElement('source', {
+        key: index,
+        src: source.src,
+        type: source.type,
+    }));
+    return createElement('video', videoAttrs, ...children);
+}

package/dist/react/index.d.ts

@@ -0,0 +1,3 @@
+export { GradialPicture } from './GradialPicture.js';
+export { GradialVideoPlayer } from './GradialVideoPlayer.js';
+export { GradialMedia } from './GradialMedia.js';

package/dist/react/index.js

@@ -0,0 +1,3 @@
+export { GradialPicture } from './GradialPicture.js';
+export { GradialVideoPlayer } from './GradialVideoPlayer.js';
+export { GradialMedia } from './GradialMedia.js';

package/dist/sveltekit/index.d.ts

@@ -1,2 +1,18 @@
-import { type BareMetalContentWatchOptions, type VitePluginLike } from '../dev/index.js';
-export declare function baremetalSvelteKit(options?: BareMetalContentWatchOptions): VitePluginLike;
+import { type GradialContentWatchOptions, type VitePluginLike } from '../dev/index.js';
+/**
+ * Generates prerender entries from the compiled content manifest for SvelteKit.
+ *
+ * Usage in svelte.config.js:
+ * ```js
+ * import { gradialEntries } from '@gradial/aci/sveltekit';
+ * export default { kit: { prerender: { entries: await gradialEntries() } } };
+ * ```
+ *
+ * Or in a catch-all `+page.server.ts`:
+ * ```ts
+ * import { gradialEntries } from '@gradial/aci/sveltekit';
+ * export const entries = gradialEntries;
+ * ```
+ */
+export declare function gradialEntries(): Promise<string[]>;
+export declare function gradialSvelteKit(options?: GradialContentWatchOptions): VitePluginLike;

package/dist/sveltekit/index.js

@@ -1,9 +1,45 @@
-import { baremetalContentWatchPlugin, devRefreshPort, devRefreshScriptTag, } from '../dev/index.js';
-export function baremetalSvelteKit(options = {}) {
-    const watchPlugin = baremetalContentWatchPlugin(options);
+import { gradialContentWatchPlugin, gradialDamAssetPlugin, devRefreshPort, devRefreshScriptTag, } from '../dev/index.js';
+// ---------------------------------------------------------------------------
+// Entries helper — for SvelteKit SSG prerendering
+// ---------------------------------------------------------------------------
+/**
+ * Generates prerender entries from the compiled content manifest for SvelteKit.
+ *
+ * Usage in svelte.config.js:
+ * ```js
+ * import { gradialEntries } from '@gradial/aci/sveltekit';
+ * export default { kit: { prerender: { entries: await gradialEntries() } } };
+ * ```
+ *
+ * Or in a catch-all `+page.server.ts`:
+ * ```ts
+ * import { gradialEntries } from '@gradial/aci/sveltekit';
+ * export const entries = gradialEntries;
+ * ```
+ */
+export async function gradialEntries() {
+    const { FileContentProvider } = await import('../providers/file.js');
+    const { normalizeRoute } = await import('../content/routes.js');
+    const provider = new FileContentProvider();
+    const routes = await provider.listRoutes();
+    return routes.map((entry) => {
+        const normalized = normalizeRoute(entry.path);
+        return normalized === '/' ? '/' : `/${normalized.replace(/^\/|\/$/g, '')}/`;
+    });
+}
+// ---------------------------------------------------------------------------
+// SvelteKit Vite plugin
+// ---------------------------------------------------------------------------
+export function gradialSvelteKit(options = {}) {
+    const watchPlugin = gradialContentWatchPlugin(options);
+    const damAssetPlugin = gradialDamAssetPlugin(options);
     return {
         ...watchPlugin,
-        name: 'baremetal-sveltekit',
+        name: 'gradial-sveltekit',
+        configureServer(server) {
+            damAssetPlugin.configureServer?.(server);
+            watchPlugin.configureServer?.(server);
+        },
         transformIndexHtml(html) {
             if (process.env.NODE_ENV === 'production') {
                 return html;

package/dist/testing/index.d.ts

@@ -1,20 +1,22 @@
-import { type ContentProvider, type RenderInputOptions } from '../content/provider.js';
+import { type ContentProvider, type RouteEntry, type RenderInputOptions } from '../content/provider.js';
 import type { KernelPage, KernelRouteMetadata, KernelSiteConfig, RenderInput } from '../content/types.js';
-export interface FixtureContentProviderOptions<TPage extends KernelPage = KernelPage, TSiteConfig extends KernelSiteConfig = KernelSiteConfig> {
-    siteConfig?: TSiteConfig;
-    pages?: Record<string, TPage | null>;
+export interface FixtureContentProviderOptions {
+    siteConfig?: KernelSiteConfig;
+    pages?: Record<string, KernelPage>;
+    fragments?: Record<string, unknown>;
 }
-export declare class FixtureContentProvider<TPage extends KernelPage = KernelPage, TSiteConfig extends KernelSiteConfig = KernelSiteConfig> implements ContentProvider<TPage, TSiteConfig> {
+export declare class FixtureContentProvider implements ContentProvider {
     private siteConfig;
     private pages;
-    constructor(options?: FixtureContentProviderOptions<TPage, TSiteConfig>);
-    loadSiteConfig(): Promise<TSiteConfig>;
-    loadPage(route?: string): Promise<TPage | null>;
-    listRoutes(): Promise<string[]>;
-    listPublishedRoutes(): Promise<string[]>;
+    private fragments;
+    constructor(options?: FixtureContentProviderOptions);
+    getSiteConfig<T = unknown>(): Promise<T>;
+    getPage<T = unknown>(route: string): Promise<T>;
+    getFragment<T = unknown>(id: string): Promise<T>;
+    listRoutes(): Promise<RouteEntry[]>;
+    loadRenderInput(route?: string, options?: RenderInputOptions): Promise<RenderInput>;
     resolveRouteMetadata(route?: string): Promise<KernelRouteMetadata>;
-    loadRenderInput(route?: string, options?: RenderInputOptions): Promise<RenderInput<TPage, TSiteConfig>>;
 }
-export declare function createFixtureContentProvider<TPage extends KernelPage = KernelPage, TSiteConfig extends KernelSiteConfig = KernelSiteConfig>(options?: FixtureContentProviderOptions<TPage, TSiteConfig>): FixtureContentProvider<TPage, TSiteConfig>;
+export declare function createFixtureContentProvider(options?: FixtureContentProviderOptions): FixtureContentProvider;
 export declare function defaultFixtureSiteConfig(): KernelSiteConfig;
 export declare function defaultFixturePage(): KernelPage;

package/dist/testing/index.js

@@ -1,51 +1,64 @@
-import { loadRenderInput, routeMetadataForContent, } from '../content/provider.js';
+import { PageNotFoundError, FragmentNotFoundError, loadRenderInput, routeMetadataForContent, } from '../content/provider.js';
 import { normalizeRoute } from '../content/routes.js';
 export class FixtureContentProvider {
     siteConfig;
     pages;
+    fragments;
     constructor(options = {}) {
         this.siteConfig = cloneFixture(options.siteConfig ?? defaultFixtureSiteConfig());
         this.pages = new Map();
-        const inputPages = options.pages ?? {
-            '/': defaultFixturePage(),
-        };
+        this.fragments = new Map();
+        const inputPages = options.pages ?? { '/': defaultFixturePage() };
         for (const [route, page] of Object.entries(inputPages)) {
-            if (page) {
-                this.pages.set(normalizeRoute(route), cloneFixture(page));
+            this.pages.set(normalizeRoute(route), cloneFixture(page));
+        }
+        if (options.fragments) {
+            for (const [id, fragment] of Object.entries(options.fragments)) {
+                this.fragments.set(id, cloneFixture(fragment));
             }
         }
     }
-    async loadSiteConfig() {
+    async getSiteConfig() {
         return cloneFixture(this.siteConfig);
     }
-    async loadPage(route = '/') {
+    async getPage(route) {
         const page = this.pages.get(normalizeRoute(route));
-        return page ? cloneFixture(page) : null;
-    }
-    async listRoutes() {
-        return [...this.pages.keys()].sort((left, right) => left.localeCompare(right));
+        if (!page) {
+            throw new PageNotFoundError(route);
+        }
+        return cloneFixture(page);
     }
-    async listPublishedRoutes() {
-        const routes = await this.listRoutes();
-        const published = [];
-        for (const route of routes) {
-            const page = await this.loadPage(route);
-            if (page?.status === 'published') {
-                published.push(route);
-            }
+    async getFragment(id) {
+        const fragment = this.fragments.get(id);
+        if (fragment === undefined) {
+            throw new FragmentNotFoundError(id);
         }
-        return published;
+        return cloneFixture(fragment);
     }
-    async resolveRouteMetadata(route = '/') {
-        const [siteConfig, page] = await Promise.all([
-            this.loadSiteConfig(),
-            this.loadPage(route),
-        ]);
-        return routeMetadataForContent(siteConfig, page);
+    async listRoutes() {
+        return [...this.pages.entries()]
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([routePath, page]) => ({
+            slug: routePath === '/' ? 'home' : routePath.replace(/^\//, ''),
+            path: routePath,
+            payloadRef: `routes/${routePath === '/' ? 'home' : routePath.replace(/^\//, '')}.json`,
+            digest: '',
+        }));
     }
     async loadRenderInput(route = '/', options = {}) {
         return loadRenderInput(this, route, options);
     }
+    async resolveRouteMetadata(route = '/') {
+        const siteConfig = await this.getSiteConfig();
+        let page;
+        try {
+            page = await this.getPage(route);
+        }
+        catch {
+            page = null;
+        }
+        return routeMetadataForContent(siteConfig, page);
+    }
 }
 export function createFixtureContentProvider(options = {}) {
     return new FixtureContentProvider(options);
@@ -56,7 +69,7 @@ export function defaultFixtureSiteConfig() {
         $type: 'site',
         status: 'published',
         title: 'Fixture Site',
-        domain: 'www.baremetal.local',
+        domain: 'www.aci.local',
         defaultLocale: 'en-us',
         seo: {
             title: 'Fixture Site',

package/dist/types/component.d.ts

@@ -1,26 +1,48 @@
 import type { IslandMode, VaryDimension } from './render-mode.js';
+import type { ImageSlotContract } from './image.js';
+import type { z } from 'zod';
 export interface ComponentRenderModes {
     canStatic: boolean;
     canSSR: boolean;
     canClientIsland: boolean;
 }
+/**
+ * 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;
-    component?: unknown;
+    /**
+     * 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;
     renderModes?: ComponentRenderModes;
     render?: ComponentRenderModes;
     defaultIslandMode?: IslandMode;
     varyDimensions?: VaryDimension[];
     vary?: VaryDimension[];
+    imageSlots?: Record<string, ImageSlotContract>;
 }
 export interface ComponentContract<TSchema = unknown> {
     name: string;
-    component?: unknown;
+    component?: CmsComponentFn<any>;
     schema: TSchema;
     renderModes: ComponentRenderModes;
     render: ComponentRenderModes;
     defaultIslandMode?: IslandMode;
     varyDimensions?: VaryDimension[];
     vary?: VaryDimension[];
+    imageSlots?: Record<string, ImageSlotContract>;
 }
+export type InferComponentProps<TContract> = TContract extends ComponentContract<infer TSchema> ? InferContentProps<TSchema> : Record<string, unknown>;
+export type { CmsComponentFn, InferContentProps };

package/dist/types/config.d.ts

@@ -12,6 +12,7 @@ export interface BareMetalConfig {
     rendererEntry: string;
     capabilities: RenderCapabilities;
     routes: RouteConfig;
+    dam?: DAMConfig;
     externalDependencies?: ExternalDependency[];
     rendererProtocol: 'http' | 'stdio-json';
 }
@@ -26,3 +27,6 @@ export interface ExternalDependency {
     description?: string;
     cacheTTL?: number;
 }
+export interface DAMConfig {
+    autoApproveUploads?: boolean;
+}

package/dist/types/image.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export interface ImageSource {
+    src: string;
+    width: number;
+    height: number;
+    type: string;
+}
+export interface PictureSource {
+    media?: string;
+    type: string;
+    srcset: string;
+    sizes?: string;
+}
+export interface GradialImage {
+    $type: 'gradial.image';
+    assetId: string;
+    versionId: string;
+    alt: string;
+    fallback: ImageSource;
+    sources: PictureSource[];
+}
+export interface ImageSlotContract {
+    outputs: SlotOutput[];
+    formats: string[];
+    sizes: string;
+}
+export interface SlotOutput {
+    aspectRatio: string;
+    widths: number[];
+    media?: string;
+}
+export declare const GradialImageSchema: z.ZodObject<{
+    $type: z.ZodLiteral<"gradial.image">;
+    assetId: z.ZodString;
+    versionId: z.ZodString;
+    alt: z.ZodString;
+    fallback: 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>;
+export type ImageHTMLAttributes = Record<string, string | number | boolean | undefined | null>;
+export declare function renderImageHTML(image: GradialImage, attrs?: ImageHTMLAttributes): string;

package/dist/types/image.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+export const GradialImageSchema = 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([]),
+});
+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(' ');
+}
+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;');
+}

package/dist/types/index.d.ts

@@ -4,3 +4,6 @@ export * from './layout.js';
 export * from './page.js';
 export * from './renderer.js';
 export * from './render-mode.js';
+export * from './image.js';
+export * from './video.js';
+export * from './media.js';

package/dist/types/index.js

@@ -4,3 +4,6 @@ export * from './layout.js';
 export * from './page.js';
 export * from './renderer.js';
 export * from './render-mode.js';
+export * from './image.js';
+export * from './video.js';
+export * from './media.js';

package/dist/types/layout.d.ts

@@ -1,12 +1,24 @@
+import type { FragmentRefNode } from './page.js';
 export interface LayoutSlot {
     name: string;
     required: boolean;
 }
+/** Default content for non-required layout slots, keyed by slot name. */
+export type LayoutDefaults = Record<string, FragmentRefNode[]>;
 export interface LayoutDefinition {
     name: string;
     slots: LayoutSlot[];
+    /** Default fragment references for slots not provided by the page. */
+    defaults?: LayoutDefaults;
 }
 export interface LayoutContract {
     name: string;
     slots: LayoutSlot[];
+    defaults?: LayoutDefaults;
+}
+/** A compiled layout file as stored on disk. */
+export interface CompiledLayout {
+    name: string;
+    slots: LayoutSlot[];
+    defaults: LayoutDefaults;
 }

package/dist/types/media.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { type GradialImage } from './image.js';
+import { type GradialVideo } from './video.js';
+/** Discriminated union of all compiler-resolved asset types. */
+export type GradialAsset = GradialImage | GradialVideo;
+export declare const GradialAssetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    $type: z.ZodLiteral<"gradial.image">;
+    assetId: z.ZodString;
+    versionId: z.ZodString;
+    alt: z.ZodString;
+    fallback: 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.ZodObject<{
+    $type: z.ZodLiteral<"gradial.video">;
+    assetId: z.ZodString;
+    versionId: z.ZodString;
+    alt: z.ZodString;
+    src: z.ZodString;
+    type: z.ZodString;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    poster: z.ZodOptional<z.ZodObject<{
+        $type: z.ZodLiteral<"gradial.image">;
+        assetId: z.ZodString;
+        versionId: z.ZodString;
+        alt: z.ZodString;
+        fallback: 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>>;
+    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;