@gradial/aci 0.1.18 → 0.1.20-preview.1

package/dist/next/content-watch.js

@@ -0,0 +1,106 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { WebSocketServer } from 'ws';
+import { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT, } from '../dev/browser.js';
+function sourceContentRoot() {
+    return path.resolve(process.env.ACI_CONTENT_SOURCE || './.content');
+}
+function compiledContentRoot() {
+    return path.resolve(process.env.ACI_CONTENT_ROOT || '.aci/compiled');
+}
+function resolveAciBin() {
+    return process.env.ACI_BIN || 'aci';
+}
+function recompileContent(reason) {
+    const siteDir = process.cwd();
+    const src = sourceContentRoot();
+    const out = compiledContentRoot();
+    const bin = resolveAciBin();
+    console.log(`[aci] compiling content (${reason})`);
+    const result = spawnSync(bin, [
+        '-s', siteDir,
+        'build',
+        '--content', src,
+        '--out', out,
+        '--skip-code',
+    ], {
+        cwd: siteDir,
+        stdio: 'inherit',
+        env: process.env,
+    });
+    if (result.status !== 0) {
+        console.error(`[aci] content compile failed with exit code ${result.status ?? 'unknown'}`);
+        return false;
+    }
+    return true;
+}
+let watcherStarted = false;
+function startContentWatcher() {
+    if (watcherStarted)
+        return;
+    watcherStarted = true;
+    const enabled = process.env.ACI_DISABLE_CONTENT_WATCH !== '1';
+    if (!enabled)
+        return;
+    const src = sourceContentRoot();
+    const wsPort = Number(process.env.ACI_DEV_WS_PORT || process.env.NEXT_PUBLIC_ACI_DEV_WS_PORT || DEFAULT_DEV_REFRESH_PORT);
+    const wsPath = process.env.ACI_DEV_WS_PATH || DEFAULT_DEV_REFRESH_PATH;
+    let timer;
+    let running = false;
+    let queued = false;
+    const server = http.createServer();
+    const wss = new WebSocketServer({ server, path: wsPath });
+    server.listen(wsPort, () => {
+        console.log(`[aci] dev refresh WebSocket on port ${wsPort}`);
+    });
+    function notifyClients() {
+        for (const client of wss.clients) {
+            if (client.readyState === 1) {
+                client.send(JSON.stringify({ type: 'content-updated' }));
+            }
+        }
+    }
+    function rebuild(reason) {
+        if (running) {
+            queued = true;
+            return;
+        }
+        running = true;
+        const success = recompileContent(reason);
+        running = false;
+        if (success) {
+            notifyClients();
+        }
+        if (queued) {
+            queued = false;
+            rebuild('queued change');
+        }
+    }
+    rebuild('startup');
+    try {
+        fs.watch(src, { recursive: true }, (_event, filename) => {
+            if (!filename)
+                return;
+            clearTimeout(timer);
+            timer = setTimeout(() => {
+                rebuild(path.relative(src, path.resolve(src, filename)));
+            }, 100);
+        });
+    }
+    catch {
+        console.warn('[aci] fs.watch not supported on this platform, content watch disabled');
+    }
+}
+export function createContentWatchWebpackPlugin() {
+    return {
+        apply(compiler) {
+            compiler.hooks['beforeCompile']?.tap('gradial-content-watch', () => {
+                if (process.env.NODE_ENV !== 'production') {
+                    startContentWatcher();
+                }
+            });
+        },
+    };
+}

package/dist/next/index.d.ts

@@ -1,4 +1,4 @@
 export { DevRefresh, type DevRefreshProps } from './dev-refresh.js';
-export { withGradial, type WithGradialOptions } from './config.js';
-export { PreviewBanner, type PreviewBannerProps } from './preview-banner.js';
+export { withGradialAci, type WithGradialOptions } from './config.js';
 export { isPreviewMode } from './preview-mode.js';
+export { createPreviewBannerHTML, createPreviewCookies, extractPreviewToken, resolvePreviewContext, PREVIEW_HEADER, RELEASE_HEADER, PREVIEW_TOKEN_COOKIE, PREVIEW_RELEASE_COOKIE, type PreviewContext, type PreviewClaims, type PreviewCookie, } from '../preview/core.js';

