@gradial/aci 0.1.20-preview.3 → 0.1.20

package/dist/content/contract.d.ts

@@ -1,83 +0,0 @@
-export declare const themeValues: readonly ["auto", "light", "dark"];
-export declare const buttonVariantValues: readonly ["primary", "secondary", "tertiary", "outline", "ghost"];
-export declare const iconPositionValues: readonly ["before", "after"];
-export type ContractField = {
-    kind: 'array';
-    items: ContractField;
-    optional?: boolean;
-} | {
-    kind: 'enum';
-    values: readonly [string, ...string[]];
-    optional?: boolean;
-} | {
-    kind: 'atomicBlocks';
-    optional?: boolean;
-} | {
-    kind: 'boolean';
-    optional?: boolean;
-} | {
-    kind: 'className';
-    optional?: boolean;
-} | {
-    kind: 'componentClassName';
-    optional?: boolean;
-} | {
-    kind: 'image';
-    optional?: boolean;
-} | {
-    kind: 'object';
-    fields: Record<string, ContractField>;
-    optional?: boolean;
-} | {
-    kind: 'richText';
-    optional?: boolean;
-} | {
-    kind: 'string';
-    minLength?: number;
-    optional?: boolean;
-};
-export interface BlockContract {
-    component: string;
-    displayName: string;
-    description: string;
-    props: Record<string, ContractField>;
-}
-export interface AtomicBlockContract extends BlockContract {
-}
-export declare const stringField: (options?: {
-    minLength?: number;
-    optional?: boolean;
-}) => ContractField;
-export declare const booleanField: (options?: {
-    optional?: boolean;
-}) => ContractField;
-export declare const imageField: (options?: {
-    optional?: boolean;
-}) => ContractField;
-export declare const enumField: (values: readonly [string, ...string[]], options?: {
-    optional?: boolean;
-}) => ContractField;
-export declare const arrayField: (items: ContractField, options?: {
-    optional?: boolean;
-}) => ContractField;
-export declare const objectField: (fields: Record<string, ContractField>, options?: {
-    optional?: boolean;
-}) => ContractField;
-export declare const richTextField: (options?: {
-    optional?: boolean;
-}) => ContractField;
-export declare const atomicBlocksField: (options?: {
-    optional?: boolean;
-}) => ContractField;
-export declare const classNameField: (options?: {
-    optional?: boolean;
-}) => ContractField;
-export declare const componentClassNameField: (options?: {
-    optional?: boolean;
-}) => ContractField;
-export declare const defaultAtomicBlockContracts: AtomicBlockContract[];
-export declare const defaultBlockContracts: BlockContract[];
-export declare const blockContracts: BlockContract[];
-export declare const atomicBlockContracts: AtomicBlockContract[];
-export declare const supportedBlockComponents: string[];
-export declare const supportedAtomicBlockComponents: string[];

package/dist/content/contract.js

