@gradial/aci 0.1.45 → 0.1.47

package/dist/next/vercel-s3-personalization.js

@@ -2,6 +2,7 @@ import { GetObjectCommand, HeadObjectCommand, PutObjectCommand, S3Client, } from
 import { awsCredentialsProvider } from '@vercel/oidc-aws-credentials-provider';
 import { getUncachedEdgeConfigValue } from './edge-config.js';
 import { IdentityErasureFencedError } from './personalization-host.js';
+import { decodeEdgeRouteProjectionV1, edgeRoutesV1Key, } from './vercel-edge-projection-v1.js';
 const ENVELOPE_DIGEST_METADATA_KEY = 'aci-envelope-sha256';
 const COLLECTION_GATE_ETAG_METADATA_KEY = 'aci-collection-gate-etag';
 const COLLECTION_GATE_STATE_METADATA_KEY = 'aci-collection-gate-state';
@@ -406,12 +407,13 @@ export class VercelEdgeConfigRouteStore {
         this.siteId = siteId;
     }
     async readEdgeManifest(releaseId) {
-        const value = await getUncachedEdgeConfigValue(this.edgeConfig, edgeRoutesKey(this.siteId, releaseId));
-        if (!value)
+        const value = await getUncachedEdgeConfigValue(this.edgeConfig, edgeRoutesV1Key(this.siteId, releaseId));
+        if (value == null)
             return null;
-        if (typeof value === 'string')
-            return JSON.parse(value);
-        return value;
+        return decodeEdgeRouteProjectionV1(value, {
+            siteId: this.siteId,
+            releaseId,
+        });
     }
 }
 export function createVercelS3PersonalizationStore(config) {
@@ -531,12 +533,6 @@ function cleanKey(value) {
 function joinKey(...parts) {
     return parts.map(cleanKey).filter(Boolean).join('/');
 }
-function edgeRoutesKey(siteId, releaseId) {
-    return `edgeRoutes_${edgeKeySegment(siteId)}_${edgeKeySegment(releaseId)}`;
-}
-function edgeKeySegment(value) {
-    return value.replace(/[^A-Za-z0-9_-]/g, '_');
-}
 function isNotFound(error) {
     const value = error;
     return value?.$metadata?.httpStatusCode === 404 || value?.name === 'NoSuchKey' || value?.name === 'NotFound';

package/dist/providers/s3.d.ts

@@ -32,10 +32,8 @@ export declare class S3ContentProvider implements ContentProvider {
     getSiteConfig<T = unknown>(): Promise<T>;
     getPage<T = unknown>(route: string): Promise<T>;
     /**
-     * getPageByRef serves the exact payload the edge selected (the
-     * X-Aci-Content-Ref contract): base page or variant. Only refs the
-     * release manifest declares are served — the header names published
-     * content, it cannot address arbitrary keys.
+     * 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>;

package/dist/providers/s3.js

@@ -1,8 +1,9 @@
 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 { 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
 // ---------------------------------------------------------------------------
@@ -23,29 +24,21 @@ export class S3ContentProvider {
         return await this.getJSON(manifest.siteConfigRef);
     }
     async getPage(route) {
-        const manifest = await this.manifest();
-        const normalized = normalizeRoute(route);
-        const entry = Object.values(manifest.routes).find((candidate) => normalizeRoute(candidate.path) === normalized);
-        if (!entry) {
-            throw new PageNotFoundError(route);
-        }
-        try {
-            return await this.getJSON(entry.payloadRef);
-        }
-        catch (error) {
-            throw new PageNotFoundError(route, error);
-        }
+        return (await this.#selectPage({
+            route,
+            contentRef: '',
+            contentRefPresent: false,
+            variantKey: '',
+            variantKeyPresent: false,
+        })).page;
     }
     /**
-     * getPageByRef serves the exact payload the edge selected (the
-     * X-Aci-Content-Ref contract): base page or variant. Only refs the
-     * release manifest declares are served — the header names published
-     * content, it cannot address arbitrary keys.
+     * 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) => entry.payloadRef === payloadRef ||
-            Object.values(entry.variants ?? {}).some((variant) => variant.payloadRef === payloadRef));
+        const known = Object.values(manifest.routes).some((entry) => routeContainsRef(entry, payloadRef));
         if (!known) {
             throw new PageNotFoundError(payloadRef);
         }
@@ -56,6 +49,20 @@ export class S3ContentProvider {
             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];
@@ -92,6 +99,149 @@ export class S3ContentProvider {
     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
@@ -278,3 +428,7 @@ function joinKey(...parts) {
         .filter(Boolean)
         .join('/');
 }
+function joinManifestContentKey(prefix, contentRef) {
+    const normalizedPrefix = joinKey(prefix);
+    return normalizedPrefix ? `${normalizedPrefix}/${contentRef}` : contentRef;
+}

package/dist/types/block-ref.d.ts

@@ -5,7 +5,6 @@ export interface BlockRefMeta {
     multiple: boolean;
 }
 declare const blockRefBase: z.ZodObject<{
-    $type: z.ZodLiteral<"component">;
     id: z.ZodString;
     component: z.ZodString;
     props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -13,7 +12,6 @@ declare const blockRefBase: z.ZodObject<{
 type InferContractProps<T> = T extends ComponentContract<string, infer Schema> ? Schema extends z.ZodType<infer P> ? P : Record<string, unknown> : Record<string, unknown>;
 type InferContractId<T> = T extends ComponentContract<infer Id, unknown> ? Id : never;
 export type BlockRefEntry<T extends ComponentContract> = {
-    $type: 'component';
     id: string;
     component: InferContractId<T>;
     props: InferContractProps<T>;

package/dist/types/block-ref.js

@@ -1,7 +1,6 @@
 import { z } from 'zod';
 const BLOCK_REF_KEY = '_gradialBlockRef';
 const blockRefBase = z.object({
-    $type: z.literal('component'),
     id: z.string().min(1),
     component: z.string().min(1),
     props: z.record(z.string(), z.unknown()),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gradial/aci",
-  "version": "0.1.45",
+  "version": "0.1.47",
   "repository": {
     "type": "git",
     "url": "https://github.com/gradial/bare-metal-go.git",
@@ -91,6 +91,11 @@
       "types": "./dist/next/dev-refresh.d.ts",
       "import": "./dist/next/dev-refresh.js"
     },
+    "./next/error-seat": {
+      "types": "./dist/next/error-seat.d.ts",
+      "import": "./dist/next/error-seat.js",
+      "default": "./dist/next/error-seat.js"
+    },
     "./next/server": {
       "types": "./dist/next/server.d.ts",
       "import": "./dist/next/server.js",
@@ -114,9 +119,10 @@
     }
   },
   "scripts": {
-    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json && node scripts/build-collect.mjs",
-    "test": "node --import tsx --test \"src/**/*.test.ts\"",
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json && node scripts/assert-render-proof-public-surface.mjs && node scripts/build-collect.mjs",
+    "test": "node --import tsx --test \"src/**/*.test.ts\" \"src/**/*.test.tsx\"",
     "build:collect": "node scripts/build-collect.mjs",
+    "generate-default-error-page": "node scripts/generate-default-error-page.mjs",
     "build:cli": "cd ../.. && ./scripts/build-cli.sh",
     "generate-starters": "cd ../.. && tsx scripts/generate-starters.ts",
     "compile-registry": "tsx src/cli/compile-registry.mjs",
@@ -164,11 +170,11 @@
     "zod": "^4.0.0"
   },
   "optionalDependencies": {
-    "@gradial/aci-cli-darwin-arm64": "0.1.45",
-    "@gradial/aci-cli-darwin-x64": "0.1.45",
-    "@gradial/aci-cli-linux-arm64": "0.1.45",
-    "@gradial/aci-cli-linux-x64": "0.1.45",
-    "@gradial/aci-cli-win32-arm64": "0.1.45",
-    "@gradial/aci-cli-win32-x64": "0.1.45"
+    "@gradial/aci-cli-darwin-arm64": "0.1.47",
+    "@gradial/aci-cli-darwin-x64": "0.1.47",
+    "@gradial/aci-cli-linux-arm64": "0.1.47",
+    "@gradial/aci-cli-linux-x64": "0.1.47",
+    "@gradial/aci-cli-win32-arm64": "0.1.47",
+    "@gradial/aci-cli-win32-x64": "0.1.47"
   }
 }

package/src/cli/compile-registry.mjs

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
-import { realpathSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { pathToFileURL } from 'node:url';
 import { z } from 'zod';
 import { ImageSchema } from '../types/image.ts';
 import { VideoSchema } from '../types/video.ts';
@@ -20,15 +19,14 @@ try {
   if (!globalThis.React) globalThis.React = React;
 } catch { /* react not available — component files without JSX will still work */ }
 
-if (isMainModule()) {
-  const args = parseArgs(process.argv.slice(2));
-  try {
-    const result = await compileRegistry(args);
-    console.log(JSON.stringify({ success: true, ...result, errors: [] }, null, 2));
-  } catch (error) {
-    console.error(JSON.stringify({ success: false, errors: [String(error?.message ?? error)] }, null, 2));
-    process.exitCode = 1;
-  }
+const args = parseArgs(process.argv.slice(2));
+
+try {
+  const result = await compileRegistry(args);
+  console.log(JSON.stringify({ success: true, ...result, errors: [] }, null, 2));
+} catch (error) {
+  console.error(JSON.stringify({ success: false, errors: [String(error?.message ?? error)] }, null, 2));
+  process.exitCode = 1;
 }
 
 async function compileRegistry(options) {
@@ -432,10 +430,9 @@ async function generatePageSchema(schemaDir, componentEntries, outDir) {
   const defs = {
     baseBlock: {
       type: 'object',
-      required: ['$type', 'id', 'component', 'props'],
+      required: ['id', 'component', 'props'],
       additionalProperties: true,
       properties: {
-        $type: { const: 'component' },
         id: { type: 'string', minLength: 1 },
         component: { type: 'string' },
         props: { type: 'object' },
@@ -744,14 +741,3 @@ function parseArgs(argv) {
   }
   return out;
 }
-
-function isMainModule() {
-  if (!process.argv[1]) return false;
-  try {
-    return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(path.resolve(process.argv[1]));
-  } catch {
-    return false;
-  }
-}
-
-export { compileRegistry, generatePageSchema };