package/dist/next/index.js

@@ -1,4 +1,4 @@
 export { DevRefresh } from './dev-refresh.js';
-export { withGradial } from './config.js';
-export { PreviewBanner } from './preview-banner.js';
+export { withGradialAci } from './config.js';
 export { isPreviewMode } from './preview-mode.js';
+export { createPreviewBannerHTML, createPreviewCookies, extractPreviewToken, resolvePreviewContext, PREVIEW_HEADER, RELEASE_HEADER, PREVIEW_TOKEN_COOKIE, PREVIEW_RELEASE_COOKIE, } from '../preview/core.js';

package/dist/next/middleware.d.ts

@@ -1,7 +1,11 @@
 import { NextResponse, type NextRequest } from 'next/server.js';
 export interface GradialMiddlewareConfig {
-    siteId: string;
+    siteId?: string;
     edgeConfig?: string;
+    previewSignKey?: string;
     deploymentId?: string;
 }
-export declare function createGradialMiddleware(config: GradialMiddlewareConfig): (request: NextRequest) => Promise<NextResponse<unknown>>;
+export declare function createGradialMiddleware(config?: GradialMiddlewareConfig): (request: NextRequest) => Promise<NextResponse<unknown>>;
+export declare const config: {
+    matcher: string[];
+};

package/dist/next/middleware.js

@@ -1,92 +1,89 @@
 import { NextResponse } from 'next/server.js';
 import { getUncachedEdgeConfigValue } from './edge-config.js';
-import { validatePreviewToken } from './preview.js';
-const RELEASE_HEADER = 'x-gradial-release-id';
+import { PREVIEW_TOKEN_COOKIE, PREVIEW_RELEASE_COOKIE, PREVIEW_HEADER, RELEASE_HEADER, extractPreviewToken, resolvePreviewContext, createPreviewCookies, previewSignKey, } from '../preview/core.js';
 const ROUTE_HEADER = 'x-gradial-route';
 const DISPATCH_HEADER = 'x-gradial-dispatch';
