@gradial/aci 0.1.20-preview.2 → 0.1.20

package/dist/content/cache.test.js

@@ -1,86 +0,0 @@
-import { describe, it, expect, beforeEach } from '@jest/globals';
-import { getCachedSiteConfig, getCachedManifest, clearProviderCache, getCacheStats, resetCacheStats } from './cache.js';
-describe('Content Cache', () => {
-    let mockProvider;
-    let getSiteConfigCallCount = 0;
-    let manifestCallCount = 0;
-    beforeEach(() => {
-        getSiteConfigCallCount = 0;
-        manifestCallCount = 0;
-        resetCacheStats();
-        mockProvider = {
-            getSiteConfig: async () => {
-                getSiteConfigCallCount++;
-                return { title: 'Test Site' };
-            },
-            manifest: async () => {
-                manifestCallCount++;
-                return {
-                    routes: {},
-                    fragments: {},
-                    siteConfigRef: 'site.json'
-                };
-            },
-            getPage: async () => ({}),
-            getFragment: async () => ({}),
-            listRoutes: async () => []
-        };
-    });
-    it('should cache siteConfig across multiple calls', async () => {
-        const result1 = await getCachedSiteConfig(mockProvider);
-        const result2 = await getCachedSiteConfig(mockProvider);
-        expect(getSiteConfigCallCount).toBe(1); // Only called once
-        expect(result1).toEqual(result2);
-        const stats = getCacheStats();
-        expect(stats.siteConfig.hits).toBe(1);
-        expect(stats.siteConfig.misses).toBe(1);
-    });
-    it('should cache manifest across multiple calls', async () => {
-        const result1 = await getCachedManifest(mockProvider);
-        const result2 = await getCachedManifest(mockProvider);
-        expect(manifestCallCount).toBe(1); // Only called once
-        expect(result1).toEqual(result2);
-        const stats = getCacheStats();
-        expect(stats.manifest.hits).toBe(1);
-        expect(stats.manifest.misses).toBe(1);
-    });
-    it('should clear cache for a provider', async () => {
-        await getCachedSiteConfig(mockProvider);
-        expect(getSiteConfigCallCount).toBe(1);
-        clearProviderCache(mockProvider);
-        await getCachedSiteConfig(mockProvider);
-        expect(getSiteConfigCallCount).toBe(2); // Called again after clear
-        const stats = getCacheStats();
-        expect(stats.siteConfig.misses).toBe(2);
-    });
-    it('should not cache rejected promises', async () => {
-        const errorProvider = {
-            getSiteConfig: async () => {
-                getSiteConfigCallCount++;
-                throw new Error('S3 timeout');
-            },
-            getPage: async () => ({}),
-            getFragment: async () => ({}),
-            listRoutes: async () => []
-        };
-        await expect(getCachedSiteConfig(errorProvider)).rejects.toThrow('S3 timeout');
-        expect(getSiteConfigCallCount).toBe(1);
-        // Second call should retry (not cached)
-        await expect(getCachedSiteConfig(errorProvider)).rejects.toThrow('S3 timeout');
-        expect(getSiteConfigCallCount).toBe(2);
-    });
-    it('should cache separately per provider instance', async () => {
-        const provider2 = {
-            getSiteConfig: async () => ({ title: 'Site 2' }),
-            getPage: async () => ({}),
-            getFragment: async () => ({}),
-            listRoutes: async () => []
-        };
-        const result1 = await getCachedSiteConfig(mockProvider);
-        const result2 = await getCachedSiteConfig(provider2);
-        expect(result1).toEqual({ title: 'Test Site' });
-        expect(result2).toEqual({ title: 'Site 2' });
-        const stats = getCacheStats();
-        expect(stats.siteConfig.misses).toBe(2); // Both are cache misses
-    });
-});

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,184 +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),
-        renderMode: 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/next/preview-banner.d.ts

@@ -1,4 +0,0 @@
-export interface PreviewBannerProps {
-    releaseId?: string;
-}
-export declare function PreviewBanner({ releaseId }: PreviewBannerProps): import("react").JSX.Element | null;

package/dist/next/preview-banner.js

@@ -1,51 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-export function PreviewBanner({ releaseId }) {
-    if (!releaseId)
-        return null;
-    const shortId = releaseId.length > 20
-        ? `${releaseId.slice(0, 8)}\u2026${releaseId.slice(-6)}`
-        : releaseId;
-    return (_jsxs("div", { role: "alert", style: {
-            position: 'fixed',
-            top: 0,
-            left: 0,
-            right: 0,
-            zIndex: 9999,
-            display: 'flex',
-            alignItems: 'center',
-            justifyContent: 'center',
-            gap: '12px',
-            padding: '8px 16px',
-            backgroundColor: '#1a1a2e',
-            color: '#fff',
-            fontSize: '13px',
-            fontFamily: 'system-ui, -apple-system, sans-serif',
-            boxShadow: '0 2px 8px rgba(0,0,0,0.3)',
-        }, children: [_jsx("span", { "aria-hidden": "true", style: {
-                    display: 'inline-flex',
-                    alignItems: 'center',
-                    justifyContent: 'center',
-                    width: '18px',
-                    height: '18px',
-                    borderRadius: '50%',
-                    backgroundColor: '#f59e0b',
-                    color: '#1a1a2e',
-                    fontWeight: 700,
-                    fontSize: '11px',
-                    flexShrink: 0,
-                }, children: "P" }), _jsx("span", { style: { fontWeight: 500 }, children: "Release Preview" }), _jsx("span", { style: {
-                    fontFamily: 'monospace',
-                    opacity: 0.7,
-                    fontSize: '12px',
-                }, title: releaseId, children: shortId }), _jsx("a", { href: "?leave_preview=1", style: {
-                    marginLeft: 'auto',
-                    padding: '4px 12px',
-                    borderRadius: '6px',
-                    backgroundColor: '#dc2626',
-                    color: '#fff',
-                    textDecoration: 'none',
-                    fontSize: '12px',
-                    fontWeight: 600,
-                    whiteSpace: 'nowrap',
-                }, children: "Exit Preview" })] }));
-}

package/dist/next/preview.d.ts

@@ -1,7 +0,0 @@
-export interface PreviewClaims {
-    releaseId?: string;
-    siteId?: string;
-    expiresAt?: string;
-    scope?: string;
-}
-export declare function validatePreviewToken(token: string, signKey: string): Promise<PreviewClaims | null>;