@gradial/aci 0.1.48 → 0.1.51-ssr.2

package/dist/providers/s3.d.ts

@@ -1,47 +0,0 @@
-import { type CompiledManifest, type ContentProvider, type RouteEntry } from '../content/provider.js';
-export interface S3ContentProviderConfig {
-    bucket?: string;
-    keyPrefix?: string;
-    region?: string;
-    accessKeyId?: string;
-    secretAccessKey?: string;
-    sessionToken?: string;
-    roleArn?: string;
-    endpoint?: string;
-}
-type ResolvedS3Config = {
-    bucket: string;
-    keyPrefix: string;
-    region: string;
-    accessKeyId: string;
-    secretAccessKey: string;
-    sessionToken: string;
-    roleArn: string;
-    endpoint: string;
-};
-export interface S3CommandClient {
-    send(command: {
-        input: unknown;
-    }): Promise<any>;
-}
-export declare class S3ContentProvider implements ContentProvider {
-    #private;
-    readonly config: ResolvedS3Config;
-    constructor(config?: S3ContentProviderConfig, client?: S3CommandClient);
-    listRoutes(): Promise<RouteEntry[]>;
-    getSiteConfig<T = unknown>(): Promise<T>;
-    getPage<T = unknown>(route: string): Promise<T>;
-    /**
-     * getPageByRef serves an exact payload the manifest declares. The stricter
-     * route-bound selection used by server rendering stays package-internal.
-     */
-    getPageByRef<T = unknown>(payloadRef: string): Promise<T>;
-    getFragment<T = unknown>(id: string): Promise<T>;
-    getLayout<T = unknown>(name: string): Promise<T>;
-    manifest(): Promise<CompiledManifest>;
-    fetchRaw(key: string): Promise<Response>;
-    private getJSON;
-}
-export declare function getS3JSON<T>(key: string, config: ResolvedS3Config, client?: S3CommandClient): Promise<T>;
-export declare function getS3Raw(key: string, config: ResolvedS3Config, client?: S3CommandClient): Promise<Response>;
-export {};

package/dist/providers/s3.js