-export function createGradialMiddleware(config) {
+export function createGradialMiddleware(config = {}) {
     return async function gradialMiddleware(request) {
         const url = request.nextUrl;
-        console.log('[gradial/mw] === middleware start ===');
-        console.log('[gradial/mw] path:', url.pathname, 'search:', url.search.slice(0, 100));
-        console.log('[gradial/mw] siteId:', config.siteId);
-        console.log('[gradial/mw] EDGE_CONFIG:', process.env.EDGE_CONFIG ? 'set' : 'NOT SET');
-        console.log('[gradial/mw] GRADIAL_PREVIEW_SIGN_KEY:', process.env.GRADIAL_PREVIEW_SIGN_KEY ? `set (${process.env.GRADIAL_PREVIEW_SIGN_KEY.length} chars, prefix: ${process.env.GRADIAL_PREVIEW_SIGN_KEY.slice(0, 6)})` : 'NOT SET');
-        console.log('[gradial/mw] VERCEL_DEPLOYMENT_ID:', process.env.VERCEL_DEPLOYMENT_ID || 'NOT SET');
         // ?leave_preview=1 → clear cookies, redirect to clean URL
         if (url.searchParams.get('leave_preview') === '1') {
-            console.log('[gradial/mw] leave_preview=1, clearing cookies and redirecting');
             const cleanUrl = new URL(url.pathname, url.origin);
             const response = NextResponse.redirect(cleanUrl);
-            response.cookies.delete('aci_preview');
-            response.cookies.delete('aci_preview_release');
+            response.cookies.delete(PREVIEW_TOKEN_COOKIE);
+            response.cookies.delete(PREVIEW_RELEASE_COOKIE);
             return response;
         }
         const requestHeaders = gradialHeaders(request.headers);
         // Try preview token first; if valid, use that release.
         // If no token or invalid, fall through to active release from edge config.
-        const previewReleaseId = await releaseIdFromPreviewToken(request, config);
-        console.log('[gradial/mw] previewReleaseId from token:', previewReleaseId || '(none)');
-        const releaseId = previewReleaseId || await activeReleaseFromEdgeConfig(config);
-        console.log('[gradial/mw] final releaseId:', releaseId || '(none)');
+        const preview = await resolvePreviewFromRequest(request, config);
+        const releaseId = preview?.releaseId || await activeReleaseFromEdgeConfig(config);
         if (!releaseId) {
-            console.log('[gradial/mw] no releaseId, passing through with no headers');
             return NextResponse.next({ request: { headers: requestHeaders } });
         }
         requestHeaders.set(RELEASE_HEADER, releaseId);
         requestHeaders.set(ROUTE_HEADER, url.pathname);
         requestHeaders.set(DISPATCH_HEADER, 'ssr-page');
-        if (previewReleaseId) {
-            requestHeaders.set('x-gradial-preview', '1');
-            console.log('[gradial/mw] set x-gradial-preview=1 and x-gradial-release-id:', releaseId);
-        }
-        else {
-            console.log('[gradial/mw] set x-gradial-release-id (active):', releaseId);
+        if (preview?.isPreview) {
+            requestHeaders.set(PREVIEW_HEADER, '1');
         }
         const response = NextResponse.next({ request: { headers: requestHeaders } });
         // Persist preview token as cookie so navigation stays in preview
-        const queryToken = url.searchParams.get('preview_token');
-        if (queryToken && previewReleaseId) {
-            console.log('[gradial/mw] setting preview cookies for release:', previewReleaseId);
-            response.cookies.set('aci_preview', queryToken, {
-                httpOnly: true,
-                sameSite: 'lax',
-                maxAge: 60 * 60,
-                path: '/',
-            });
-            response.cookies.set('aci_preview_release', previewReleaseId, {
-                httpOnly: false,
-                sameSite: 'lax',
-                maxAge: 60 * 60,
-                path: '/',
-            });
+        if (preview?.token && preview.isPreview) {
+            for (const cookie of createPreviewCookies(preview.token, releaseId)) {
+                response.cookies.set(cookie.name, cookie.value, cookie.options);
+            }
         }
-        console.log('[gradial/mw] === middleware end ===');
         return response;
     };
 }
+export const config = {
+    matcher: [
+        '/((?!_next/static|_next/image|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp)$).*)',
+    ],
+};
 function gradialHeaders(headers) {
     const next = new Headers(headers);
     next.delete(RELEASE_HEADER);
     next.delete(ROUTE_HEADER);
     next.delete(DISPATCH_HEADER);
+    next.delete(PREVIEW_HEADER);
     return next;
 }
+async function resolvePreviewFromRequest(request, config) {
+    const token = extractPreviewToken({
+        query: request.nextUrl.searchParams,
+        cookies: cookieMap(request.cookies),
+        authorization: request.headers.get('authorization') || undefined,
+    });
+    if (!token)
+        return null;
+    const signKey = previewSignKey();
+    if (!signKey) {
+        console.warn('[gradial/mw] GRADIAL_PREVIEW_SIGN_KEY not set — preview tokens will be ignored');
+        return null;
+    }
+    return await resolvePreviewContext({ token, siteId: config.siteId || '', signKey });
+}
+function cookieMap(cookies) {
+    const map = new Map();
+    for (const cookie of cookies.getAll()) {
+        map.set(cookie.name, cookie.value);
+    }
+    return map;
+}
 async function activeReleaseFromEdgeConfig(config) {
     const edgeConfig = config.edgeConfig || process.env.EDGE_CONFIG || '';
-    if (!edgeConfig || !config.siteId) {
-        console.log('[gradial/mw] activeRelease: no edgeConfig or siteId, skipping');
+    if (!edgeConfig || !config.siteId)
         return '';
-    }
     const active = await activeReleasePointer(edgeConfig, config.siteId);
-    console.log('[gradial/mw] activeRelease pointer:', JSON.stringify(active));
     if (!active.releaseId)
         return '';
     const deploymentId = config.deploymentId || process.env.VERCEL_DEPLOYMENT_ID || '';
     if (!deploymentId)
         return active.releaseId;
     const compatibility = await getEdgeConfigJSON(edgeConfig, deploymentCompatibilityKey(config.siteId, deploymentId));
-    console.log('[gradial/mw] compatibility:', compatibility ? JSON.stringify(compatibility) : '(none)');
     if (!compatibility)
         return active.releaseId;
     return clampRelease(active.releaseId, active.sequence || 0, compatibility);
@@ -146,42 +143,3 @@ function clampRelease(activeReleaseId, activeSequence, compatibility) {
 function edgeKeySegment(value) {
     return value.replace(/[^A-Za-z0-9_-]/g, '_');
 }
-async function releaseIdFromPreviewToken(request, config) {
-    const token = previewTokenFromRequest(request);
-    console.log('[gradial/mw] previewToken: token found:', !!token, 'len:', token.length);
-    if (!token)
-        return '';
-    const signKey = process.env.GRADIAL_PREVIEW_SIGN_KEY || '';
-    if (!signKey) {
-        console.warn('[gradial/mw] GRADIAL_PREVIEW_SIGN_KEY not set — preview tokens will be ignored');
-        return '';
-    }
-    console.log('[gradial/mw] signKey present, len:', signKey.length, 'prefix:', signKey.slice(0, 6));
-    console.log('[gradial/mw] calling validatePreviewToken...');
-    const claims = await validatePreviewToken(token, signKey);
-    console.log('[gradial/mw] validatePreviewToken result:', claims ? JSON.stringify(claims) : 'null');
-    if (!claims || claims.scope !== 'preview' || !claims.releaseId) {
-        console.log('[gradial/mw] claims invalid: scope=', claims?.scope, 'releaseId=', claims?.releaseId);
-        return '';
-    }
-    if (claims.siteId && config.siteId && claims.siteId !== config.siteId) {
-        console.log('[gradial/mw] siteId mismatch: token=', claims.siteId, 'config=', config.siteId);
-        return '';
-    }
-    if (!claims.expiresAt || Date.parse(claims.expiresAt) <= Date.now()) {
-        console.log('[gradial/mw] token expired or no expiresAt:', claims.expiresAt);
-        return '';
-    }
-    console.log('[gradial/mw] preview token valid! releaseId:', claims.releaseId);
-    return claims.releaseId;
-}
-function previewTokenFromRequest(request) {
-    const queryToken = request.nextUrl.searchParams.get('preview_token');
-    if (queryToken)
-        return queryToken;
-    const cookieToken = request.cookies.get('aci_preview')?.value || '';
-    if (cookieToken)
-        return cookieToken;
-    const auth = request.headers.get('authorization') || '';
-    return auth.startsWith('Bearer ') ? auth.slice('Bearer '.length) : '';
-}

package/dist/next/page.d.ts

@@ -0,0 +1,41 @@
+import type { Metadata } from 'next';
+import { type KernelPage } from '../content/index.js';
+import type { Registry } from '../registry.js';
+type NextPageProps = {
+    params: Promise<{
+        slug?: string[];
+    }>;
+};
+export type SlotPropsFn = (slotName: string, page: KernelPage) => Record<string, unknown> | undefined;
+export interface CreatePageOptions {
+    slotProps?: SlotPropsFn;
+}
+/**
+ * Creates the catch-all route handler for a Next.js ACI site.
+ *
+ * Usage in `src/app/[[...slug]]/page.tsx`:
+ *
+ * ```tsx
+ * import { createPage } from '@gradial/aci/next/page';
+ * import { registry } from '@/cms/registry';
+ *
+ * const page = createPage(registry);
+ * export const dynamic = page.dynamic;
+ * export const generateMetadata = page.generateMetadata;
+ * export default page.default;
+ * ```
+ *
+ * The SDK owns param normalization, content loading, metadata generation,
+ * notFound handling, layout resolution, and block rendering via the registry.
+ *
+ * Layout slots: createPage loads the page's layout, iterates all slots, and
+ * fills each from the page's regions. If a slot is empty, it falls back to
+ * the layout's fragment defaults (loaded via getFragment). This lets chrome
+ * be CMS-managed fragments instead of hardcoded component imports.
+ */
+export declare function createPage(registry: Registry, options?: CreatePageOptions): {
+    dynamic: "force-dynamic";
+    generateMetadata: ({ params }: NextPageProps) => Promise<Metadata>;
+    default: ({ params }: NextPageProps) => Promise<import("react").JSX.Element>;
+};
+export {};

package/dist/next/page.js

@@ -0,0 +1,77 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { notFound } from 'next/navigation.js';
+import { Fragment } from 'react';
+import { PageNotFoundError, routeFromNextParams, getRenderInput, getLayout, getFragment, } from './server.js';
+import { routeMetadataForContent, resolveSlots, } from '../content/index.js';
+import { renderBlocks } from './render.js';
+/**
+ * Creates the catch-all route handler for a Next.js ACI site.
+ *
+ * Usage in `src/app/[[...slug]]/page.tsx`:
+ *
+ * ```tsx
+ * import { createPage } from '@gradial/aci/next/page';
+ * import { registry } from '@/cms/registry';
+ *
+ * const page = createPage(registry);
+ * export const dynamic = page.dynamic;
+ * export const generateMetadata = page.generateMetadata;
+ * export default page.default;
+ * ```
+ *
+ * The SDK owns param normalization, content loading, metadata generation,
+ * notFound handling, layout resolution, and block rendering via the registry.
+ *
+ * Layout slots: createPage loads the page's layout, iterates all slots, and
+ * fills each from the page's regions. If a slot is empty, it falls back to
+ * the layout's fragment defaults (loaded via getFragment). This lets chrome
+ * be CMS-managed fragments instead of hardcoded component imports.
+ */
+export function createPage(registry, options) {
+    const dynamic = 'force-dynamic';
+    async function generateMetadata({ params }) {
+        const route = await routeFromNextParams(params);
+        const input = await getRenderInput(route);
+        const meta = routeMetadataForContent(input.siteConfig, input.page);
+        return {
+            title: meta.title,
+            description: meta.description,
+            alternates: meta.canonical ? { canonical: meta.canonical } : undefined,
+            openGraph: {
+                title: meta.title,
+                description: meta.description,
+                siteName: meta.siteName,
+            },
+        };
+    }
+    async function CatchAllPage({ params }) {
+        const route = await routeFromNextParams(params);
+        try {
+            const input = await getRenderInput(route);
+            if (!input.page || input.page.status !== 'published')
+                notFound();
+            const layout = await getLayout(input.page.layout);
+            const resolvedSlots = await resolveSlots(layout, input.page.regions || {}, (id) => getFragment(id));
+            return (_jsx(_Fragment, { children: layout.slots.map((slot) => {
+                    const blocks = resolvedSlots[slot.name];
+                    if (!blocks?.length)
+                        return null;
+                    const extraProps = options?.slotProps?.(slot.name, input.page);
+                    if (slot.name === 'main') {
+                        return (_jsx("main", { id: "content-main", children: renderBlocks(blocks, registry, extraProps) }, "main"));
+                    }
+                    return (_jsx(Fragment, { children: renderBlocks(blocks, registry, extraProps) }, slot.name));
+                }) }));
+        }
+        catch (error) {
+            if (error instanceof PageNotFoundError)
+                notFound();
+            throw error;
+        }
+    }
+    return {
+        dynamic,
+        generateMetadata,
+        default: CatchAllPage,
+    };
+}

package/dist/next/preview-mode.js

@@ -1,18 +1,9 @@
 import { headers } from 'next/headers.js';
-const RELEASE_HEADER = 'x-gradial-release-id';
-const PREVIEW_HEADER = 'x-gradial-preview';
+import { PREVIEW_HEADER, RELEASE_HEADER } from '../preview/core.js';
 export async function isPreviewMode() {
-    try {
-        const current = await headers();
-        const previewFlag = current.get(PREVIEW_HEADER);
-        const releaseId = current.get(RELEASE_HEADER);
-        console.log('[gradial/server] isPreviewMode: x-gradial-preview=', previewFlag, 'x-gradial-release-id=', releaseId || '(none)');
-        if (previewFlag === '1') {
-            return releaseId || '';
-        }
-    }
-    catch (err) {
-        console.log('[gradial/server] isPreviewMode error:', String(err));
+    const current = await headers();
+    if (current.get(PREVIEW_HEADER) === '1') {
+        return current.get(RELEASE_HEADER) || '';
     }
     return '';
 }

package/dist/next/render.d.ts

@@ -0,0 +1,5 @@
+import type { ReactElement } from 'react';
+import type { Registry } from '../registry.js';
+import type { KernelPageBlock } from '../content/types.js';
+export declare function renderBlock(block: KernelPageBlock, registry: Registry, extraProps?: Record<string, unknown>): ReactElement | null;
+export declare function renderBlocks(blocks: readonly KernelPageBlock[], registry: Registry, extraProps?: Record<string, unknown>): (ReactElement | null)[];

package/dist/next/render.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function renderBlock(block, registry, extraProps) {
+    const entry = registry.find((r) => r.name === block.component);
+    if (!entry) {
+        if (process.env.NODE_ENV !== 'production') {
+            return (_jsxs("div", { className: "mx-auto my-4 max-w-[var(--max-width-container)] rounded-card border-2 border-red-600 bg-red-50 px-5 py-4 font-mono text-sm leading-relaxed text-red-900", children: [_jsx("strong", { children: "Unknown block:" }), " ", _jsx("code", { children: block.component }), _jsx("br", {}), _jsxs("span", { className: "text-red-800 opacity-70", children: ["id: ", block.id] })] }, block.id));
+        }
+        return null;
+    }
+    const Component = entry.component;
+    return _jsx(Component, { ...block.props, ...extraProps }, block.id);
+}
+export function renderBlocks(blocks, registry, extraProps) {
+    return blocks.map((block) => renderBlock(block, registry, extraProps));
+}

package/dist/next/root-layout.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from 'react';
+export declare function RootLayout({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/next/root-layout.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { DevRefresh } from './dev-refresh.js';
+export function RootLayout({ children }) {
+    return (_jsx("html", { lang: "en", children: _jsxs("body", { children: [children, _jsx(DevRefresh, {})] }) }));
+}

package/dist/next/server.d.ts

@@ -1,6 +1,6 @@
-import { FragmentNotFoundError, PageNotFoundError } from '../content/provider.js';
+import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError } from '../content/provider.js';
 import type { RenderInput } from '../content/types.js';
-export { FragmentNotFoundError, PageNotFoundError };
+export { FragmentNotFoundError, PageNotFoundError, LayoutNotFoundError };
 export interface GradialFetchConfig {
     siteId?: string;
     bucket?: string;
@@ -29,6 +29,7 @@ export interface GradialSiteConfig {
 export declare function getPage<T = unknown>(route?: string, config?: GradialFetchConfig): Promise<T>;
 export declare function getSiteConfig<T extends GradialSiteConfig = GradialSiteConfig>(config?: GradialFetchConfig): Promise<T>;
 export declare function getFragment<T = unknown>(name: string, config?: GradialFetchConfig): Promise<T>;
+export declare function getLayout<T = unknown>(name: string, config?: GradialFetchConfig): Promise<T>;
 export declare function getRoutes(config?: GradialFetchConfig): Promise<string[]>;
 export declare function getRenderInput<TPage, TSite extends GradialSiteConfig = GradialSiteConfig>(route?: string, config?: GradialFetchConfig): Promise<GradialRenderInput<TPage, TSite>>;
 export declare function getPageRuntimeRenderInput(): Promise<RenderInput | null>;

package/dist/next/server.js

@@ -1,12 +1,12 @@
 import { headers } from 'next/headers.js';
-import { FragmentNotFoundError, PageNotFoundError, } from '../content/provider.js';
+import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError, } from '../content/provider.js';
 import { getCachedManifest, getCachedSiteConfig } from '../content/cache.js';
 import { S3ContentProvider } from '../providers/s3.js';
 import { GRADIAL_RENDER_INPUT_HEADER, getPendingRenderInput } from '../runtime/page.js';
 import { getUncachedEdgeConfigValue } from './edge-config.js';
 const RELEASE_HEADER = 'x-gradial-release-id';
 const PREVIEW_HEADER = 'x-gradial-preview';
-export { FragmentNotFoundError, PageNotFoundError };
+export { FragmentNotFoundError, PageNotFoundError, LayoutNotFoundError };
 export async function getPage(route = '', config = {}) {
     const runtimeInput = await getPageRuntimeRenderInput();
     if (runtimeInput)
@@ -31,29 +31,33 @@ export async function getFragment(name, config = {}) {
     const provider = await resolveProviderWithFallback(config);
     return await provider.getFragment(name);
 }
+export async function getLayout(name, config = {}) {
+    const runtimeInput = await getPageRuntimeRenderInput();
+    if (runtimeInput) {
+        const layouts = runtimeInput.layouts || {};
+        if (name in layouts)
+            return layouts[name];
+    }
+    const provider = await resolveProviderWithFallback(config);
+    return await provider.getLayout(name);
+}
 export async function getRoutes(config = {}) {
     const provider = await resolveProviderWithFallback(config);
     const routes = await provider.listRoutes();
     return routes.map((route) => route.path).sort();
 }
 export async function getRenderInput(route = '/', config = {}) {
-    const startTime = Date.now();
     const runtimeInput = await getPageRuntimeRenderInput();
     if (runtimeInput) {
         return runtimeInput;
     }
-    const providerStart = Date.now();
     const provider = await resolveProviderWithFallback(config);
-    console.log(`[ACI SSR] Provider resolved in ${Date.now() - providerStart}ms`);
     // Cache shared resources (manifest, siteConfig) but not per-page content
     // Page-level caching is handled by CDN
-    const fetchStart = Date.now();
     const [page, siteConfig] = await Promise.all([
         provider.getPage(route),
         getCachedSiteConfig(provider),
     ]);
-    console.log(`[ACI SSR] Content fetched in ${Date.now() - fetchStart}ms`);
-    console.log(`[ACI SSR] Total getRenderInput for ${route}: ${Date.now() - startTime}ms`);
     return {
         route,
         domain: siteConfig.domain || 'www.aci.local',

package/dist/preview/core.d.ts

@@ -0,0 +1,41 @@
+export interface PreviewClaims {
+    scope?: string;
+    releaseId?: string;
+    siteId?: string;
+    expiresAt?: string;
+}
+export interface PreviewTokenSource {
+    query?: URLSearchParams;
+    cookies?: Map<string, string> | Record<string, string>;
+    authorization?: string;
+}
+export interface PreviewResolveOptions {
+    siteId: string;
+    signKey?: string;
+    token?: string;
+}
+export interface PreviewContext {
+    isPreview: boolean;
+    releaseId?: string;
+    token?: string;
+}
+export interface PreviewCookie {
+    name: string;
+    value: string;
+    options: {
+        httpOnly: boolean;
+        sameSite: 'lax' | 'strict' | 'none';
+        maxAge: number;
+        path: string;
+    };
+}
+export declare const PREVIEW_HEADER = "x-gradial-preview";
+export declare const RELEASE_HEADER = "x-gradial-release-id";
+export declare const PREVIEW_TOKEN_COOKIE = "aci_preview";
+export declare const PREVIEW_RELEASE_COOKIE = "aci_preview_release";
+export declare function validatePreviewToken(token: string, signKey: string): Promise<PreviewClaims | null>;
+export declare function extractPreviewToken(source: PreviewTokenSource): string | undefined;
+export declare function previewSignKey(): string | undefined;
+export declare function resolvePreviewContext(options: PreviewResolveOptions): Promise<PreviewContext>;
+export declare function createPreviewCookies(token: string, releaseId: string): PreviewCookie[];
+export declare function createPreviewBannerHTML(releaseId: string): string;