@gradial/aci 0.1.20-preview.1 → 0.1.20-preview.2

package/README.md

@@ -10,9 +10,9 @@ content provider helpers, and framework-specific subpaths from one package.
 The fastest way to create a new ACI site is via the scaffolding script:
 
 ```bash
-pnpm exec tsx scripts/create-site.ts --framework astro --name my-site --dir ./my-site
+npx tsx scripts/create-site.ts --framework astro --name my-site --dir ./my-site
 cd my-site
-pnpm run dev
+npm run dev
 ```
 
 Available frameworks: `astro`, `nextjs`, `sveltekit`.
@@ -28,8 +28,8 @@ See the [templates directory](templates/) for the canonical starter source.
 ## Installation
 
 ```bash
-pnpm add @gradial/aci zod@^4
-pnpm add -D typescript tsx
+npm install @gradial/aci zod@^4
+npm install -D typescript tsx
 ```
 
 Common imports:
@@ -78,6 +78,7 @@ export const heroContract = defineComponentContract({
     headline: z.string(),
     image: GradialImageSchema,
   }),
+  renderModes: { canStatic: true, canSSR: true, canClientIsland: false },
 });
 
 export type HeroProps = z.infer<typeof heroContract.schema>;
@@ -106,6 +107,7 @@ const content = new FixtureContentProvider({
       $type: 'page',
       status: 'published',
       layout: 'marketing',
+      renderMode: 'static',
       metadata: { title: 'Test Home' },
       regions: { main: [] }
     }
@@ -121,7 +123,7 @@ Use this in unit tests when you want the same provider API as
 Publish from this package directory:
 
 ```bash
-pnpm publish --access public
+npm publish --access public
 ```
 
 The package includes a `prepack` script that builds `dist` before packing or
@@ -129,15 +131,15 @@ publishing.
 
 ## Verify the Published Shape Locally
 
-Before publishing, inspect the exact tarball pnpm will upload. This catches
+Before publishing, inspect the exact tarball npm will upload. This catches
 package `files` mistakes where local source imports work from the repo but fail
-after pnpm filters the packed files.
+after npm filters the packed files.
 
 From `packages/sdk`:
 
 ```bash
 tmpdir="$(mktemp -d /tmp/gradial-aci-pack.XXXXXX)"
-filename="$(pnpm pack --pack-destination "$tmpdir" | tail -n 1)"
+filename="$(npm pack --pack-destination "$tmpdir" | tail -n 1)"
 tar -tzf "$tmpdir/$filename" | sort | rg '^(package/src/cli/|package/src/types/|package/dist/types/)'
 echo "tarball=$tmpdir/$filename"
 ```

package/dist/astro/index.d.ts

@@ -33,8 +33,6 @@ export declare function getGradialStaticPaths(): Promise<Array<{
     };
 }>>;
 export declare function getPageRuntimeRenderInput(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 interface GradialAstroOptions extends GradialContentWatchOptions {
     /** Path to compiled content root. Defaults to ACI_CONTENT_ROOT env or '.aci/compiled' */

package/dist/astro/index.js

@@ -32,10 +32,6 @@ export function getPageRuntimeRenderInput(request) {
     return getPendingRenderInputFromHeaders(request.headers);
 }
 // ---------------------------------------------------------------------------
-// Registry helpers
-// ---------------------------------------------------------------------------
-export { createRegistry, registryLookup } from '../registry.js';
-// ---------------------------------------------------------------------------
 // Preview support
 // ---------------------------------------------------------------------------
 export { getPreviewMode, createPreviewBannerHTML, createPreviewCookies, } from './preview.js';

package/dist/content/cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/content/cache.test.js

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

@@ -2,4 +2,3 @@ export * from './provider.js';
 export * from './routes.js';
 export * from './types.js';
 export * from './cache.js';
-export * from './resolve-slots.js';

package/dist/content/index.js

@@ -2,4 +2,3 @@ export * from './provider.js';
 export * from './routes.js';
 export * from './types.js';
 export * from './cache.js';
-export * from './resolve-slots.js';

package/dist/content/provider.d.ts

@@ -12,33 +12,17 @@ export interface FragmentEntry {
     digest: string;
     fragmentRefs?: string[];
 }
-export interface LayoutEntry {
-    name: string;
-    slots: LayoutSlot[];
-    defaults?: Record<string, FragmentRef[]>;
-}
-export interface LayoutSlot {
-    name: string;
-    required: boolean;
-}
-export interface FragmentRef {
-    kind: string;
-    fragmentId: string;
-    inline: boolean;
-}
 export interface CompiledManifest {
     manifestVersion: string;
     buildDigest: string;
     siteConfigRef: string;
     routes: Record<string, RouteEntry>;
     fragments: Record<string, FragmentEntry>;
-    layouts?: Record<string, LayoutEntry>;
 }
 export interface ContentProvider {
     getSiteConfig<T = unknown>(): Promise<T>;
     getPage<T = unknown>(route: string): Promise<T>;
     getFragment<T = unknown>(id: string): Promise<T>;
-    getLayout<T = unknown>(name: string): Promise<T>;
     listRoutes(): Promise<RouteEntry[]>;
 }
 export declare class PageNotFoundError extends Error {
@@ -47,9 +31,6 @@ export declare class PageNotFoundError extends Error {
 export declare class FragmentNotFoundError extends Error {
     constructor(id: string, cause?: unknown);
 }
-export declare class LayoutNotFoundError extends Error {
-    constructor(name: string, cause?: unknown);
-}
 export interface RenderInputOptions {
     domain?: string;
     locale?: string;

package/dist/content/provider.js

@@ -16,13 +16,6 @@ export class FragmentNotFoundError extends Error {
         this.cause = cause;
     }
 }
-export class LayoutNotFoundError extends Error {
-    constructor(name, cause) {
-        super(`Layout not found: ${name}`);
-        this.name = 'LayoutNotFoundError';
-        this.cause = cause;
-    }
-}
 import { getCachedSiteConfig } from './cache.js';
 export async function loadRenderInput(provider, route = '/', options = {}) {
     const normalized = normalizeRoute(route);

package/dist/content/types.d.ts

@@ -55,6 +55,7 @@ export interface KernelPage {
     $type: 'page';
     status: string;
     layout: string;
+    renderMode: string;
     metadata: KernelPageSeo;
     regions: Record<string, KernelPageBlock[]>;
 }
@@ -92,7 +93,6 @@ export interface RenderInput<TPage extends KernelPage = KernelPage, TSiteConfig
     siteConfig: TSiteConfig;
     page: TPage | null;
     fragments?: Record<string, unknown>;
-    layouts?: Record<string, unknown>;
 }
 export interface RenderOutput {
     route: string;

package/dist/content/validation.js

@@ -121,6 +121,7 @@ export function createContentSchemas(contracts = {}) {
         $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(),

package/dist/define-component.js

@@ -1,6 +1,12 @@
 export function defineComponent(definition) {
+    const renderModes = definition.renderModes ?? definition.render;
+    if (!renderModes) {
+        throw new Error(`component ${definition.name} must define renderModes`);
+    }
     return {
         ...definition,
+        renderModes,
+        render: renderModes,
         varyDimensions: definition.varyDimensions ?? definition.vary,
         vary: definition.vary ?? definition.varyDimensions,
     };

package/dist/define-layout.d.ts

@@ -1,6 +1,4 @@
 import type { LayoutContract, LayoutDefinition, LayoutSlot } from './types/layout.js';
-import type { FragmentRefNode } from './types/page.js';
 export declare function defineLayout(definition: LayoutDefinition): LayoutContract;
 export declare const defineLayoutContract: typeof defineLayout;
 export declare function slot(name: string, required?: boolean): LayoutSlot;
-export declare function fragmentDefault(fragmentId: string): FragmentRefNode;

package/dist/define-layout.js

@@ -9,6 +9,3 @@ export const defineLayoutContract = defineLayout;
 export function slot(name, required = false) {
     return { name, required };
 }
-export function fragmentDefault(fragmentId) {
-    return { kind: 'fragment-ref', fragmentId, inline: true };
-}

package/dist/index.d.ts

@@ -2,5 +2,4 @@ export * from './block-ref.js';
 export * from './define-component.js';
 export * from './define-data-model.js';
 export * from './define-layout.js';
-export * from './registry.js';
 export * from './types/index.js';

package/dist/index.js

@@ -2,7 +2,6 @@ export * from './block-ref.js';
 export * from './define-component.js';
 export * from './define-data-model.js';
 export * from './define-layout.js';
-export * from './registry.js';
 export * from './types/index.js';
 // Note: content/ is NOT re-exported here because it imports node:path,
 // making it incompatible with client-side bundlers. Import server-only

package/dist/next/asset-route.d.ts

@@ -5,7 +5,5 @@ type AssetRouteParams = {
     releaseId?: string;
     path?: string[];
 };
-export declare const runtime = "nodejs";
-export declare const dynamic = "force-dynamic";
 export declare function GET(_request: Request, { params }: AssetRouteContext): Promise<Response>;
 export {};

package/dist/next/asset-route.js

@@ -1,19 +1,11 @@
-import { FileContentProvider } from '../providers/file.js';
 import { getReleaseAssetResponse } from './server.js';
-const LOCAL_RELEASE_ID = 'local';
-export const runtime = 'nodejs';
-export const dynamic = 'force-dynamic';
 export async function GET(_request, { params }) {
     const resolvedParams = await params;
     const releaseId = resolvedParams.releaseId || '';
-    const assetPath = '/' + (resolvedParams.path || []).join('/');
-    if (!releaseId || assetPath === '/') {
+    const assetPath = (resolvedParams.path || []).join('/');
+    if (!releaseId || !assetPath) {
         return new Response('asset not found', { status: 404 });
     }
-    if (releaseId === LOCAL_RELEASE_ID) {
-        const provider = new FileContentProvider();
-        return provider.fetchRaw(assetPath);
-    }
     try {
         return await getReleaseAssetResponse(releaseId, assetPath);
     }

package/dist/next/config.js

@@ -9,7 +9,7 @@ export function withGradialAci(nextConfig = {}, options = {}) {
             const gradialRewrites = [
                 {
                     source: `${assetPrefix}/:path*`,
-                    destination: `/gradial/assets/local${assetPrefix}/:path*`,
+                    destination: `/api/aci-assets${assetPrefix}/:path*`,
                 },
             ];
             if (!userRewrites)

package/dist/next/middleware.d.ts

@@ -1,11 +1,7 @@
 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 const config: {
-    matcher: string[];
-};
+export declare function createGradialMiddleware(config: GradialMiddlewareConfig): (request: NextRequest) => Promise<NextResponse<unknown>>;

package/dist/next/middleware.js

@@ -3,7 +3,7 @@ import { getUncachedEdgeConfigValue } from './edge-config.js';
 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;
         // ?leave_preview=1 → clear cookies, redirect to clean URL
@@ -38,11 +38,6 @@ export function createGradialMiddleware(config = {}) {
         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);
@@ -64,7 +59,7 @@ async function resolvePreviewFromRequest(request, config) {
         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 });
+    return await resolvePreviewContext({ token, siteId: config.siteId, signKey });
 }
 function cookieMap(cookies) {
     const map = new Map();

package/dist/next/page.d.ts

@@ -1,39 +1,38 @@
+import type { ComponentType } from 'react';
 import type { Metadata } from 'next';
-import { type KernelPage } from '../content/index.js';
-import type { Registry } from '../registry.js';
+import { type KernelPage, type KernelSiteConfig } from '../content/index.js';
+export interface AciPageProps {
+    page: KernelPage;
+    siteConfig: KernelSiteConfig;
+}
+export interface CreateAciPageOptions {
+    /** The site's CmsPage component that renders chrome + content blocks. */
+    CmsPage: ComponentType<AciPageProps>;
+}
 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';
+ * import { createAciPage } from '@gradial/aci/next/page';
+ * import { CmsPage } from '@/components/CmsPage';
  *
- * const page = createPage(registry);
+ * const page = createAciPage({ CmsPage });
  * 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.
+ * and notFound handling. The site only provides its CmsPage component.
  */
-export declare function createPage(registry: Registry, options?: CreatePageOptions): {
+export declare function createAciPage({ CmsPage }: CreateAciPageOptions): {
     dynamic: "force-dynamic";
     generateMetadata: ({ params }: NextPageProps) => Promise<Metadata>;
     default: ({ params }: NextPageProps) => Promise<import("react").JSX.Element>;

package/dist/next/page.js

@@ -1,33 +1,26 @@
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx } 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';
+import { PageNotFoundError, routeFromNextParams, getRenderInput, } from './server.js';
+import { routeMetadataForContent, } from '../content/index.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';
+ * import { createAciPage } from '@gradial/aci/next/page';
+ * import { CmsPage } from '@/components/CmsPage';
  *
- * const page = createPage(registry);
+ * const page = createAciPage({ CmsPage });
  * 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.
+ * and notFound handling. The site only provides its CmsPage component.
  */
-export function createPage(registry, options) {
+export function createAciPage({ CmsPage }) {
     const dynamic = 'force-dynamic';
     async function generateMetadata({ params }) {
         const route = await routeFromNextParams(params);
@@ -50,18 +43,7 @@ export function createPage(registry, options) {
             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));
-                }) }));
+            return _jsx(CmsPage, { page: input.page, siteConfig: input.siteConfig });
         }
         catch (error) {
             if (error instanceof PageNotFoundError)

package/dist/next/preview-banner.d.ts

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

package/dist/next/preview-banner.js

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

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

package/dist/next/preview.js

@@ -0,0 +1,37 @@
+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/next/server.d.ts

@@ -1,6 +1,6 @@
-import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError } from '../content/provider.js';
+import { FragmentNotFoundError, PageNotFoundError } from '../content/provider.js';
 import type { RenderInput } from '../content/types.js';
-export { FragmentNotFoundError, PageNotFoundError, LayoutNotFoundError };
+export { FragmentNotFoundError, PageNotFoundError };
 export interface GradialFetchConfig {
     siteId?: string;
     bucket?: string;
@@ -29,7 +29,6 @@ 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>;