@gradial/aci 0.1.20-preview.2 → 0.1.20

package/dist/next/preview.js

@@ -1,37 +0,0 @@
-export async function validatePreviewToken(token, signKey) {
-    try {
-        const parts = token.split('.');
-        if (parts.length !== 3)
-            return null;
-        const signingInput = `${parts[0]}.${parts[1]}`;
-        const signature = base64URLToBytes(parts[2]);
-        const key = await crypto.subtle.importKey('raw', new TextEncoder().encode(signKey), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
-        const expected = new Uint8Array(await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(signingInput)));
-        if (!constantTimeEqual(signature, expected))
-            return null;
-        const payload = new TextDecoder().decode(base64URLToBytes(parts[1]));
-        return JSON.parse(payload);
-    }
-    catch {
-        return null;
-    }
-}
-function base64URLToBytes(value) {
-    const base64 = value.replace(/-/g, '+').replace(/_/g, '/');
-    const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, '=');
-    const binary = atob(padded);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-        bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
-}
-function constantTimeEqual(left, right) {
-    if (left.length !== right.length)
-        return false;
-    let diff = 0;
-    for (let i = 0; i < left.length; i++) {
-        diff |= left[i] ^ right[i];
-    }
-    return diff === 0;
-}

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,23 +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 { getPreviewMode, createPreviewBannerHTML, createPreviewCookies, type PreviewContext, type PreviewCookie, } from './preview.js';
-export declare function withGradialAci(options?: GradialContentWatchOptions): VitePluginLike;

package/dist/sveltekit/index.js

@@ -1,62 +0,0 @@
-import { gradialContentWatchPlugin, gradialDamAssetPlugin, devRefreshPort, devRefreshScriptTag, } from '../dev/index.js';
-import { getPendingRenderInputFromHeaders } from '../runtime/page.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, '')}/`;
-    });
-}
-export function getPageRuntimeRenderInput(event) {
-    return getPendingRenderInputFromHeaders(event.request.headers);
-}
-// ---------------------------------------------------------------------------
-// Preview support
-// ---------------------------------------------------------------------------
-export { getPreviewMode, createPreviewBannerHTML, createPreviewCookies, } from './preview.js';
-// ---------------------------------------------------------------------------
-// SvelteKit Vite plugin
-// ---------------------------------------------------------------------------
-export function withGradialAci(options = {}) {
-    const watchPlugin = gradialContentWatchPlugin(options);
-    const damAssetPlugin = gradialDamAssetPlugin(options);
-    return {
-        ...watchPlugin,
-        name: 'gradial-sveltekit',
-        configureServer(server) {
-            damAssetPlugin.configureServer?.(server);
-            watchPlugin.configureServer?.(server);
-        },
-        transformIndexHtml(html) {
-            if (process.env.NODE_ENV === 'production') {
-                return html;
-            }
-            if (devRefreshPort(options) <= 0) {
-                return html;
-            }
-            const script = devRefreshScriptTag(options);
-            return html.includes('</body>') ? html.replace('</body>', `${script}</body>`) : `${html}${script}`;
-        },
-    };
-}

package/dist/sveltekit/preview.d.ts

@@ -1,5 +0,0 @@
-import { type PreviewContext, type PreviewCookie } from '../preview/core.js';
-export declare function getPreviewMode(request: Request, siteId: string): Promise<PreviewContext>;
-export declare function createPreviewBannerHTML(releaseId: string): string;
-export declare function createPreviewCookies(token: string, releaseId: string): PreviewCookie[];
-export type { PreviewContext, PreviewCookie };

package/dist/sveltekit/preview.js

@@ -1,33 +0,0 @@
-import { extractPreviewToken, resolvePreviewContext, createPreviewBannerHTML as coreCreatePreviewBannerHTML, createPreviewCookies as coreCreatePreviewCookies, previewSignKey, } from '../preview/core.js';
-export async function getPreviewMode(request, siteId) {
-    const url = new URL(request.url);
-    const token = extractPreviewToken({
-        query: url.searchParams,
-        cookies: parseCookieHeader(request.headers.get('cookie') || ''),
-        authorization: request.headers.get('authorization') || undefined,
-    });
-    if (!token)
-        return { isPreview: false };
-    return resolvePreviewContext({ token, siteId, signKey: previewSignKey() });
-}
-export function createPreviewBannerHTML(releaseId) {
-    return coreCreatePreviewBannerHTML(releaseId);
-}
-export function createPreviewCookies(token, releaseId) {
-    return coreCreatePreviewCookies(token, releaseId);
-}
-function parseCookieHeader(header) {
-    const cookies = new Map();
-    for (const part of header.split(';')) {
-        const trimmed = part.trim();
-        if (!trimmed)
-            continue;
-        const idx = trimmed.indexOf('=');
-        if (idx < 0)
-            continue;
-        const name = trimmed.slice(0, idx).trim();
-        const value = trimmed.slice(idx + 1).trim();
-        cookies.set(name, decodeURIComponent(value));
-    }
-    return cookies;
-}