@@ -1,104 +0,0 @@
-export const themeValues = ['auto', 'light', 'dark'];
-export const buttonVariantValues = ['primary', 'secondary', 'tertiary', 'outline', 'ghost'];
-export const iconPositionValues = ['before', 'after'];
-export const stringField = (options = {}) => ({
-    kind: 'string',
-    ...options,
-});
-export const booleanField = (options = {}) => ({
-    kind: 'boolean',
-    ...options,
-});
-export const imageField = (options = {}) => ({
-    kind: 'image',
-    ...options,
-});
-export const enumField = (values, options = {}) => ({
-    kind: 'enum',
-    values,
-    ...options,
-});
-export const arrayField = (items, options = {}) => ({
-    kind: 'array',
-    items,
-    ...options,
-});
-export const objectField = (fields, options = {}) => ({
-    kind: 'object',
-    fields,
-    ...options,
-});
-export const richTextField = (options = {}) => ({
-    kind: 'richText',
-    ...options,
-});
-export const atomicBlocksField = (options = {}) => ({
-    kind: 'atomicBlocks',
-    ...options,
-});
-export const classNameField = (options = {}) => ({
-    kind: 'className',
-    ...options,
-});
-export const componentClassNameField = (options = {}) => ({
-    kind: 'componentClassName',
-    ...options,
-});
-const themeFields = {
-    theme: enumField(themeValues, { optional: true }),
-    className: componentClassNameField({ optional: true }),
-};
-export const defaultAtomicBlockContracts = [
-    {
-        component: 'button',
-        displayName: 'Button',
-        description: 'Inline link styled as a button.',
-        props: {
-            label: stringField({ minLength: 1 }),
-            href: stringField({ minLength: 1 }),
-            variant: enumField(buttonVariantValues, { optional: true }),
-            newWindow: booleanField({ optional: true }),
-            icon: stringField({ optional: true }),
-            iconPosition: enumField(iconPositionValues, { optional: true }),
-            className: componentClassNameField({ optional: true }),
-        },
-    },
-];
-export const defaultBlockContracts = [
-    {
-        component: 'home_hero',
-        displayName: 'Home Hero',
-        description: 'Full-width hero section with headline, description, CTA, and image.',
-        props: {
-            eyebrow: stringField({ optional: true }),
-            headline: stringField({ minLength: 1 }),
-            description: stringField({ optional: true }),
-            ctaLabel: stringField({ minLength: 1 }),
-            ctaHref: stringField({ minLength: 1 }),
-            image: imageField(),
-        },
-    },
-    {
-        component: 'container',
-        displayName: 'Container',
-        description: 'Themed section wrapper that renders a stack of atomic content blocks.',
-        props: {
-            ...themeFields,
-            blocks: atomicBlocksField(),
-        },
-    },
-    {
-        component: 'ssr_probe',
-        displayName: 'SSR Probe',
-        description: 'Server-rendered proof section used by render/publish smoke tests.',
-        props: {
-            label: stringField({ optional: true }),
-            message: stringField({ optional: true }),
-            mode: stringField({ optional: true }),
-        },
-    },
-];
-export const blockContracts = defaultBlockContracts;
-export const atomicBlockContracts = defaultAtomicBlockContracts;
-export const supportedBlockComponents = defaultBlockContracts.map((block) => block.component);
-export const supportedAtomicBlockComponents = defaultAtomicBlockContracts.map((block) => block.component);

package/dist/content/tailwind-validator.d.ts

@@ -1,6 +0,0 @@
-export interface ClassNameValidationResult {
-    valid: boolean;
-    invalidClasses: string[];
-}
-export declare function validateContentClassName(value: string): ClassNameValidationResult;
-export declare function validateComponentClassName(value: string): ClassNameValidationResult;

package/dist/content/tailwind-validator.js

