@gradial/aci 0.1.0 → 0.1.2

package/dist/dev/browser.d.ts

@@ -1,5 +1,5 @@
 export declare const DEFAULT_DEV_REFRESH_PORT = 24680;
-export declare const DEFAULT_DEV_REFRESH_PATH = "/baremetal-dev";
+export declare const DEFAULT_DEV_REFRESH_PATH = "/aci-dev";
 export interface DevRefreshOptions {
     wsPort?: number | string;
     path?: string;

package/dist/dev/browser.js

@@ -1,2 +1,2 @@
 export const DEFAULT_DEV_REFRESH_PORT = 24680;
-export const DEFAULT_DEV_REFRESH_PATH = '/baremetal-dev';
+export const DEFAULT_DEV_REFRESH_PATH = '/aci-dev';

package/dist/dev/index.d.ts

@@ -1,15 +1,20 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
 import { type DevRefreshOptions } from './browser.js';
 export { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT, type DevRefreshOptions } from './browser.js';
 declare global {
     interface Window {
-        __bareMetalDevRefresh?: boolean;
+        __gradialDevRefresh?: boolean;
     }
 }
-export interface BareMetalContentWatchOptions extends DevRefreshOptions {
+export interface GradialContentWatchOptions extends DevRefreshOptions {
     contentRoot?: string;
+    compiledRoot?: string;
     enabled?: boolean;
 }
 interface ViteDevServerLike {
+    middlewares?: {
+        use(path: string, handler: (req: IncomingMessage, res: ServerResponse, next: () => void) => void): void;
+    };
     watcher: {
         add(path: string): void;
         on(event: string, callback: (eventName: string, filePath: string) => void): void;
@@ -27,4 +32,5 @@ export interface VitePluginLike {
 export declare function devRefreshPort(options?: DevRefreshOptions): number;
 export declare function devRefreshScript(options?: DevRefreshOptions): string;
 export declare function devRefreshScriptTag(options?: DevRefreshOptions): string;
-export declare function baremetalContentWatchPlugin(options?: BareMetalContentWatchOptions): VitePluginLike;
+export declare function gradialContentWatchPlugin(options?: GradialContentWatchOptions): VitePluginLike;
+export declare function gradialDamAssetPlugin(options?: GradialContentWatchOptions): VitePluginLike;

package/dist/dev/index.js

@@ -1,5 +1,6 @@
+import fs from 'node:fs/promises';
 import path from 'node:path';
-import { contentRoot } from '../content/routes.js';
+import { compiledContentRoot } from '../content/routes.js';
 import { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT, } from './browser.js';
 export { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT } from './browser.js';
 function numberOption(value, fallback) {
@@ -10,7 +11,7 @@ function numberOption(value, fallback) {
     return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 export function devRefreshPort(options = {}) {
-    const value = options.wsPort ?? process.env.BARE_METAL_DEV_WS_PORT;
+    const value = options.wsPort ?? process.env.ACI_DEV_WS_PORT;
     if (value === 0 || value === '0') {
         return 0;
     }
@@ -24,8 +25,8 @@ export function devRefreshScript(options = {}) {
     const wsPath = options.path || DEFAULT_DEV_REFRESH_PATH;
     const reconnectMs = numberOption(options.reconnectMs, 1000);
     return `(() => {
-  if (typeof window === 'undefined' || window.__bareMetalDevRefresh) return;
-  window.__bareMetalDevRefresh = true;
+  if (typeof window === 'undefined' || window.__gradialDevRefresh) return;
+  window.__gradialDevRefresh = true;
   const port = ${JSON.stringify(wsPort)};
   const path = ${JSON.stringify(wsPath)};
   const reconnectMs = ${JSON.stringify(reconnectMs)};
@@ -47,16 +48,16 @@ export function devRefreshScript(options = {}) {
 export function devRefreshScriptTag(options = {}) {
     return `<script>${devRefreshScript(options)}</script>`;
 }
-export function baremetalContentWatchPlugin(options = {}) {
-    const enabled = options.enabled ?? process.env.BARE_METAL_DISABLE_CONTENT_WATCH !== '1';
+export function gradialContentWatchPlugin(options = {}) {
+    const enabled = options.enabled ?? process.env.ACI_DISABLE_CONTENT_WATCH !== '1';
     return {
-        name: 'baremetal-content-watch',
+        name: 'gradial-content-watch',
         apply: 'serve',
         configureServer(server) {
             if (!enabled) {
                 return;
             }
-            const root = path.resolve(options.contentRoot || contentRoot());
+            const root = path.resolve(options.contentRoot || compiledContentRoot());
             server.watcher.add(root);
             server.watcher.on('all', (_eventName, filePath) => {
                 const changed = path.resolve(filePath);
@@ -68,3 +69,68 @@ export function baremetalContentWatchPlugin(options = {}) {
         },
     };
 }
+export function gradialDamAssetPlugin(options = {}) {
+    return {
+        name: 'gradial-dam-assets',
+        apply: 'serve',
+        configureServer(server) {
+            if (!server.middlewares) {
+                return;
+            }
+            server.middlewares.use('/.gradial-dam', async (req, res, next) => {
+                const root = path.resolve(options.compiledRoot || compiledContentRoot());
+                const requestPath = safeRequestPath(req.url || '');
+                if (!requestPath) {
+                    res.statusCode = 404;
+                    res.end('asset not found');
+                    return;
+                }
+                const filePath = path.resolve(root, '.gradial-dam', requestPath.replace(/^\/+/, ''));
+                if (!isInside(root, filePath)) {
+                    res.statusCode = 404;
+                    res.end('asset not found');
+                    return;
+                }
+                try {
+                    const body = await fs.readFile(filePath);
+                    res.statusCode = 200;
+                    res.setHeader('Content-Type', contentType(filePath));
+                    res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
+                    res.end(body);
+                }
+                catch {
+                    next();
+                }
+            });
+        },
+    };
+}
+function safeRequestPath(url) {
+    const rawPath = url.split('?')[0] || '';
+    try {
+        const decoded = decodeURIComponent(rawPath);
+        return decoded.startsWith('/.gradial-dam/') ? decoded.slice('/.gradial-dam/'.length) : decoded;
+    }
+    catch {
+        return '';
+    }
+}
+function isInside(root, filePath) {
+    const rel = path.relative(root, filePath);
+    return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+function contentType(filePath) {
+    switch (path.extname(filePath).toLowerCase()) {
+        case '.webp':
+            return 'image/webp';
+        case '.svg':
+            return 'image/svg+xml';
+        case '.jpg':
+        case '.jpeg':
+            return 'image/jpeg';
+        case '.png':
+            return 'image/png';
+        default:
+            return 'application/octet-stream';
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,3 +1,7 @@
+export * from './block-ref.js';
 export * from './define-component.js';
 export * from './define-layout.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
+// content utilities from '@gradial/aci/content' explicitly.

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

@@ -0,0 +1,9 @@
+type AssetRouteContext = {
+    params: Promise<AssetRouteParams>;
+};
+type AssetRouteParams = {
+    releaseId?: string;
+    path?: string[];
+};
+export declare function GET(_request: Request, { params }: AssetRouteContext): Promise<Response>;
+export {};

package/dist/next/asset-route.js

@@ -0,0 +1,15 @@
+import { getReleaseAssetResponse } from './server.js';
+export async function GET(_request, { params }) {
+    const resolvedParams = await params;
+    const releaseId = resolvedParams.releaseId || '';
+    const assetPath = (resolvedParams.path || []).join('/');
+    if (!releaseId || !assetPath) {
+        return new Response('asset not found', { status: 404 });
+    }
+    try {
+        return await getReleaseAssetResponse(releaseId, assetPath);
+    }
+    catch {
+        return new Response('asset not found', { status: 404 });
+    }
+}

package/dist/next/config.d.ts

@@ -0,0 +1,6 @@
+import type { NextConfig } from 'next';
+export interface WithGradialOptions {
+    /** Asset rewrite prefix. Defaults to '/.gradial-dam' */
+    assetPrefix?: string;
+}
+export declare function withGradial(nextConfig?: NextConfig, options?: WithGradialOptions): NextConfig;

package/dist/next/config.js

@@ -0,0 +1,25 @@
+export function withGradial(nextConfig = {}, options = {}) {
+    const assetPrefix = options.assetPrefix || '/.gradial-dam';
+    const userRewrites = nextConfig.rewrites;
+    return {
+        ...nextConfig,
+        rewrites: async () => {
+            const gradialRewrites = [
+                {
+                    source: `${assetPrefix}/:path*`,
+                    destination: `/api/aci-assets${assetPrefix}/:path*`,
+                },
+            ];
+            if (!userRewrites)
+                return gradialRewrites;
+            const userResult = await (typeof userRewrites === 'function' ? userRewrites() : userRewrites);
+            if (Array.isArray(userResult)) {
+                return [...gradialRewrites, ...userResult];
+            }
+            return {
+                ...userResult,
+                beforeFiles: [...gradialRewrites, ...(userResult.beforeFiles ?? [])],
+            };
+        },
+    };
+}

package/dist/next/dev-refresh.js

@@ -3,10 +3,10 @@ import { useEffect } from 'react';
 import { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT, } from '../dev/browser.js';
 export function DevRefresh({ enabled = process.env.NODE_ENV !== 'production', wsPort = DEFAULT_DEV_REFRESH_PORT, path = DEFAULT_DEV_REFRESH_PATH, reconnectMs = 1000, }) {
     useEffect(() => {
-        if (!enabled || Number(wsPort) <= 0 || typeof window === 'undefined' || window.__bareMetalDevRefresh) {
+        if (!enabled || Number(wsPort) <= 0 || typeof window === 'undefined' || window.__gradialDevRefresh) {
             return undefined;
         }
-        window.__bareMetalDevRefresh = true;
+        window.__gradialDevRefresh = true;
         let reconnectTimer;
         let socket;
         let active = true;
@@ -21,7 +21,7 @@ export function DevRefresh({ enabled = process.env.NODE_ENV !== 'production', ws
                     }
                 }
                 catch {
-                    // Ignore non-Bare Metal dev server frames.
+                    // Ignore non-Gradial dev server frames.
                 }
             });
             socket.addEventListener('close', () => {
@@ -33,7 +33,7 @@ export function DevRefresh({ enabled = process.env.NODE_ENV !== 'production', ws
         connect();
         return () => {
             active = false;
-            window.__bareMetalDevRefresh = false;
+            window.__gradialDevRefresh = false;
             if (reconnectTimer) {
                 clearTimeout(reconnectTimer);
             }

package/dist/next/edge-config.d.ts

@@ -0,0 +1 @@
+export declare function getUncachedEdgeConfigValue(edgeConfig: string, key: string): Promise<unknown>;

package/dist/next/edge-config.js

@@ -0,0 +1,92 @@
+export async function getUncachedEdgeConfigValue(edgeConfig, key) {
+    const connection = parseEdgeConfigConnection(edgeConfig);
+    if (!connection) {
+        throw new Error('Invalid Edge Config connection string');
+    }
+    const headers = new Headers({
+        authorization: `Bearer ${connection.token}`,
+        'x-edge-config-min-updated-at': `${Number.MAX_SAFE_INTEGER}`,
+    });
+    if (process.env.VERCEL_ENV) {
+        headers.set('x-edge-config-vercel-env', process.env.VERCEL_ENV);
+    }
+    const url = `${connection.baseUrl}/item/${encodeURIComponent(key)}?version=${encodeURIComponent(connection.version)}`;
+    const response = await fetch(url, {
+        headers,
+        cache: 'no-store',
+    });
+    if (response.ok) {
+        return response.json();
+    }
+    if (response.status === 404 && response.headers.has('x-edge-config-digest')) {
+        return undefined;
+    }
+    const body = await response.text().catch(() => '');
+    throw new Error(`Edge Config read ${key} returned ${response.status}: ${body.slice(0, 500)}`);
+}
+function parseEdgeConfigConnection(value) {
+    const text = value.trim();
+    if (!text)
+        return null;
+    return parseEdgeConfigQueryConnection(text)
+        || parseVercelEdgeConfigURL(text)
+        || parseExternalEdgeConfigURL(text);
+}
+function parseEdgeConfigQueryConnection(value) {
+    if (!value.startsWith('edge-config:'))
+        return null;
+    const params = new URLSearchParams(value.slice('edge-config:'.length));
+    const id = params.get('id') || '';
+    const token = params.get('token') || '';
+    if (!id || !token)
+        return null;
+    return {
+        baseUrl: `https://edge-config.vercel.com/${id}`,
+        token,
+        version: params.get('version') || '1',
+    };
+}
+function parseVercelEdgeConfigURL(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== 'https:' || url.host !== 'edge-config.vercel.com')
+        return null;
+    const id = url.pathname.split('/').filter(Boolean)[0] || '';
+    const token = url.searchParams.get('token') || '';
+    if (!id || !id.startsWith('ecfg') || !token)
+        return null;
+    return {
+        baseUrl: `https://edge-config.vercel.com/${id}`,
+        token,
+        version: url.searchParams.get('version') || '1',
+    };
+}
+function parseExternalEdgeConfigURL(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return null;
+    }
+    let id = url.searchParams.get('id') || '';
+    const token = url.searchParams.get('token') || '';
+    const version = url.searchParams.get('version') || '1';
+    if (!id || url.pathname.startsWith('/ecfg_')) {
+        id = url.pathname.split('/').filter(Boolean)[0] || '';
+    }
+    if (!id || !token)
+        return null;
+    url.search = '';
+    const base = url.toString().replace(/\/+$/, '');
+    return {
+        baseUrl: base,
+        token,
+        version,
+    };
+}

package/dist/next/index.d.ts

@@ -0,0 +1,2 @@
+export { DevRefresh, type DevRefreshProps } from './dev-refresh.js';
+export { withGradial, type WithGradialOptions } from './config.js';

package/dist/next/index.js

@@ -0,0 +1,2 @@
+export { DevRefresh } from './dev-refresh.js';
+export { withGradial } from './config.js';

package/dist/next/middleware.js

@@ -1,5 +1,5 @@
-import { createClient, get as getEdgeConfigItem } from '@vercel/edge-config';
 import { NextResponse } from 'next/server';
+import { getUncachedEdgeConfigValue } from './edge-config.js';
 import { validatePreviewToken } from './preview.js';
 const RELEASE_HEADER = 'x-gradial-release-id';
 const ROUTE_HEADER = 'x-gradial-route';
@@ -62,9 +62,7 @@ async function getEdgeConfigJSON(edgeConfig, key) {
     return value;
 }
 async function getEdgeConfigValue(edgeConfig, key) {
-    return edgeConfig === process.env.EDGE_CONFIG
-        ? await getEdgeConfigItem(key)
-        : await createClient(edgeConfig).get(key);
+    return getUncachedEdgeConfigValue(edgeConfig, key);
 }
 function activeReleaseKey(siteId) {
     return `activeRelease_${edgeKeySegment(siteId)}`;
@@ -108,7 +106,7 @@ async function releaseFromPreviewToken(request, config) {
     const token = previewTokenFromRequest(request);
     if (!token)
         return { releaseId: '', invalid: false };
-    const signKey = config.previewSignKey || process.env.GRADIAL_PREVIEW_SIGN_KEY || process.env.HOSTING_PREVIEW_SIGN_KEY || '';
+    const signKey = config.previewSignKey || process.env.ACI_PREVIEW_SIGN_KEY || '';
     if (!signKey)
         return { releaseId: '', invalid: true };
     const claims = await validatePreviewToken(token, signKey);
@@ -124,7 +122,7 @@ function previewTokenFromRequest(request) {
     const queryToken = request.nextUrl.searchParams.get('preview_token');
     if (queryToken)
         return queryToken;
-    const cookieToken = request.cookies.get('bm_preview')?.value || '';
+    const cookieToken = request.cookies.get('aci_preview')?.value || '';
     if (cookieToken)
         return cookieToken;
     const auth = request.headers.get('authorization') || '';

package/dist/next/server.d.ts

@@ -1,9 +1,5 @@
-export declare class PageNotFoundError extends Error {
-    constructor(route: string, cause?: unknown);
-}
-export declare class FragmentNotFoundError extends Error {
-    constructor(name: string, cause?: unknown);
-}
+import { FragmentNotFoundError, PageNotFoundError } from '../content/provider.js';
+export { FragmentNotFoundError, PageNotFoundError };
 export interface GradialFetchConfig {
     siteId?: string;
     bucket?: string;
@@ -17,24 +13,6 @@ export interface GradialFetchConfig {
     edgeConfig?: string;
     deploymentId?: string;
 }
-export interface RouteManifest {
-    manifestVersion: string;
-    releaseId: string;
-    siteId: string;
-    routes: Record<string, RouteEntry>;
-}
-export interface RouteEntry {
-    path: string;
-    mode: string;
-    bodyArtifact?: string;
-    fragments?: Array<{
-        id: string;
-        artifactRef?: string;
-    }>;
-    cachePolicy?: {
-        cacheControl?: string;
-    };
-}
 export interface GradialRenderInput<TPage, TSite extends GradialSiteConfig = GradialSiteConfig> {
     route: string;
     domain: string;
@@ -55,4 +33,11 @@ export declare function routeFromNextParams(params?: Promise<{
 }> | {
     slug?: string[];
 }): Promise<string>;
+export declare function generateGradialStaticParams(): Promise<Array<{
+    slug?: string[];
+}>>;
+export declare class ReleaseAssetNotFoundError extends Error {
+    constructor(releaseId: string, assetPath: string, cause?: unknown);
+}
+export declare function getReleaseAssetResponse(releaseId: string, assetPath: string, config?: GradialFetchConfig): Promise<Response>;
 export declare function resolveReleaseId(config?: GradialFetchConfig): Promise<string>;