package/src/cli/verify-renderer.mjs

@@ -1,73 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-
-const args = parseArgs(process.argv.slice(2));
-
-try {
-  if (!args.renderer) throw new Error('missing --renderer');
-  await verifyRenderer(path.resolve(args.renderer));
-  console.log(JSON.stringify({ success: true, errors: [] }, null, 2));
-} catch (error) {
-  console.error(JSON.stringify({ success: false, errors: [String(error?.message ?? error)] }, null, 2));
-  process.exitCode = 1;
-}
-
-async function verifyRenderer(rendererPath) {
-  try {
-    const mod = await import(pathToFileURL(rendererPath).href);
-    const renderer = mod.default ?? mod.renderer;
-    if (!renderer || typeof renderer.renderPage !== 'function') {
-      throw new Error('renderer must export a GradialRenderer with renderPage');
-    }
-    return;
-  } catch (error) {
-    if (!shouldUseStaticFallback(error)) {
-      throw error;
-    }
-  }
-
-  const source = fs.readFileSync(rendererPath, 'utf8');
-  if (!staticallyExportsRenderPage(source)) {
-    throw new Error('renderer must export a GradialRenderer with renderPage');
-  }
-}
-
-function shouldUseStaticFallback(error) {
-  const message = String(error?.message ?? error);
-  return message.includes('Unknown file extension ".astro"');
-}
-
-function staticallyExportsRenderPage(source) {
-  if (!/\brenderPage\s*[:=]\s*(async\s*)?(\([^)]*\)|[A-Za-z_$][\w$]*)?\s*=>|\brenderPage\s*[:=]\s*(async\s*)?function\b|\basync\s+renderPage\s*\(|\brenderPage\s*\(/m.test(source)) {
-    return false;
-  }
-  if (/export\s+default\s+{[\s\S]*\brenderPage\b[\s\S]*}/m.test(source)) {
-    return true;
-  }
-  const defaultName = source.match(/export\s+default\s+([A-Za-z_$][\w$]*)\s*;?/m)?.[1];
-  const namedExport = source.match(/export\s*{\s*([A-Za-z_$][\w$]*)\s+as\s+renderer\s*}/m)?.[1] ?? source.match(/export\s*{\s*([A-Za-z_$][\w$]*)\s*}/m)?.[1];
-  const rendererName = defaultName ?? namedExport;
-  if (!rendererName) {
-    return false;
-  }
-  const declaration = new RegExp(`(?:const|let|var)\\s+${rendererName}\\b[\\s\\S]*?\\{[\\s\\S]*?\\brenderPage\\b`, 'm');
-  return declaration.test(source);
-}
-
-function parseArgs(argv) {
-  const out = {};
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (!arg.startsWith('--')) continue;
-    const body = arg.slice(2);
-    const equals = body.indexOf('=');
-    if (equals >= 0) {
-      out[body.slice(0, equals)] = body.slice(equals + 1);
-      continue;
-    }
-    out[body] = argv[++i];
-  }
-  return out;
-}

package/src/types/component.ts