@@ -1,434 +0,0 @@
-import crypto from 'node:crypto';
-import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
-import { awsCredentialsProvider } from '@vercel/oidc-aws-credentials-provider';
-import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError, } from '../content/provider.js';
-import { normalizeRoute } from '../content/routes.js';
-import { createVerifiedPageReceipt, selectVerifiedPage, validateVerifiedPageReceipt, } from '../internal/render-proof.js';
-// ---------------------------------------------------------------------------
-// S3 content provider — reads compiled content files from S3
-// ---------------------------------------------------------------------------
-export class S3ContentProvider {
-    config;
-    #manifest;
-    #client;
-    constructor(config = {}, client) {
-        this.config = resolveS3Config(config);
-        this.#client = client || oidcS3Client(this.config);
-    }
-    async listRoutes() {
-        const manifest = await this.manifest();
-        return Object.values(manifest.routes).sort((a, b) => a.path.localeCompare(b.path));
-    }
-    async getSiteConfig() {
-        const manifest = await this.manifest();
-        return await this.getJSON(manifest.siteConfigRef);
-    }
-    async getPage(route) {
-        return (await this.#selectPage({
-            route,
-            contentRef: '',
-            contentRefPresent: false,
-            variantKey: '',
-            variantKeyPresent: false,
-        })).page;
-    }
-    /**
-     * getPageByRef serves an exact payload the manifest declares. The stricter
-     * route-bound selection used by server rendering stays package-internal.
-     */
-    async getPageByRef(payloadRef) {
-        const manifest = await this.manifest();
-        const known = Object.values(manifest.routes).some((entry) => routeContainsRef(entry, payloadRef));
-        if (!known) {
-            throw new PageNotFoundError(payloadRef);
-        }
-        try {
-            return await this.getJSON(payloadRef);
-        }
-        catch (error) {
-            throw new PageNotFoundError(payloadRef, error);
-        }
-    }
-    /** @internal */
-    async [selectVerifiedPage](request) {
-        const selection = await this.#selectPage(request, request.releaseId);
-        return Object.freeze({
-            page: selection.page,
-            receipt: createVerifiedPageReceipt({
-                releaseId: request.releaseId,
-                route: selection.route,
-                contentRef: selection.contentRef,
-                contentSha256: selection.contentSha256,
-                variantKey: selection.variantKey,
-            }),
-        });
-    }
-    async getFragment(id) {
-        const manifest = await this.manifest();
-        const entry = manifest.fragments[id];
-        if (!entry) {
-            throw new FragmentNotFoundError(id);
-        }
-        try {
-            return await this.getJSON(entry.payloadRef);
-        }
-        catch (error) {
-            throw new FragmentNotFoundError(id, error);
-        }
-    }
-    async getLayout(name) {
-        const manifest = await this.manifest();
-        const layouts = manifest.layouts;
-        if (!layouts || !layouts[name]) {
-            throw new LayoutNotFoundError(name);
-        }
-        try {
-            return await this.getJSON(`layouts/${name}.json`);
-        }
-        catch (error) {
-            throw new LayoutNotFoundError(name, error);
-        }
-    }
-    async manifest() {
-        this.#manifest ??= this.getJSON('manifest.json');
-        return await this.#manifest;
-    }
-    async fetchRaw(key) {
-        return await getS3Raw(key, this.config, this.#client);
-    }
-    async getJSON(key) {
-        return await getS3JSON(joinKey(this.config.keyPrefix, key), this.config, this.#client);
-    }
-    async #selectPage(request, releaseId) {
-        if (request.variantKeyPresent && !request.contentRefPresent) {
-            throw pageIntegrityError('variant header requires a content ref');
-        }
-        const manifest = await this.manifest();
-        const normalized = normalizeRoute(request.route);
-        const routeMatches = Object.values(manifest.routes).filter((candidate) => normalizeRoute(candidate.path) === normalized);
-        if (routeMatches.length === 0) {
-            if (request.contentRefPresent) {
-                const elsewhere = Object.values(manifest.routes)
-                    .some((candidate) => routeContainsRef(candidate, request.contentRef));
-                const reason = elsewhere ? 'cross-route content ref' : 'undeclared route content ref';
-                throw pageIntegrityError(`${reason}: ${request.contentRef}`);
-            }
-            throw new PageNotFoundError(request.route);
-        }
-        if (routeMatches.length !== 1) {
-            throw pageIntegrityError(`route ${normalized} is ambiguous`);
-        }
-        const entry = routeMatches[0];
-        const route = normalizeRoute(entry.path);
-        const tuples = [
-            {
-                contentRef: entry.payloadRef,
-                digest: entry.digest,
-                variantKey: '',
-                isVariant: false,
-            },
-            ...Object.values(entry.variants ?? {}).map(pageTupleForVariant),
-        ];
-        let tuple;
-        if (!request.contentRefPresent) {
-            tuple = tuples[0];
-        }
-        else {
-            const matches = tuples.filter((candidate) => {
-                if (candidate.contentRef !== request.contentRef)
-                    return false;
-                if (!request.variantKeyPresent)
-                    return true;
-                return candidate.isVariant && candidate.variantKey === request.variantKey;
-            });
-            if (matches.length === 0) {
-                const elsewhere = Object.values(manifest.routes)
-                    .filter((candidate) => candidate !== entry)
-                    .some((candidate) => routeContainsRef(candidate, request.contentRef));
-                const reason = elsewhere ? 'cross-route content ref' : 'undeclared route content ref';
-                throw pageIntegrityError(`${reason}: ${request.contentRef}`);
-            }
-            if (matches.length !== 1) {
-                throw pageIntegrityError(`ambiguous route content ref: ${request.contentRef}`);
-            }
-            tuple = matches[0];
-        }
-        const digestMatch = /^sha256:([0-9a-f]{64})$/.exec(tuple.digest);
-        if (!digestMatch) {
-            throw pageIntegrityError(`invalid manifest digest for ${tuple.contentRef}`);
-        }
-        const contentSha256 = digestMatch[1];
-        if (releaseId !== undefined) {
-            validateVerifiedPageReceipt({
-                releaseId,
-                route,
-                contentRef: tuple.contentRef,
-                contentSha256,
-                variantKey: tuple.variantKey,
-            });
-        }
-        const key = joinManifestContentKey(this.config.keyPrefix, tuple.contentRef);
-        let response;
-        try {
-            response = await getS3Raw(key, this.config, this.#client);
-        }
-        catch (cause) {
-            throw pageIntegrityError(`fetch failed for ${tuple.contentRef}`, cause);
-        }
-        if (!response.ok) {
-            const detail = await safeResponseText(response);
-            throw pageIntegrityError(`fetch failed for ${tuple.contentRef} with status ${response.status}${detail ? `: ${detail}` : ''}`);
-        }
-        let bytes;
-        try {
-            bytes = new Uint8Array(await response.arrayBuffer());
-        }
-        catch (cause) {
-            throw pageIntegrityError(`response body failed for ${tuple.contentRef}`, cause);
-        }
-        const actualDigest = crypto.createHash('sha256').update(bytes).digest('hex');
-        if (actualDigest !== contentSha256) {
-            throw pageIntegrityError(`digest mismatch for ${tuple.contentRef}: got ${actualDigest}, want ${contentSha256}`);
-        }
-        let source = '';
-        try {
-            source = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
-        }
-        catch (cause) {
-            throw pageIntegrityError(`invalid UTF-8 for ${tuple.contentRef}`, cause);
-        }
-        let page;
-        try {
-            page = JSON.parse(source);
-        }
-        catch (cause) {
-            throw pageIntegrityError(`invalid JSON for ${tuple.contentRef}`, cause);
-        }
-        return Object.freeze({
-            page,
-            route,
-            contentRef: tuple.contentRef,
-            contentSha256,
-            variantKey: tuple.variantKey,
-        });
-    }
-}
-function pageTupleForVariant(variant) {
-    if (typeof variant.variantKey !== 'string' || variant.variantKey === '') {
-        throw pageIntegrityError('variant manifest tuple has an empty variant key');
-    }
-    return {
-        contentRef: variant.payloadRef,
-        digest: variant.digest,
-        variantKey: variant.variantKey,
-        isVariant: true,
-    };
-}
-function routeContainsRef(entry, contentRef) {
-    return entry.payloadRef === contentRef
-        || Object.values(entry.variants ?? {})
-            .some((variant) => variant.payloadRef === contentRef);
-}
-function pageIntegrityError(message, cause) {
-    const error = new Error(`ACI S3 page integrity error: ${message}`);
-    if (cause !== undefined)
-        error.cause = cause;
-    return error;
-}
-async function safeResponseText(response) {
-    try {
-        return await response.text();
-    }
-    catch {
-        return '';
-    }
-}
-// ---------------------------------------------------------------------------
-// S3 fetch with AWS SigV4 signing
-// ---------------------------------------------------------------------------
-export async function getS3JSON(key, config, client) {
-    const startTime = Date.now();
-    const res = await getS3Raw(key, config, client);
-    const duration = Date.now() - startTime;
-    console.log(`[ACI S3] GET ${key} - ${res.status} in ${duration}ms`);
-    if (!res.ok) {
-        throw new Error(`S3 GET ${key} failed with status ${res.status}: ${await res.text()}`);
-    }
-    return (await res.json());
-}
-export async function getS3Raw(key, config, client) {
-    if (client)
-        return await getS3RawWithClient(key, config, client);
-    const url = s3ObjectURL(config, key);
-    const signedHeaders = signedS3Headers('GET', url, config);
-    return await fetch(url, {
-        method: 'GET',
-        headers: signedHeaders,
-        cache: 'no-store'
-    });
-}
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-function resolveS3Config(config) {
-    const resolved = {
-        bucket: configuredValue(config.bucket, process.env.ACI_S3_BUCKET),
-        keyPrefix: configuredValue(config.keyPrefix, process.env.ACI_S3_KEY_PREFIX),
-        region: configuredValue(config.region, process.env.AWS_REGION) || 'us-east-1',
-        accessKeyId: configuredValue(config.accessKeyId, process.env.AWS_ACCESS_KEY_ID),
-        secretAccessKey: configuredValue(config.secretAccessKey, process.env.AWS_SECRET_ACCESS_KEY),
-        sessionToken: configuredValue(config.sessionToken, process.env.AWS_SESSION_TOKEN),
-        roleArn: configuredValue(config.roleArn, process.env.AWS_ROLE_ARN),
-        endpoint: trimSlash(configuredValue(config.endpoint, process.env.ACI_S3_ENDPOINT))
-    };
-    if (!resolved.bucket)
-        throw new Error('S3 config missing bucket');
-    if (!resolved.roleArn) {
-        if (resolved.accessKeyId && !resolved.secretAccessKey) {
-            throw new Error('S3 config missing secretAccessKey');
-        }
-        if (!resolved.accessKeyId && resolved.secretAccessKey) {
-            throw new Error('S3 config missing accessKeyId');
-        }
-        if (!resolved.accessKeyId) {
-            throw new Error('S3 config missing credential mode: set AWS_ROLE_ARN or both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY');
-        }
-    }
-    return resolved;
-}
-function oidcS3Client(config) {
-    if (!config.roleArn)
-        return undefined;
-    return new S3Client({
-        region: config.region,
-        ...(config.endpoint ? {
-            endpoint: config.endpoint,
-            forcePathStyle: true,
-        } : {}),
-        credentials: awsCredentialsProvider({
-            roleArn: config.roleArn,
-            clientConfig: { region: config.region },
-        }),
-    });
-}
-async function getS3RawWithClient(key, config, client) {
-    try {
-        const output = await client.send(new GetObjectCommand({
-            Bucket: config.bucket,
-            Key: key,
-        }));
-        if (!output.Body?.transformToWebStream) {
-            throw new Error(`S3 GET ${key} returned an unsupported object body`);
-        }
-        const headers = new Headers();
-        if (output.ContentType)
-            headers.set('content-type', output.ContentType);
-        if (output.ContentLength !== undefined) {
-            headers.set('content-length', String(output.ContentLength));
-        }
-        if (output.ETag)
-            headers.set('etag', output.ETag);
-        if (output.LastModified) {
-            headers.set('last-modified', output.LastModified.toUTCString());
-        }
-        return new Response(output.Body.transformToWebStream(), {
-            status: 200,
-            headers,
-        });
-    }
-    catch (error) {
-        const status = s3ErrorStatus(error);
-        if (status) {
-            return new Response(error instanceof Error ? error.message : String(error), { status });
-        }
-        throw new Error(`S3 GET ${key} failed`, { cause: error });
-    }
-}
-function s3ErrorStatus(error) {
-    if (!error || typeof error !== 'object')
-        return undefined;
-    const status = error
-        .$metadata?.httpStatusCode;
-    return typeof status === 'number' && status >= 400 && status <= 599
-        ? status
-        : undefined;
-}
-function configuredValue(configured, environment) {
-    return (configured === undefined ? environment : configured)?.trim() || '';
-}
-function s3ObjectURL(config, key) {
-    const encodedKey = encodeKey(key);
-    if (config.endpoint) {
-        return new URL(`${config.endpoint}/${encodeURIComponent(config.bucket)}${encodedKey}`);
-    }
-    return new URL(`https://${config.bucket}.s3.${config.region}.amazonaws.com${encodedKey}`);
-}
-function signedS3Headers(method, url, config) {
-    const now = new Date();
-    const amzDate = amzTimestamp(now);
-    const dateStamp = amzDate.slice(0, 8);
-    const payloadHash = sha256Hex('');
-    const headers = new Headers({
-        host: url.host,
-        'x-amz-content-sha256': payloadHash,
-        'x-amz-date': amzDate
-    });
-    if (config.sessionToken)
-        headers.set('x-amz-security-token', config.sessionToken);
-    const signedHeaderNames = Array.from(headers.keys()).sort();
-    const canonicalHeaders = signedHeaderNames.map((k) => `${k}:${headers.get(k)?.trim()}\n`).join('');
-    const canonicalRequest = [
-        method,
-        url.pathname,
-        url.searchParams.toString(),
-        canonicalHeaders,
-        signedHeaderNames.join(';'),
-        payloadHash
-    ].join('\n');
-    const credentialScope = `${dateStamp}/${config.region}/s3/aws4_request`;
-    const stringToSign = [
-        'AWS4-HMAC-SHA256',
-        amzDate,
-        credentialScope,
-        sha256Hex(canonicalRequest)
-    ].join('\n');
-    const signingKey = awsSigningKey(config.secretAccessKey, dateStamp, config.region, 's3');
-    const signature = hmacHex(signingKey, stringToSign);
-    headers.set('authorization', `AWS4-HMAC-SHA256 Credential=${config.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaderNames.join(';')}, Signature=${signature}`);
-    return headers;
-}
-function awsSigningKey(secret, dateStamp, region, service) {
-    const kDate = hmac(Buffer.from(`AWS4${secret}`, 'utf8'), dateStamp);
-    const kRegion = hmac(kDate, region);
-    const kService = hmac(kRegion, service);
-    return hmac(kService, 'aws4_request');
-}
-function amzTimestamp(date) {
-    return date.toISOString().replace(/[:-]|\.\d{3}/g, '');
-}
-function hmac(key, value) {
-    return crypto.createHmac('sha256', key).update(value, 'utf8').digest();
-}
-function hmacHex(key, value) {
-    return crypto.createHmac('sha256', key).update(value, 'utf8').digest('hex');
-}
-function sha256Hex(value) {
-    return crypto.createHash('sha256').update(value, 'utf8').digest('hex');
-}
-function trimSlash(value) {
-    return value.replace(/\/+$/, '');
-}
-function encodeKey(key) {
-    return `/${key.split('/').map(encodeURIComponent).join('/')}`;
-}
-function joinKey(...parts) {
-    return parts
-        .flatMap((part) => part.split('/'))
-        .map((part) => part.trim())
-        .filter(Boolean)
-        .join('/');
-}
-function joinManifestContentKey(prefix, contentRef) {
-    const normalizedPrefix = joinKey(prefix);
-    return normalizedPrefix ? `${normalizedPrefix}/${contentRef}` : contentRef;
-}

package/dist/types/render-mode.d.ts

@@ -1,2 +0,0 @@
-export type IslandMode = 'ssr' | 'client';
-export type VaryDimension = 'geo:country' | 'geo:region' | 'geo:city' | `cookie:${string}` | `header:${string}` | 'locale' | `query:${string}`;

package/dist/types/render-mode.js

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

package/dist/types/renderer.d.ts

@@ -1,71 +0,0 @@
-import type { PageDocument } from './page.js';
-import type { VaryDimension } from './render-mode.js';
-export interface RenderCapabilities {
-    staticRender: boolean;
-    ssr: boolean;
-    ssrIslands: boolean;
-    clientIslands: boolean;
-    fragmentRender: boolean;
-}
-export interface Renderer {
-    renderPage(request: RenderPageRequest): Promise<RenderPageResult>;
-    renderFragment?(request: RenderFragmentRequest): Promise<RenderResult>;
-    renderIsland?(request: RenderIslandRequest): Promise<RenderResult>;
-}
-export interface RenderPageRequest {
-    page: PageDocument;
-    requestContext?: RequestContext;
-    release: ReleaseContext;
-}
-export interface RequestContext {
-    url: string;
-    method: string;
-    headers: Record<string, string>;
-    cookies: Record<string, string>;
-    geo?: GeoContext;
-}
-export interface GeoContext {
-    country?: string;
-    region?: string;
-    city?: string;
-}
-export interface ReleaseContext {
-    releaseId: string;
-    codeDigest: string;
-    contentSnapshotId: string;
-    assetUrl(logicalPath: string): string;
-}
-export interface RenderFragmentRequest {
-    fragmentId: string;
-    content: unknown;
-    release: ReleaseContext;
-}
-export interface RenderIslandRequest {
-    islandId: string;
-    component: string;
-    props: Record<string, unknown>;
-    requestContext: RequestContext;
-    release: ReleaseContext;
-}
-export interface RenderResult {
-    html: string;
-    status?: number;
-    headers?: Record<string, string>;
-    cachePolicy?: CachePolicy;
-}
-export interface RenderPageResult extends RenderResult {
-    islands?: IslandDescriptor[];
-}
-export interface IslandDescriptor {
-    islandId: string;
-    component: string;
-    props: Record<string, unknown>;
-    mode: 'ssr' | 'client';
-    varyDimensions?: VaryDimension[];
-}
-export interface CachePolicy {
-    scope: 'public' | 'private' | 'no-store';
-    ttl?: number;
-    staleWhileRevalidate?: number;
-    tags?: string[];
-}

package/dist/types/renderer.js

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

package/src/types/render-mode.ts

@@ -1,10 +0,0 @@
-export type IslandMode = 'ssr' | 'client';
-
-export type VaryDimension =
-  | 'geo:country'
-  | 'geo:region'
-  | 'geo:city'
-  | `cookie:${string}`
-  | `header:${string}`
-  | 'locale'
-  | `query:${string}`;

package/src/types/renderer.ts

@@ -1,83 +0,0 @@
-import type { PageDocument } from './page.js';
-import type { VaryDimension } from './render-mode.js';
-
-export interface RenderCapabilities {
-  staticRender: boolean;
-  ssr: boolean;
-  ssrIslands: boolean;
-  clientIslands: boolean;
-  fragmentRender: boolean;
-}
-
-export interface Renderer {
-  renderPage(request: RenderPageRequest): Promise<RenderPageResult>;
-  renderFragment?(request: RenderFragmentRequest): Promise<RenderResult>;
-  renderIsland?(request: RenderIslandRequest): Promise<RenderResult>;
-}
-
-export interface RenderPageRequest {
-  page: PageDocument;
-  requestContext?: RequestContext;
-  release: ReleaseContext;
-}
-
-export interface RequestContext {
-  url: string;
-  method: string;
-  headers: Record<string, string>;
-  cookies: Record<string, string>;
-  geo?: GeoContext;
-}
-
-export interface GeoContext {
-  country?: string;
-  region?: string;
-  city?: string;
-}
-
-export interface ReleaseContext {
-  releaseId: string;
-  codeDigest: string;
-  contentSnapshotId: string;
-  assetUrl(logicalPath: string): string;
-}
-
-export interface RenderFragmentRequest {
-  fragmentId: string;
-  content: unknown;
-  release: ReleaseContext;
-}
-
-export interface RenderIslandRequest {
-  islandId: string;
-  component: string;
-  props: Record<string, unknown>;
-  requestContext: RequestContext;
-  release: ReleaseContext;
-}
-
-export interface RenderResult {
-  html: string;
-  status?: number;
-  headers?: Record<string, string>;
-  cachePolicy?: CachePolicy;
-}
-
-export interface RenderPageResult extends RenderResult {
-  islands?: IslandDescriptor[];
-}
-
-export interface IslandDescriptor {
-  islandId: string;
-  component: string;
-  props: Record<string, unknown>;
-  mode: 'ssr' | 'client';
-  varyDimensions?: VaryDimension[];
-}
-
-export interface CachePolicy {
-  scope: 'public' | 'private' | 'no-store';
-  ttl?: number;
-  staleWhileRevalidate?: number;
-  tags?: string[];
-}

package/templates/nextjs/starter-content/src/middleware.ts

@@ -1,41 +0,0 @@
-import { createGradialMiddleware } from '@gradial/aci/next/middleware';
-import { createVercelPersonalizationFromEnv } from '@gradial/aci/next/vercel-personalization';
-
-export default createGradialMiddleware({
-  personalization: createVercelPersonalizationFromEnv(),
-});
-
-export const config = {
-  runtime: 'nodejs',
-  matcher: [
-    '/((?!_next(?:/|$)|api(?:/|$)|collect(?:/|$)|gradial/assets(?:/|$)|favicon\\.ico$).*)',
-    {
-      source: '/:path*',
-      has: [{ type: 'header', key: 'x-gradial-framework-origin-auth' }],
-    },
-    {
-      source: '/:path*',
-      has: [{ type: 'header', key: 'x-baremetal-site-id' }],
-    },
-    {
-      source: '/:path*',
-      has: [{ type: 'header', key: 'x-baremetal-release-id' }],
-    },
-    {
-      source: '/:path*',
-      has: [{ type: 'header', key: 'x-aci-content-ref' }],
-    },
-    {
-      source: '/:path*',
-      has: [{ type: 'header', key: 'x-baremetal-content-base-url' }],
-    },
-    {
-      source: '/:path*',
-      has: [{ type: 'header', key: 'x-aci-content-path' }],
-    },
-    {
-      source: '/:path*',
-      has: [{ type: 'query', key: '__aci_content_path' }],
-    },
-  ],
-};