@gradial/aci 0.1.45 → 0.1.46

package/dist/next/middleware.js

@@ -2,6 +2,7 @@ import { NextResponse } from 'next/server.js';
 import { getUncachedEdgeConfigValue } from './edge-config.js';
 import { PREVIEW_TOKEN_COOKIE, PREVIEW_RELEASE_COOKIE, extractPreviewToken, resolvePreviewContext, createPreviewCookies, previewSignKey, } from '../preview/core.js';
 import { CONTENT_PATH_HEADER, CONTENT_PATH_CACHE_PARAM, resolvePersonalizationRequest, } from './personalization-host.js';
+import { activeReleaseV1Key, clampDeploymentCompatibleReleaseV1, decodeActiveReleaseV1, decodeDeploymentCompatibilityV1, deploymentCompatibilityKey, } from './vercel-edge-projection-v1.js';
 const RELEASE_SCOPED_PREFIX = '/__r';
 const FRAMEWORK_ORIGIN_AUTH_HEADER = 'x-gradial-framework-origin-auth';
 const FRAMEWORK_SITE_ID_HEADER = 'x-baremetal-site-id';
@@ -371,73 +372,27 @@ async function activeReleaseFromEdgeConfig(config) {
     if (!edgeConfig || !siteId)
         return '';
     const active = await activeReleasePointer(edgeConfig, siteId);
-    if (!active.releaseId)
+    if (active == null)
         return '';
     const deploymentId = config.deploymentId || process.env.VERCEL_DEPLOYMENT_ID || '';
     if (!deploymentId)
         return active.releaseId;
-    const compatibility = await getEdgeConfigJSON(edgeConfig, deploymentCompatibilityKey(siteId, deploymentId));
-    if (!compatibility)
+    const compatibilityValue = await getEdgeConfigValue(edgeConfig, deploymentCompatibilityKey(siteId, deploymentId));
+    if (compatibilityValue == null)
         return active.releaseId;
-    return clampRelease(active.releaseId, active.sequence || 0, compatibility);
+    return clampDeploymentCompatibleReleaseV1(active, decodeDeploymentCompatibilityV1(compatibilityValue));
 }
 function siteIdForConfig(config) {
     return config.siteId || process.env.ACI_SITE_ID || '';
 }
-async function getEdgeConfigJSON(edgeConfig, key) {
-    const value = await getEdgeConfigValue(edgeConfig, key);
-    if (!value)
-        return null;
-    if (typeof value === 'string') {
-        try {
-            return JSON.parse(value);
-        }
-        catch {
-            return null;
-        }
-    }
-    return value;
-}
 async function getEdgeConfigValue(edgeConfig, key) {
     return getUncachedEdgeConfigValue(edgeConfig, key);
 }