@@ -1,31 +0,0 @@
-const MODIFIER_PATTERN = /^(!)?(?:(?:hover|focus|focus-within|focus-visible|active|disabled|visited|checked|first|last|odd|even|sm|md|lg|xl|2xl|dark|light|motion-safe|motion-reduce|portrait|landscape|print|rtl|ltr|open|placeholder|before|after|first-line|first-letter|selection|marker|group-hover|group-focus|peer-hover|peer-focus|has|not|aria-\w+|data-\w+):)*/;
-const RAW_VALUE_PATTERN = /\[(?:#|.*?\d+(?:px|rem|em|vh|vw|dvh|dvw|svh|svw|ch|ex|cap|ic|lh|rlh|cm|mm|in|pt|pc|%))/;
-function parseToken(token) {
-    return token.replace(MODIFIER_PATTERN, '');
-}
-function hasArbitraryBracket(bare) {
-    return bare.includes('[');
-}
-function hasRawArbitraryValue(bare) {
-    if (!hasArbitraryBracket(bare)) {
-        return false;
-    }
-    return RAW_VALUE_PATTERN.test(bare);
-}
-function validate(value, isInvalid) {
-    const tokens = value.trim().split(/\s+/).filter(Boolean);
-    const invalidClasses = [];
-    for (const token of tokens) {
-        const bare = parseToken(token);
-        if (isInvalid(bare)) {
-            invalidClasses.push(token);
-        }
-    }
-    return { valid: invalidClasses.length === 0, invalidClasses };
-}
-export function validateContentClassName(value) {
-    return validate(value, hasArbitraryBracket);
-}
-export function validateComponentClassName(value) {
-    return validate(value, hasRawArbitraryValue);
-}

package/dist/content/validation.d.ts

@@ -1,108 +0,0 @@
-import { z } from 'zod';
-import { type AtomicBlockContract, type BlockContract, type ContractField } from './contract.js';
-import type { KernelPage, KernelSiteConfig } from './types.js';
-export interface ContentValidationContracts {
-    blockContracts?: readonly BlockContract[];
-    atomicBlockContracts?: readonly AtomicBlockContract[];
-}
-export interface ContentSchemas {
-    siteConfigSchema: z.ZodTypeAny;
-    atomicBlockSchema: z.ZodTypeAny;
-    pageBlockSchema: z.ZodTypeAny;
-    pageSchema: z.ZodTypeAny;
-    schemaFromContractField(field: ContractField): z.ZodTypeAny;
-    schemaFromContractFields(fields: Record<string, ContractField>): z.ZodTypeAny;
-    parseKernelSiteConfig(value: unknown, source?: string): KernelSiteConfig;
-    parseKernelPage(value: unknown, source?: string): KernelPage;
-}
-export declare const linkSchema: z.ZodObject<{
-    id: z.ZodString;
-    label: z.ZodString;
-    href: z.ZodString;
-}, z.core.$loose>;
-export declare const imageSchema: z.ZodObject<{
-    src: z.ZodString;
-    alt: z.ZodString;
-}, z.core.$loose>;
-export declare const optionalImageSchema: z.ZodObject<{
-    src: z.ZodString;
-    alt: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>;
-export declare const siteConfigSchema: z.ZodObject<{
-    id: z.ZodString;
-    $type: z.ZodLiteral<"site">;
-    status: z.ZodString;
-    title: z.ZodString;
-    domain: z.ZodString;
-    defaultLocale: z.ZodString;
-    brandHref: z.ZodOptional<z.ZodString>;
-    brandLogo: z.ZodOptional<z.ZodObject<{
-        src: z.ZodString;
-        alt: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
-    navigation: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        label: z.ZodString;
-        href: z.ZodString;
-    }, z.core.$loose>>>;
-    utilities: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        variant: z.ZodOptional<z.ZodEnum<{
-            primary: "primary";
-            secondary: "secondary";
-            tertiary: "tertiary";
-            outline: "outline";
-            ghost: "ghost";
-        }>>;
-        id: z.ZodString;
-        label: z.ZodString;
-        href: z.ZodString;
-    }, z.core.$loose>>>;
-    promo: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    footer: z.ZodOptional<z.ZodObject<{
-        columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            title: z.ZodOptional<z.ZodString>;
-            groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                title: z.ZodString;
-                links: z.ZodArray<z.ZodObject<{
-                    id: z.ZodString;
-                    label: z.ZodString;
-                    href: z.ZodString;
-                }, z.core.$loose>>;
-            }, z.core.$loose>>>;
-            links: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                label: z.ZodString;
-                href: z.ZodString;
-            }, z.core.$loose>>>;
-        }, z.core.$loose>>>;
-        social: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            icon: z.ZodOptional<z.ZodString>;
-            id: z.ZodString;
-            label: z.ZodString;
-            href: z.ZodString;
-        }, z.core.$loose>>>;
-        legalLinks: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            label: z.ZodString;
-            href: z.ZodString;
-        }, z.core.$loose>>>;
-        copyright: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
-    seo: z.ZodOptional<z.ZodObject<{
-        title: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        siteName: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>;
-}, z.core.$loose>;
-export declare function createContentSchemas(contracts?: ContentValidationContracts): ContentSchemas;
-export declare function formatZodError(source: string, error: z.ZodError): string;
-export declare function parseWithSchema(schema: z.ZodTypeAny, value: unknown, source: string): unknown;
-export declare const atomicBlockSchema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-export declare const pageBlockSchema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-export declare const pageSchema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-export declare const schemaFromContractField: (field: ContractField) => z.ZodTypeAny;
-export declare const schemaFromContractFields: (fields: Record<string, ContractField>) => z.ZodTypeAny;
-export declare const parseKernelSiteConfig: (value: unknown, source?: string) => KernelSiteConfig;
-export declare const parseKernelPage: (value: unknown, source?: string) => KernelPage;

