@gradial/aci 0.1.19 → 0.1.20-preview.2

package/README.md

@@ -5,6 +5,28 @@ installing `@gradial/aci`, Zod 4, and TypeScript tooling. The
 SDK exposes component and layout helpers, renderer types, compiler tooling,
 content provider helpers, and framework-specific subpaths from one package.
 
+## Getting Started
+
+The fastest way to create a new ACI site is via the scaffolding script:
+
+```bash
+npx tsx scripts/create-site.ts --framework astro --name my-site --dir ./my-site
+cd my-site
+npm run dev
+```
+
+Available frameworks: `astro`, `nextjs`, `sveltekit`.
+
+Generated starters include:
+- `.aci/docs/` — Understanding ACI, running, and testing guides
+- `.aci/guides/` — Component development, design system, content authoring
+- `.aci/migration/` — Migrating existing sites to ACI
+- Design system tokens, ESLint rules, and demo content
+
+See the [templates directory](templates/) for the canonical starter source.
+
+## Installation
+
 ```bash
 npm install @gradial/aci zod@^4
 npm install -D typescript tsx

package/dist/astro/index.d.ts

@@ -33,9 +33,9 @@ export declare function getGradialStaticPaths(): Promise<Array<{
     };
 }>>;
 export declare function getPageRuntimeRenderInput(request: Request): RenderInput | null;
+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' */
     compiledRoot?: string;
 }
-export declare function gradialAstro(options?: GradialAstroOptions): AstroIntegrationLike;
-export {};
+export declare function withGradialAci(options?: GradialAstroOptions): AstroIntegrationLike;

package/dist/astro/index.js

@@ -31,7 +31,11 @@ export async function getGradialStaticPaths() {
 export function getPageRuntimeRenderInput(request) {
     return getPendingRenderInputFromHeaders(request.headers);
 }
-export function gradialAstro(options = {}) {
+// ---------------------------------------------------------------------------
+// Preview support
+// ---------------------------------------------------------------------------
+export { getPreviewMode, createPreviewBannerHTML, createPreviewCookies, } from './preview.js';
+export function withGradialAci(options = {}) {
     return {
         name: 'gradial-astro',
         hooks: {

package/dist/astro/preview.d.ts

@@ -0,0 +1,5 @@
+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/astro/preview.js

@@ -0,0 +1,33 @@
+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/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/define-data-model.d.ts

@@ -0,0 +1,2 @@
+import type { DataModelContract, DataModelDefinition } from './types/data.js';
+export declare function defineDataModel<TSchema = unknown, TType extends string = string>(definition: DataModelDefinition<TSchema, TType>): DataModelContract<TSchema, TType>;

package/dist/define-data-model.js

@@ -0,0 +1,3 @@
+export function defineDataModel(definition) {
+    return { ...definition };
+}

package/dist/dev/index.d.ts

@@ -7,10 +7,21 @@ declare global {
     }
 }
 export interface GradialContentWatchOptions extends DevRefreshOptions {
+    /** Source content root to watch. Defaults to ACI_CONTENT_SOURCE env or '.content' */
     contentRoot?: string;
+    /** Compiled content output root. Defaults to ACI_CONTENT_ROOT env or '.aci/compiled' */
     compiledRoot?: string;
+    /** Path to the ACI CLI binary. Defaults to ACI_BIN env or 'aci' */
+    aciBin?: string;
+    /** Disable content watching entirely. Defaults to ACI_DISABLE_CONTENT_WATCH env */
     enabled?: boolean;
 }
+interface ViteModuleGraph {
+    idToModuleMap: Map<unknown, {
+        id: string | null;
+    }>;
+    invalidateModule(mod: unknown): void;
+}
 interface ViteDevServerLike {
     middlewares?: {
         use(path: string, handler: (req: IncomingMessage, res: ServerResponse, next: () => void) => void): void;
@@ -22,6 +33,7 @@ interface ViteDevServerLike {
     ws: {
         send(payload: unknown): void;
     };
+    moduleGraph?: ViteModuleGraph;
 }
 export interface VitePluginLike {
     name: string;

package/dist/dev/index.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { compiledContentRoot } from '../content/routes.js';
 import { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT, } from './browser.js';
@@ -48,23 +49,97 @@ export function devRefreshScript(options = {}) {
 export function devRefreshScriptTag(options = {}) {
     return `<script>${devRefreshScript(options)}</script>`;
 }
+function sourceContentRoot(options) {
+    return path.resolve(options.contentRoot ||
+        process.env.ACI_CONTENT_SOURCE ||
+        './.content');
+}
+function resolveAciBin(options) {
+    return options.aciBin || process.env.ACI_BIN || 'aci';
+}
+function recompileContent(options, reason) {
+    const siteDir = process.cwd();
+    const src = sourceContentRoot(options);
+    const out = path.resolve(options.compiledRoot ||
+        process.env.ACI_CONTENT_ROOT ||
+        '.aci/compiled');
+    const bin = resolveAciBin(options);
+    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;
+}
 export function gradialContentWatchPlugin(options = {}) {
     const enabled = options.enabled ?? process.env.ACI_DISABLE_CONTENT_WATCH !== '1';
+    if (!enabled) {
+        return {
+            name: 'gradial-content-watch-disabled',
+            apply: 'serve',
+        };
+    }
+    let timer;
+    let running = false;
+    let queued = false;
+    function rebuild(server, reason) {
+        if (running) {
+            queued = true;
+            return;
+        }
+        running = true;
+        const success = recompileContent(options, reason);
+        running = false;
+        if (success) {
+            if (server.moduleGraph) {
+                for (const mod of server.moduleGraph.idToModuleMap.values()) {
+                    server.moduleGraph.invalidateModule(mod);
+                }
+            }
+            server.ws.send({ type: 'full-reload' });
+        }
+        if (queued) {
+            queued = false;
+            rebuild(server, 'queued change');
+        }
+    }
     return {
         name: 'gradial-content-watch',
         apply: 'serve',
         configureServer(server) {
-            if (!enabled) {
-                return;
-            }
-            const root = path.resolve(options.contentRoot || compiledContentRoot());
-            server.watcher.add(root);
-            server.watcher.on('all', (_eventName, filePath) => {
+            const src = sourceContentRoot(options);
+            const compiled = path.resolve(options.compiledRoot ||
+                process.env.ACI_CONTENT_ROOT ||
+                compiledContentRoot());
+            server.watcher.add(src);
+            server.watcher.add(compiled);
+            rebuild(server, 'startup');
+            server.watcher.on('all', (_event, filePath) => {
                 const changed = path.resolve(filePath);
-                const relative = path.relative(root, changed);
-                if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
-                    server.ws.send({ type: 'full-reload', path: '*' });
+                const isSource = changed.startsWith(src + path.sep);
+                const isCompiled = changed.startsWith(compiled + path.sep);
+                if (!isSource && !isCompiled)
+                    return;
+                if (isCompiled) {
+                    server.ws.send({ type: 'full-reload' });
+                    return;
                 }
+                clearTimeout(timer);
+                timer = setTimeout(() => {
+                    const relative = path.relative(src, changed);
+                    rebuild(server, relative);
+                }, 100);
             });
         },
     };

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from './block-ref.js';
 export * from './define-component.js';
+export * from './define-data-model.js';
 export * from './define-layout.js';
 export * from './types/index.js';
 // Note: content/ is NOT re-exported here because it imports node:path,

package/dist/next/config.d.ts

@@ -3,4 +3,4 @@ export interface WithGradialOptions {
     /** Asset rewrite prefix. Defaults to '/.gradial-dam' */
     assetPrefix?: string;
 }
-export declare function withGradial(nextConfig?: NextConfig, options?: WithGradialOptions): NextConfig;
+export declare function withGradialAci(nextConfig?: NextConfig, options?: WithGradialOptions): NextConfig;

package/dist/next/config.js

@@ -1,6 +1,8 @@
-export function withGradial(nextConfig = {}, options = {}) {
+import { createContentWatchWebpackPlugin } from './content-watch.js';
+export function withGradialAci(nextConfig = {}, options = {}) {
     const assetPrefix = options.assetPrefix || '/.gradial-dam';
     const userRewrites = nextConfig.rewrites;
+    const userWebpack = nextConfig.webpack;
     return {
         ...nextConfig,
         rewrites: async () => {
@@ -21,5 +23,15 @@ export function withGradial(nextConfig = {}, options = {}) {
                 beforeFiles: [...gradialRewrites, ...(userResult.beforeFiles ?? [])],
             };
         },
+        webpack: (config, context) => {
+            if (context?.isServer && process.env.NODE_ENV !== 'production') {
+                if (!config.plugins)
+                    config.plugins = [];
+                config.plugins.push(createContentWatchWebpackPlugin());
+            }
+            return typeof userWebpack === 'function'
+                ? userWebpack(config, context)
+                : config;
+        },
     };
 }

package/dist/next/content-watch.d.ts

@@ -0,0 +1,11 @@
+interface ContentWatchWebpackPlugin {
+    apply(compiler: {
+        hooks: {
+            [key: string]: {
+                tap: (name: string, fn: () => void) => void;
+            };
+        };
+    }): void;
+}
+export declare function createContentWatchWebpackPlugin(): ContentWatchWebpackPlugin;
+export {};

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.js

@@ -1,7 +1,6 @@
 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) {
@@ -11,40 +10,30 @@ export function createGradialMiddleware(config) {
         if (url.searchParams.get('leave_preview') === '1') {
             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);
-        const releaseId = previewReleaseId || await activeReleaseFromEdgeConfig(config);
+        const preview = await resolvePreviewFromRequest(request, config);
+        const releaseId = preview?.releaseId || await activeReleaseFromEdgeConfig(config);
         if (!releaseId) {
             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');
+        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) {
-            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);
+            }
         }
         return response;
     };
@@ -54,8 +43,31 @@ function gradialHeaders(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)
@@ -126,31 +138,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);
-    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 '';
-    }
-    const claims = await validatePreviewToken(token, signKey);
-    if (!claims || claims.scope !== 'preview' || !claims.releaseId)
-        return '';
-    if (claims.siteId && config.siteId && claims.siteId !== config.siteId)
-        return '';
-    if (!claims.expiresAt || Date.parse(claims.expiresAt) <= Date.now())
-        return '';
-    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) : '';
-}