@@ -1,59 +0,0 @@
-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;
-  /**
-   * 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?: 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/src/types/config.ts

@@ -1,38 +0,0 @@
-import type { RenderCapabilities } from './renderer.js';
-
-export interface BareMetalConfig {
-  version: '1';
-  siteId: string;
-  framework: 'astro' | 'next' | 'sveltekit' | 'custom';
-  source: {
-    root: string;
-    outDir?: string;
-    publicDir?: string;
-  };
-  componentRegistry: string;
-  dataRegistry?: string;
-  layoutRegistry: string;
-  rendererEntry: string;
-  capabilities: RenderCapabilities;
-  routes: RouteConfig;
-  dam?: DAMConfig;
-  externalDependencies?: ExternalDependency[];
-  rendererProtocol: 'http' | 'stdio-json';
-}
-
-export interface RouteConfig {
-  cmsManaged: string;
-  frameworkOwned?: string[];
-}
-
-export interface ExternalDependency {
-  name: string;
-  host: string;
-  kind?: 'api' | 'client-script';
-  description?: string;
-  cacheTTL?: number;
-}
-
-export interface DAMConfig {
-  autoApproveUploads?: boolean;
-}

package/src/types/data.ts

@@ -1,47 +0,0 @@
-import { z } from 'zod';
-
-type InferDataProps<TSchema> = TSchema extends z.ZodType<infer T>
-  ? T
-  : Record<string, unknown>;
-
-const dataRefPattern = /^\$ref:data\/[A-Za-z0-9][A-Za-z0-9_./-]*$/;
-
-export interface DataModelDefinition<TSchema = unknown, TType extends string = string> {
-  type: TType;
-  schema: TSchema;
-}
-
-export interface DataModelContract<TSchema = unknown, TType extends string = string> {
-  type: TType;
-  schema: TSchema;
-}
-
-export interface DataEntry<TProps = Record<string, unknown>, TType extends string = string> {
-  $type: TType;
-  props: TProps;
-}
-
-export type InferDataModelProps<TContract> = TContract extends DataModelContract<infer TSchema, string>
-  ? InferDataProps<TSchema>
-  : Record<string, unknown>;
-
-export type InferDataModelType<TContract> = TContract extends DataModelContract<unknown, infer TType>
-  ? TType
-  : string;
-
-export type DataModelRef<TContract extends DataModelContract> = DataEntry<
-  InferDataModelProps<TContract>,
-  InferDataModelType<TContract>
->;
-
-export function dataModelRef<TContract extends DataModelContract<z.ZodTypeAny>>(
-  contract: TContract,
-): z.ZodType<DataModelRef<TContract>> {
-  return z.union([
-    z.string().regex(dataRefPattern, `expected a $ref:data/... pointer for ${contract.type}`),
-    z.object({
-      $type: z.literal(contract.type),
-      props: contract.schema,
-    }),
-  ]).describe(`data model reference: ${contract.type}`) as unknown as z.ZodType<DataModelRef<TContract>>;
-}

package/src/types/index.ts

@@ -1,10 +0,0 @@
-export * from './config.js';
-export * from './component.js';
-export * from './data.js';
-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/src/types/layout.ts

@@ -1,29 +0,0 @@
-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/src/types/media.ts

@@ -1,125 +0,0 @@
-import { z } from 'zod';
-import { GradialImageSchema, renderImageHTML, type GradialImage } from './image.js';
-import { GradialVideoSchema, type GradialVideo } from './video.js';
-
-// ---------------------------------------------------------------------------
-// GradialAsset — union of all DAM-backed asset types
-//
-// Content authors write: { "$type": "dam.assetRef", "assetId": "..." }
-// The compiler resolves this to a GradialImage or GradialVideo based on
-// the asset's media type in the DAM.
-// ---------------------------------------------------------------------------
-
-/** Discriminated union of all compiler-resolved asset types. */
-export type GradialAsset = GradialImage | GradialVideo;
-
-// ---------------------------------------------------------------------------
-// Zod schema — discriminated on $type
-// ---------------------------------------------------------------------------
-
-export const GradialAssetSchema = z.discriminatedUnion('$type', [
-  GradialImageSchema,
-  GradialVideoSchema,
-]);
-
-// ---------------------------------------------------------------------------
-// Type guards
-// ---------------------------------------------------------------------------
-
-export function isGradialImage(value: unknown): value is GradialImage {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    (value as Record<string, unknown>).$type === 'gradial.image'
-  );
-}
-
-export function isGradialVideo(value: unknown): value is GradialVideo {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    (value as Record<string, unknown>).$type === 'gradial.video'
-  );
-}
-
-export function isGradialAsset(value: unknown): value is GradialAsset {
-  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: GradialVideo,
-  attrs: Record<string, string | number | boolean | undefined | null> = {},
-): string {
-  const posterSrc = video.poster?.fallback.src;
-  const attrPairs: Array<[string, string | number | boolean | undefined | null]> = [
-    ...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: GradialAsset,
-  attrs: Record<string, string | number | boolean | undefined | null> = {},
-): string {
-  if (asset.$type === 'gradial.image') {
-    return renderImageHTML(asset, attrs);
-  }
-  return renderVideoHTML(asset, attrs);
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-function renderAttrs(
-  pairs: Array<[string, string | number | boolean | undefined | null]>,
-): string {
-  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: string): string {
-  return name.replace(/[^A-Za-z0-9_:-]/g, '');
-}
-
-function escapeAttr(value: string): string {
-  return value
-    .replace(/&/g, '&amp;')
-    .replace(/"/g, '&quot;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;');
-}