package/dist/content/validation.js

@@ -1,183 +0,0 @@
-import { z } from 'zod';
-import { defaultAtomicBlockContracts, defaultBlockContracts, } from './contract.js';
-import { validateContentClassName, validateComponentClassName } from './tailwind-validator.js';
-const linkFields = {
-    id: z.string().min(1),
-    label: z.string().min(1),
-    href: z.string().min(1),
-};
-export const linkSchema = z.looseObject(linkFields);
-export const imageSchema = z.looseObject({
-    src: z.string().min(1),
-    alt: z.string().min(1),
-});
-export const optionalImageSchema = z.looseObject({
-    src: z.string().min(1),
-    alt: z.string().optional(),
-});
-export const siteConfigSchema = z.looseObject({
-    id: z.string().min(1),
-    $type: z.literal('site'),
-    status: z.string().min(1),
-    title: z.string().min(1),
-    domain: z.string().min(1),
-    defaultLocale: z.string().min(1),
-    brandHref: z.string().optional(),
-    brandLogo: optionalImageSchema.optional(),
-    navigation: z.array(linkSchema).optional(),
-    utilities: z.array(z.looseObject({
-        ...linkFields,
-        variant: z.enum(['primary', 'secondary', 'tertiary', 'outline', 'ghost']).optional(),
-    })).optional(),
-    promo: z.record(z.string(), z.unknown()).optional(),
-    footer: z.looseObject({
-        columns: z.array(z.looseObject({
-            id: z.string().min(1),
-            title: z.string().optional(),
-            groups: z.array(z.looseObject({
-                id: z.string().min(1),
-                title: z.string(),
-                links: z.array(linkSchema),
-            })).optional(),
-            links: z.array(linkSchema).optional(),
-        })).optional(),
-        social: z.array(z.looseObject({
-            ...linkFields,
-            icon: z.string().optional(),
-        })).optional(),
-        legalLinks: z.array(linkSchema).optional(),
-        copyright: z.string().optional(),
-    }).optional(),
-    seo: z.looseObject({
-        title: z.string().optional(),
-        description: z.string().optional(),
-        siteName: z.string().optional(),
-    }).optional(),
-});
-function withOptional(schema, field) {
-    return field.optional ? schema.optional() : schema;
-}
-export function createContentSchemas(contracts = {}) {
-    const blockContracts = contracts.blockContracts ?? defaultBlockContracts;
-    const atomicBlockContracts = contracts.atomicBlockContracts ?? defaultAtomicBlockContracts;
-    let atomicBlockSchema;
-    function schemaFromContractField(field) {
-        switch (field.kind) {
-            case 'atomicBlocks':
-                return withOptional(z.array(atomicBlockSchema), field);
-            case 'array':
-                return withOptional(z.array(schemaFromContractField(field.items)), field);
-            case 'boolean':
-                return withOptional(z.boolean(), field);
-            case 'className': {
-                const schema = z.string().check((ctx) => {
-                    const result = validateContentClassName(ctx.value);
-                    if (!result.valid) {
-                        ctx.issues.push({
-                            code: 'custom',
-                            message: `Invalid Tailwind classes: ${result.invalidClasses.join(', ')}. Use standard utilities only; arbitrary bracket values are not allowed in content.`,
-                            input: ctx.value,
-                        });
-                    }
-                });
-                return withOptional(schema, field);
-            }
-            case 'componentClassName': {
-                const schema = z.string().check((ctx) => {
-                    const result = validateComponentClassName(ctx.value);
-                    if (!result.valid) {
-                        ctx.issues.push({
-                            code: 'custom',
-                            message: `Invalid Tailwind classes: ${result.invalidClasses.join(', ')}. Raw dimension/color bracket values (for example [12px] or [#fff]) are not allowed.`,
-                            input: ctx.value,
-                        });
-                    }
-                });
-                return withOptional(schema, field);
-            }
-            case 'enum':
-                return withOptional(z.enum(field.values), field);
-            case 'image':
-                return withOptional(imageSchema, field);
-            case 'object':
-                return withOptional(schemaFromContractFields(field.fields), field);
-            case 'richText':
-                return withOptional(z.string(), field);
-            case 'string': {
-                const schema = typeof field.minLength === 'number'
-                    ? z.string().min(field.minLength)
-                    : z.string();
-                return withOptional(schema, field);
-            }
-        }
-    }
-    function schemaFromContractFields(fields) {
-        return z.looseObject(Object.fromEntries(Object.entries(fields).map(([key, field]) => [key, schemaFromContractField(field)])));
-    }
-    atomicBlockSchema = discriminatedContractUnion('atomic block', atomicBlockContracts, schemaFromContractFields);
-    const pageBlockSchema = discriminatedContractUnion('page block', blockContracts, schemaFromContractFields);
-    const pageSchema = z.looseObject({
-        id: z.string().min(1),
-        $type: z.literal('page'),
-        status: z.string().min(1),
-        layout: z.string().min(1),
-        metadata: z.looseObject({
-            title: z.string().optional(),
-            description: z.string().optional(),
-            canonical: z.string().optional(),
-        }),
-        regions: z.record(z.string(), z.array(pageBlockSchema)),
-    });
-    return {
-        siteConfigSchema,
-        atomicBlockSchema,
-        pageBlockSchema,
-        pageSchema,
-        schemaFromContractField,
-        schemaFromContractFields,
-        parseKernelSiteConfig(value, source = 'site.json') {
-            return parseWithSchema(siteConfigSchema, value, source);
-        },
-        parseKernelPage(value, source = '_index.json') {
-            return parseWithSchema(pageSchema, value, source);
-        },
-    };
-}
-function discriminatedContractUnion(label, contracts, schemaFromContractFields) {
-    if (contracts.length === 0) {
-        throw new Error(`At least one ${label} contract is required`);
-    }
-    const schemas = contracts.map((block) => z.looseObject({
-        id: z.string().min(1),
-        component: z.literal(block.component),
-        props: schemaFromContractFields(block.props),
-    }));
-    if (schemas.length === 1) {
-        return schemas[0];
-    }
-    return z.discriminatedUnion('component', schemas);
-}
-export function formatZodError(source, error) {
-    const issues = error.issues
-        .map((issue) => {
-        const path = issue.path.length ? issue.path.join('.') : '<root>';
-        return `- ${path}: ${issue.message}`;
-    })
-        .join('\n');
-    return `Invalid Gradial content in ${source}:\n${issues}`;
-}
-export function parseWithSchema(schema, value, source) {
-    const parsed = schema.safeParse(value);
-    if (!parsed.success) {
-        throw new Error(formatZodError(source, parsed.error));
-    }
-    return parsed.data;
-}
-const defaultContentSchemas = createContentSchemas();
-export const atomicBlockSchema = defaultContentSchemas.atomicBlockSchema;
-export const pageBlockSchema = defaultContentSchemas.pageBlockSchema;
-export const pageSchema = defaultContentSchemas.pageSchema;
-export const schemaFromContractField = defaultContentSchemas.schemaFromContractField;
-export const schemaFromContractFields = defaultContentSchemas.schemaFromContractFields;
-export const parseKernelSiteConfig = defaultContentSchemas.parseKernelSiteConfig;
-export const parseKernelPage = defaultContentSchemas.parseKernelPage;

package/dist/react/GradialMedia.d.ts

@@ -1,24 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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/sveltekit/index.d.ts

@@ -1,25 +0,0 @@
-import { type GradialContentWatchOptions, type VitePluginLike } from '../dev/index.js';
-import type { RenderInput } from '../content/types.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 getPageRuntimeRenderInput(event: {
-    request: Request;
-}): RenderInput | null;
-export { createRegistry, registryLookup } from '../registry.js';
-export type { Registry, RegistryEntry, AnyComponent } from '../registry.js';
-export { getPreviewMode, createPreviewBannerHTML, createPreviewCookies, type PreviewContext, type PreviewCookie, } from './preview.js';
-export declare function withGradialAci(options?: GradialContentWatchOptions): VitePluginLike;