-function activeReleaseKey(siteId) {
-    return `activeRelease_${edgeKeySegment(siteId)}`;
-}
-function deploymentCompatibilityKey(siteId, deploymentId) {
-    return `deploymentCompatibility_${edgeKeySegment(siteId)}_${edgeKeySegment(deploymentId)}`;
-}
 async function activeReleasePointer(edgeConfig, siteId) {
-    const value = await getEdgeConfigValue(edgeConfig, activeReleaseKey(siteId));
-    if (!value)
-        return { releaseId: '' };
-    if (typeof value === 'string') {
-        try {
-            const parsed = JSON.parse(value);
-            if (parsed.releaseId)
-                return parsed;
-        }
-        catch {
-            return { releaseId: value };
-        }
-        return { releaseId: value };
-    }
-    const pointer = value;
-    return { releaseId: pointer.releaseId || '', sequence: pointer.sequence };
-}
-function clampRelease(activeReleaseId, activeSequence, compatibility) {
-    if (!activeSequence)
-        return activeReleaseId;
-    if (compatibility.minSequence && activeSequence < compatibility.minSequence && compatibility.minReleaseId) {
-        return compatibility.minReleaseId;
-    }
-    if (compatibility.maxSequence && activeSequence > compatibility.maxSequence && compatibility.maxReleaseId) {
-        return compatibility.maxReleaseId;
-    }
-    return activeReleaseId;
-}
-function edgeKeySegment(value) {
-    return value.replace(/[^A-Za-z0-9_-]/g, '_');
+    const value = await getEdgeConfigValue(edgeConfig, activeReleaseV1Key(siteId));
+    if (value == null)
+        return null;
+    return decodeActiveReleaseV1(value);
 }
 function isPassthroughRoute(pathname) {
     return PASSTHROUGH_ROUTES.some((route) => routeMatches(pathname, route));

package/dist/next/page.js

@@ -6,6 +6,7 @@ import { routeMetadataForContent, resolveSlots, } from '../content/index.js';
 import { renderBlocks } from './render.js';
 import { AssignmentsScript } from './assignments-script.js';
 import { CollectScript } from './collect-script.js';
+import { renderProofContentFor } from '../internal/render-proof.js';
 /**
  * Creates the catch-all route handler for a Next.js ACI site.
  *
@@ -64,12 +65,14 @@ export function createPage(registry, options) {
     }
     async function CatchAllPage({ params }) {
         const { route, releaseId } = await resolveRouteAndRelease(params);
+        const fetchConfig = { releaseId };
         try {
-            const input = await getRenderInput(route, { releaseId });
+            const input = await getRenderInput(route, fetchConfig);
             if (!input.page)
                 notFound();
-            const layout = await getLayout(input.page.layout);
-            const resolvedSlots = await resolveSlots(layout, input.page.regions || {}, (id) => getFragment(id));
+            const renderProofContent = renderProofContentFor(input);
+            const layout = await getLayout(input.page.layout, fetchConfig);
+            const resolvedSlots = await resolveSlots(layout, input.page.regions || {}, (id) => getFragment(id, fetchConfig));
             const renderedSlots = await Promise.all(layout.slots.map(async (slot) => {
                 const blocks = resolvedSlots[slot.name];
                 if (!blocks?.length)
@@ -81,7 +84,9 @@ export function createPage(registry, options) {
                 }
                 return (_jsx(Fragment, { children: renderedBlocks }, slot.name));
             }));
-            return (_jsxs(_Fragment, { children: [renderedSlots.filter(Boolean), _jsx(AssignmentsScript, { page: input.page }), _jsx(CollectScript, { siteConfig: input.siteConfig })] }));
+            return (_jsxs(_Fragment, { children: [renderProofContent
+                        ? _jsx("meta", { name: "aci-render-proof", content: renderProofContent })
+                        : null, renderedSlots.filter(Boolean), _jsx(AssignmentsScript, { page: input.page }), _jsx(CollectScript, { siteConfig: input.siteConfig })] }));
         }
         catch (error) {
             if (error instanceof PageNotFoundError)

package/dist/next/personalization-host.d.ts

@@ -29,12 +29,17 @@ export interface EdgeRouteEntry {
     dispatch: EdgeDispatch;
     variants?: Record<string, EdgeRouteVariant>;
 }
+export interface CollectSDKEntry {
+    hash: string;
+    path: string;
+}
 export interface EdgeRouteManifest {
     manifestVersion: string;
     releaseId: string;
     siteId: string;
     routes: Record<string, EdgeRouteEntry>;
     experiments?: Record<string, PersonalizationExperiment>;
+    collectSdk?: CollectSDKEntry;
     notFoundPage?: string;
     errorPage?: string;
 }

package/dist/next/server.js

@@ -3,17 +3,19 @@ import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError, } from '
 import { getCachedManifest, getCachedSiteConfig } from '../content/cache.js';
 import { S3ContentProvider } from '../providers/s3.js';
 import { GRADIAL_RENDER_INPUT_HEADER, getPendingRenderInput } from '../runtime/page.js';
+import { attachRenderProofReceipt, selectVerifiedPage, } from '../internal/render-proof.js';
 import { getUncachedEdgeConfigValue } from './edge-config.js';
+import { activeReleaseV1Key, clampDeploymentCompatibleReleaseV1, decodeActiveReleaseV1, decodeDeploymentCompatibilityV1, deploymentCompatibilityKey, } from './vercel-edge-projection-v1.js';
 export { FragmentNotFoundError, PageNotFoundError, LayoutNotFoundError };
+const MAX_S3_PROVIDER_CACHE_ENTRIES = 8;
+const s3ProviderCache = [];
+const s3ProviderReleaseIds = new WeakMap();
 export async function getPage(route = '', config = {}) {
     const runtimeInput = await getPageRuntimeRenderInput();
     if (runtimeInput)
         return runtimeInput.page;
     const provider = await resolveProviderWithFallback(config);
-    const variantPage = await pageFromContentPath(provider);
-    if (variantPage !== null)
-        return variantPage;
-    return await provider.getPage(route);
+    return (await selectRenderPage(provider, route)).page;
 }
 export async function getSiteConfig(config = {}) {
     const runtimeInput = await getPageRuntimeRenderInput();
@@ -55,17 +57,21 @@ export async function getRenderInput(route = '/', config = {}) {
     const provider = await resolveProviderWithFallback(config);
     // Cache shared resources (manifest, siteConfig) but not per-page content
     // Page-level caching is handled by CDN
-    const [page, siteConfig] = await Promise.all([
-        pageFromContentPath(provider).then((variantPage) => variantPage ?? provider.getPage(route)),
+    const [selection, siteConfig] = await Promise.all([
+        selectRenderPage(provider, route),
         getCachedSiteConfig(provider),
     ]);
-    return {
+    const input = {
         route,
         domain: siteConfig.domain || 'www.aci.local',
         locale: siteConfig.defaultLocale || 'en-us',
         siteConfig,
-        page,
+        page: selection.page,
     };
+    if (selection.receipt) {
+        attachRenderProofReceipt(input, selection.receipt);
+    }
+    return input;
 }
 export async function getPageRuntimeRenderInput() {
     try {
@@ -83,20 +89,39 @@ export async function getPageRuntimeRenderInput() {
 // is cosmetic. The S3 provider only serves refs the release manifest
 // declares.
 const ACI_CONTENT_PATH_HEADER = 'x-aci-content-path';
-async function pageFromContentPath(provider) {
-    if (!(provider instanceof S3ContentProvider))
-        return null;
-    let ref = '';
+const ACI_VARIANT_KEY_HEADER = 'x-aci-variant-key';
+async function selectRenderPage(provider, route) {
+    if (!(provider instanceof S3ContentProvider)) {
+        return { page: await provider.getPage(route) };
+    }
+    const releaseId = s3ProviderReleaseIds.get(provider);
+    if (!releaseId) {
+        throw new Error('ACI S3 page integrity error: provider release is unavailable');
+    }
+    let contentRef = '';
+    let contentRefPresent = false;
+    let variantKey = '';
+    let variantKeyPresent = false;
     try {
         const current = await headers();
-        ref = (current.get(ACI_CONTENT_PATH_HEADER) || '').trim();
+        const selectedContentRef = current.get(ACI_CONTENT_PATH_HEADER);
+        contentRefPresent = selectedContentRef !== null;
+        contentRef = selectedContentRef ?? '';
+        const selectedVariantKey = current.get(ACI_VARIANT_KEY_HEADER);
+        variantKeyPresent = selectedVariantKey !== null;
+        variantKey = selectedVariantKey ?? '';
     }
     catch {
-        return null;
+        // `headers()` has no request context in static generation and unit tests.
     }
-    if (!ref)
-        return null;
-    return await provider.getPageByRef(ref);
+    return await provider[selectVerifiedPage]({
+        releaseId,
+        route,
+        contentRef,
+        contentRefPresent,
+        variantKey,
+        variantKeyPresent,
+    });
 }
 export { isPreviewMode } from './preview-mode.js';
 export async function routeFromNextParams(params) {
@@ -230,7 +255,11 @@ export async function resolveReleaseId(config = {}) {
 }
 async function resolveS3Provider(config) {
     const releaseId = await resolveReleaseId(config);
-    const provider = new S3ContentProvider({
+    if (releaseId.length > 128
+        || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(releaseId)) {
+        throw new Error(`ACI release ID is invalid: ${releaseId}`);
+    }
+    const candidate = new S3ContentProvider({
         bucket: config.bucket,
         keyPrefix: releaseKey(config, releaseId),
         region: config.region,
@@ -240,9 +269,29 @@ async function resolveS3Provider(config) {
         roleArn: config.roleArn,
         endpoint: config.endpoint,
     });
-    // Pre-warm the manifest with cached version
-    await getCachedManifest(provider);
-    return provider;
+    s3ProviderReleaseIds.set(candidate, releaseId);
+    const cachedIndex = s3ProviderCache.findIndex((entry) => sameS3ProviderConfig(entry.config, candidate.config));
+    if (cachedIndex >= 0) {
+        const [cached] = s3ProviderCache.splice(cachedIndex, 1);
+        s3ProviderCache.push(cached);
+        return await cached.provider;
+    }
+    const provider = getCachedManifest(candidate).then(() => candidate);
+    const entry = { config: candidate.config, provider };
+    s3ProviderCache.push(entry);
+    if (s3ProviderCache.length > MAX_S3_PROVIDER_CACHE_ENTRIES) {
+        s3ProviderCache.shift();
+    }
+    try {
+        return await provider;
+    }
+    catch (error) {
+        const rejectedIndex = s3ProviderCache.findIndex((cached) => cached.provider === provider);
+        if (rejectedIndex >= 0) {
+            s3ProviderCache.splice(rejectedIndex, 1);
+        }
+        throw error;
+    }
 }
 async function resolveProviderWithFallback(config) {
     if (process.env.ACI_CONTENT_PROVIDER === 'file') {
@@ -251,35 +300,31 @@ async function resolveProviderWithFallback(config) {
     }
     return await resolveS3Provider(config);
 }
+function sameS3ProviderConfig(left, right) {
+    return left.bucket === right.bucket
+        && left.keyPrefix === right.keyPrefix
+        && left.region === right.region
+        && left.accessKeyId === right.accessKeyId
+        && left.secretAccessKey === right.secretAccessKey
+        && left.sessionToken === right.sessionToken
+        && left.roleArn === right.roleArn
+        && left.endpoint === right.endpoint;
+}
 async function activeReleaseFromEdgeConfig(config) {
     const edgeConfig = config.edgeConfig || process.env.EDGE_CONFIG || '';
     const siteId = config.siteId || process.env.ACI_SITE_ID || '';
     if (!edgeConfig || !siteId)
         return '';
     const active = await activeReleasePointer(edgeConfig, siteId);
-    if (!active.releaseId)
+    if (active == null)
         return '';
     const deploymentId = config.deploymentId || process.env.VERCEL_DEPLOYMENT_ID || '';
     if (!deploymentId)
         return active.releaseId;
-    const compatibility = await getEdgeConfigJSON(edgeConfig, deploymentCompatibilityKey(siteId, deploymentId));
-    if (!compatibility)
+    const compatibilityValue = await getEdgeConfigValue(edgeConfig, deploymentCompatibilityKey(siteId, deploymentId));
+    if (compatibilityValue == null)
         return active.releaseId;
-    return clampRelease(active.releaseId, active.sequence || 0, compatibility);
-}
-async function getEdgeConfigJSON(edgeConfig, key) {
-    const value = await getEdgeConfigValue(edgeConfig, key);
-    if (!value)
-        return null;
-    if (typeof value === 'string') {
-        try {
-            return JSON.parse(value);
-        }
-        catch {
-            return null;
-        }
-    }
-    return value;
+    return clampDeploymentCompatibleReleaseV1(active, decodeDeploymentCompatibilityV1(compatibilityValue));
 }
 async function getEdgeConfigValue(edgeConfig, key) {
     return getUncachedEdgeConfigValue(edgeConfig, key);
@@ -287,43 +332,11 @@ async function getEdgeConfigValue(edgeConfig, key) {
 function releaseKey(config, releaseId) {
     return joinKey(config.keyPrefix || process.env.ACI_S3_KEY_PREFIX || '', 'releases', releaseId);
 }
-function activeReleaseKey(siteId) {
-    return `activeRelease_${edgeKeySegment(siteId)}`;
-}
-function deploymentCompatibilityKey(siteId, deploymentId) {
-    return `deploymentCompatibility_${edgeKeySegment(siteId)}_${edgeKeySegment(deploymentId)}`;
-}
 async function activeReleasePointer(edgeConfig, siteId) {
-    const value = await getEdgeConfigValue(edgeConfig, activeReleaseKey(siteId));
-    if (!value)
-        return { releaseId: '' };
-    if (typeof value === 'string') {
-        try {
-            const parsed = JSON.parse(value);
-            if (parsed.releaseId)
-                return parsed;
-        }
-        catch {
-            return { releaseId: value };
-        }
-        return { releaseId: value };
-    }
-    const pointer = value;
-    return { releaseId: pointer.releaseId || '', sequence: pointer.sequence };
-}
-function clampRelease(activeReleaseId, activeSequence, compatibility) {
-    if (!activeSequence)
-        return activeReleaseId;
-    if (compatibility.minSequence && activeSequence < compatibility.minSequence && compatibility.minReleaseId) {
-        return compatibility.minReleaseId;
-    }
-    if (compatibility.maxSequence && activeSequence > compatibility.maxSequence && compatibility.maxReleaseId) {
-        return compatibility.maxReleaseId;
-    }
-    return activeReleaseId;
-}
-function edgeKeySegment(value) {
-    return value.replace(/[^A-Za-z0-9_-]/g, '_');
+    const value = await getEdgeConfigValue(edgeConfig, activeReleaseV1Key(siteId));
+    if (value == null)
+        return null;
+    return decodeActiveReleaseV1(value);
 }
 function joinKey(...parts) {
     return parts

package/dist/next/vercel-collect-sdk-route.js

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
 import { awsCredentialsProvider } from '@vercel/oidc-aws-credentials-provider';
 import { getUncachedEdgeConfigValue } from './edge-config.js';
+import { activeReleaseV1Key, decodeActiveReleaseV1, decodeEdgeRouteProjectionV1, edgeRoutesV1Key, } from './vercel-edge-projection-v1.js';
 const SHA256_HEX = /^[0-9a-f]{64}$/;
 /**
  * Creates the Node-only stable collect-SDK route used by ACI's injected
@@ -34,12 +35,11 @@ export function createVercelCollectSDKRoute(input, dependencies = {}) {
             });
         }
         try {
-            const active = parseActiveReleasePointer(await readEdgeConfig(config.edgeConfig, activeReleaseKey(config.siteId)));
-            const projection = parseProjection(await readEdgeConfig(config.edgeConfig, edgeRoutesKey(config.siteId, active.releaseId)));
-            if (projection.siteId !== config.siteId || projection.releaseId !== active.releaseId) {
-                throw new Error(`collect SDK projection identity mismatch: got ${projection.siteId}/${projection.releaseId}, `
-                    + `want ${config.siteId}/${active.releaseId}`);
-            }
+            const active = decodeActiveReleaseV1(await readEdgeConfig(config.edgeConfig, activeReleaseV1Key(config.siteId)));
+            const projection = decodeEdgeRouteProjectionV1(await readEdgeConfig(config.edgeConfig, edgeRoutesV1Key(config.siteId, active.releaseId)), {
+                siteId: config.siteId,
+                releaseId: active.releaseId,
+            });
             if (!Object.prototype.hasOwnProperty.call(projection, 'collectSdk')) {
                 return new Response(method === 'HEAD' ? null : 'collect SDK is not enabled for this release', {
                     status: 404,
@@ -115,21 +115,6 @@ function validateConfig(input) {
         hostingKeyPrefix: cleanKey(input.hostingKeyPrefix || ''),
     };
 }
-function parseActiveReleasePointer(value) {
-    const parsed = parseRecord(value, 'active release pointer');
-    return { releaseId: requiredPathSegment(parsed.releaseId || '', 'active release ID') };
-}
-function parseProjection(value) {
-    const parsed = parseRecord(value, 'collect SDK route projection');
-    const projection = {
-        releaseId: requiredPathSegment(parsed.releaseId || '', 'projection release ID'),
-        siteId: requiredPathSegment(parsed.siteId || '', 'projection site ID'),
-    };
-    if (Object.prototype.hasOwnProperty.call(parsed, 'collectSdk')) {
-        projection.collectSdk = parsed.collectSdk;
-    }
-    return projection;
-}
 function parseRecord(value, label) {
     const parsed = typeof value === 'string' ? JSON.parse(value) : value;
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
@@ -172,15 +157,6 @@ function ifNoneMatchSatisfied(value, etag) {
         return normalized === etag;
     });
 }
-function activeReleaseKey(siteId) {
-    return `activeRelease_${edgeKeySegment(siteId)}`;
-}
-function edgeRoutesKey(siteId, releaseId) {
-    return `edgeRoutes_${edgeKeySegment(siteId)}_${edgeKeySegment(releaseId)}`;
-}
-function edgeKeySegment(value) {
-    return value.replace(/[^A-Za-z0-9_-]/g, '_');
-}
 function requiredPathSegment(value, label) {
     const clean = value.trim();
     if (!clean || clean === '.' || clean === '..' || clean.includes('/') || clean.includes('\\')) {

package/dist/next/vercel-edge-projection-v1.d.ts

@@ -0,0 +1,24 @@
+import type { EdgeRouteManifest } from './personalization-host.js';
+export declare const VERCEL_EDGE_PROJECTION_SCHEMA_V1 = "gradial.vercel.edgeRoutes.v1";
+export declare const VERCEL_EDGE_PROJECTION_ENCODING_V1 = "gzip+base64";
+export declare const MAX_VERCEL_EDGE_MANIFEST_BYTES_V1: number;
+export interface ActiveReleasePointerV1 {
+    releaseId: string;
+    sequence: bigint;
+}
+export interface DeploymentCompatibilityV1 {
+    minReleaseId?: string;
+    minSequence?: bigint;
+    maxReleaseId?: string;
+    maxSequence?: bigint;
+}
+export declare function activeReleaseV1Key(siteId: string): string;
+export declare function edgeRoutesV1Key(siteId: string, releaseId: string): string;
+export declare function deploymentCompatibilityKey(siteId: string, deploymentId: string): string;
+export declare function decodeActiveReleaseV1(value: unknown): ActiveReleasePointerV1;
+export declare function decodeDeploymentCompatibilityV1(value: unknown): DeploymentCompatibilityV1;
+export declare function clampDeploymentCompatibleReleaseV1(active: ActiveReleasePointerV1, compatibility: DeploymentCompatibilityV1): string;
+export declare function decodeEdgeRouteProjectionV1(value: unknown, expected: {
+    siteId: string;
+    releaseId: string;
+}): EdgeRouteManifest;