@gradial/aci 0.1.52-rc.2 → 0.1.52-rc.21

package/dist/next/vercel-edge-projection-v1.js

@@ -1,27 +1,20 @@
-import { createHash } from 'node:crypto';
-import { inflateRawSync } from 'node:zlib';
-export const VERCEL_EDGE_PROJECTION_SCHEMA_V1 = 'gradial.vercel.edgeRoutes.v1';
-export const VERCEL_EDGE_PROJECTION_ENCODING_V1 = 'gzip+base64';
-export const MAX_VERCEL_EDGE_MANIFEST_BYTES_V1 = 1 << 20;
+// The v1 Vercel Edge Config release-state contract read by the Next SSR
+// server (next/server.ts): the active-release pointer and the per-deployment
+// compatibility clamp. Values are canonical Go-encoded JSON strings; decoding
+// is strict — byte-for-byte canonical form, exact fields, bounded size.
+//
+// The v1 edge-route projection decoder that used to live here served the
+// retired SDK Next personalization-host lane (ADR 0041); the platform-owned
+// edge router (internal/domain/hosting) is the only route-projection consumer
+// now, and it reads route partitions, not Edge Config.
 const ACTIVE_RELEASE_V1_PREFIX = 'activeReleaseV1_';
-const EDGE_ROUTES_V1_PREFIX = 'edgeRoutesV1_';
 const MAX_EDGE_CONFIG_VALUE_BYTES = 65_536;
 const MAX_JSON_DEPTH = 64;
-const SHA256_HEX = /^[0-9a-f]{64}$/;
 const POSITIVE_DECIMAL = /^[1-9][0-9]*$/;
 const MAX_INT64 = 9223372036854775807n;
-const CANONICAL_BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
-const NORMALIZED_GZIP_HEADER = Buffer.from([
-    0x1f, 0x8b, 0x08, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x02, 0xff,
-]);
-const textDecoder = new TextDecoder('utf-8', { fatal: true });
 export function activeReleaseV1Key(siteId) {
     return `${ACTIVE_RELEASE_V1_PREFIX}${edgeKeySegment(siteId)}`;
 }
-export function edgeRoutesV1Key(siteId, releaseId) {
-    return `${EDGE_ROUTES_V1_PREFIX}${edgeKeySegment(siteId)}_${edgeKeySegment(releaseId)}`;
-}
 export function deploymentCompatibilityKey(siteId, deploymentId) {
     return `deploymentCompatibility_${edgeKeySegment(siteId)}_${edgeKeySegment(deploymentId)}`;
 }
@@ -86,89 +79,6 @@ export function clampDeploymentCompatibleReleaseV1(active, compatibility) {
     }
     return active.releaseId;
 }
-export function decodeEdgeRouteProjectionV1(value, expected) {
-    const envelope = parseEnvelope(value);
-    const expectedSiteId = requiredIdentity(expected.siteId, 'expected site ID');
-    const expectedReleaseId = requiredIdentity(expected.releaseId, 'expected release ID');
-    if (envelope.siteId !== expectedSiteId
-        || envelope.releaseId !== expectedReleaseId) {
-        throw new Error(`v1 edge projection identity mismatch: got `
-            + `${envelope.siteId}/${envelope.releaseId}, `
-            + `want ${expectedSiteId}/${expectedReleaseId}`);
-    }
-    const compressed = decodeCanonicalBase64(envelope.payload);
-    const runtimeBytes = inflateOneNormalizedGzipMember(compressed, envelope.uncompressedLength);
-    const runtimeDigest = sha256(runtimeBytes);
-    if (runtimeDigest !== envelope.runtimeSha256) {
-        throw new Error(`v1 edge projection runtime digest mismatch: got ${runtimeDigest}, `
-            + `want ${envelope.runtimeSha256}`);
-    }
-    let runtimeJSON;
-    try {
-        runtimeJSON = textDecoder.decode(runtimeBytes);
-    }
-    catch (error) {
-        throw new Error('v1 edge projection runtime payload is not valid UTF-8', {
-            cause: error,
-        });
-    }
-    assertCanonicalJSONSyntax(runtimeJSON, 'v1 edge projection runtime payload');
-    let parsed;
-    try {
-        parsed = JSON.parse(runtimeJSON);
-    }
-    catch (error) {
-        throw new Error('v1 edge projection runtime payload is malformed JSON', {
-            cause: error,
-        });
-    }
-    const decoded = validateRuntimeProjection(parsed, {
-        siteId: expectedSiteId,
-        releaseId: expectedReleaseId,
-    });
-    if (canonicalRuntimeProjectionJSON(parsed) !== runtimeJSON) {
-        throw new Error('v1 edge projection runtime payload is not the canonical Go encoding');
-    }
-    return decoded;
-}
-function parseEnvelope(value) {
-    const record = parseCanonicalJSONStringRecord(value, 'v1 edge projection envelope');
-    const orderedKeys = [
-        'schemaVersion',
-        'encoding',
-        'siteId',
-        'releaseId',
-        'sourceSha256',
-        'uncompressedLength',
-        'runtimeSha256',
-        'payload',
-    ];
-    assertExactKeys(record, orderedKeys, [], 'v1 edge projection envelope');
-    if (Object.keys(record).some((key, index) => key !== orderedKeys[index])) {
-        throw new Error('v1 edge projection envelope fields are not canonical');
-    }
-    const envelope = {
-        schemaVersion: requiredString(record.schemaVersion, 'v1 edge projection schema version'),
-        encoding: requiredString(record.encoding, 'v1 edge projection encoding'),
-        siteId: requiredIdentity(record.siteId, 'v1 edge projection site ID'),
-        releaseId: requiredIdentity(record.releaseId, 'v1 edge projection release ID'),
-        sourceSha256: requiredSHA256(record.sourceSha256, 'v1 edge projection source digest'),
-        uncompressedLength: requiredPositiveSafeInteger(record.uncompressedLength, 'v1 edge projection uncompressed length'),
-        runtimeSha256: requiredSHA256(record.runtimeSha256, 'v1 edge projection runtime digest'),
-        payload: requiredString(record.payload, 'v1 edge projection payload'),
-    };
-    if (envelope.schemaVersion !== VERCEL_EDGE_PROJECTION_SCHEMA_V1) {
-        throw new Error(`unsupported v1 edge projection schema ${JSON.stringify(envelope.schemaVersion)}`);
-    }
-    if (envelope.encoding !== VERCEL_EDGE_PROJECTION_ENCODING_V1) {
-        throw new Error(`unsupported v1 edge projection encoding ${JSON.stringify(envelope.encoding)}`);
-    }
-    if (envelope.uncompressedLength > MAX_VERCEL_EDGE_MANIFEST_BYTES_V1) {
-        throw new Error(`v1 edge projection declares ${envelope.uncompressedLength} bytes, `
-            + `maximum ${MAX_VERCEL_EDGE_MANIFEST_BYTES_V1}`);
-    }
-    return envelope;
-}
 function parseCanonicalJSONStringRecord(value, label) {
     if (typeof value !== 'string') {
         throw new Error(`${label} must be a canonical JSON string`);
@@ -190,374 +100,6 @@ function parseCanonicalJSONStringRecord(value, label) {
     }
     return record;
 }
-function decodeCanonicalBase64(value) {
-    if (value.length === 0
-        || value.length % 4 !== 0
-        || !CANONICAL_BASE64.test(value)) {
-        throw new Error('v1 edge projection payload is not canonical padded base64');
-    }
-    const decoded = Buffer.from(value, 'base64');
-    if (decoded.toString('base64') !== value) {
-        throw new Error('v1 edge projection payload is not canonical padded base64');
-    }
-    return decoded;
-}
-function inflateOneNormalizedGzipMember(compressed, declaredLength) {
-    if (compressed.length < NORMALIZED_GZIP_HEADER.length + 8
-        || !compressed.subarray(0, NORMALIZED_GZIP_HEADER.length)
-            .equals(NORMALIZED_GZIP_HEADER)) {
-        throw new Error('v1 edge projection gzip header is not normalized');
-    }
-    let result;
-    try {
-        result = inflateRawSync(compressed.subarray(NORMALIZED_GZIP_HEADER.length), {
-            info: true,
-            maxOutputLength: declaredLength,
-        });
-    }
-    catch (error) {
-        throw new Error('v1 edge projection gzip payload is corrupt or oversized', {
-            cause: error,
-        });
-    }
-    const deflateBytes = result.engine.bytesWritten;
-    const trailerOffset = NORMALIZED_GZIP_HEADER.length + deflateBytes;
-    if (!Number.isSafeInteger(deflateBytes)
-        || deflateBytes <= 0
-        || trailerOffset + 8 !== compressed.length) {
-        throw new Error('v1 edge projection must contain exactly one gzip member with no trailing bytes');
-    }
-    if (result.buffer.byteLength !== declaredLength) {
-        throw new Error(`v1 edge projection decompressed length is ${result.buffer.byteLength}, `
-            + `want ${declaredLength}`);
-    }
-    const expectedCRC = compressed.readUInt32LE(trailerOffset);
-    const actualCRC = crc32(result.buffer);
-    if (actualCRC !== expectedCRC) {
-        throw new Error(`v1 edge projection gzip CRC32 is ${hex32(actualCRC)}, `
-            + `want ${hex32(expectedCRC)}`);
-    }
-    const expectedSize = compressed.readUInt32LE(trailerOffset + 4);
-    if (expectedSize !== result.buffer.byteLength) {
-        throw new Error(`v1 edge projection gzip size is ${expectedSize}, `
-            + `want ${result.buffer.byteLength}`);
-    }
-    return result.buffer;
-}
-function validateRuntimeProjection(value, expected) {
-    const record = requiredRecord(value, 'v1 edge runtime projection');
-    assertExactKeys(record, ['manifestVersion', 'releaseId', 'siteId', 'routes'], ['experiments', 'collectSdk'], 'v1 edge runtime projection');
-    const manifestVersion = requiredString(record.manifestVersion, 'v1 edge runtime manifest version');
-    if (manifestVersion !== 'gradial.edge.v1') {
-        throw new Error(`unsupported v1 edge runtime manifest version ${JSON.stringify(manifestVersion)}`);
-    }
-    const releaseId = requiredIdentity(record.releaseId, 'v1 edge runtime release ID');
-    const siteId = requiredIdentity(record.siteId, 'v1 edge runtime site ID');
-    if (siteId !== expected.siteId || releaseId !== expected.releaseId) {
-        throw new Error(`v1 edge runtime identity mismatch: got ${siteId}/${releaseId}, `
-            + `want ${expected.siteId}/${expected.releaseId}`);
-    }
-    const routesRecord = requiredRecord(record.routes, 'v1 edge runtime routes');
-    const routes = {};
-    for (const [routeKey, routeValue] of Object.entries(routesRecord)) {
-        defineOwnEnumerable(routes, routeKey, validateRoute(routeKey, routeValue));
-    }
-    let experiments;
-    if (Object.prototype.hasOwnProperty.call(record, 'experiments')) {
-        const experimentsRecord = requiredRecord(record.experiments, 'v1 edge runtime experiments');
-        experiments = {};
-        for (const [experimentKey, experimentValue] of Object.entries(experimentsRecord)) {
-            const experiment = validateExperiment(experimentValue);
-            if (experiment.id !== experimentKey) {
-                throw new Error(`v1 edge runtime experiment ${JSON.stringify(experimentKey)} `
-                    + `has identity ${JSON.stringify(experiment.id)}`);
-            }
-            defineOwnEnumerable(experiments, experimentKey, experiment);
-        }
-        if (Object.keys(experiments).length === 0) {
-            throw new Error('v1 edge runtime experiments must be omitted when empty');
-        }
-    }
-    let collectSdk;
-    if (Object.prototype.hasOwnProperty.call(record, 'collectSdk')) {
-        collectSdk = validateCollectSDK(record.collectSdk);
-    }
-    return {
-        manifestVersion,
-        releaseId,
-        siteId,
-        routes,
-        ...(experiments ? { experiments } : {}),
-        ...(collectSdk ? { collectSdk } : {}),
-    };
-}
-function validateRoute(routeKey, value) {
-    const record = requiredRecord(value, `v1 edge route ${JSON.stringify(routeKey)}`);
-    assertExactKeys(record, ['pattern', 'priority', 'dispatch'], ['variants'], `v1 edge route ${JSON.stringify(routeKey)}`);
-    const pattern = requiredString(record.pattern, 'v1 edge route pattern');
-    if (pattern !== routeKey) {
-        throw new Error(`v1 edge route ${JSON.stringify(routeKey)} has pattern `
-            + `${JSON.stringify(pattern)}`);
-    }
-    let variants;
-    if (Object.prototype.hasOwnProperty.call(record, 'variants')) {
-        const variantsRecord = requiredRecord(record.variants, `v1 edge route ${JSON.stringify(routeKey)} variants`);
-        variants = {};
-        for (const [variantKey, variantValue] of Object.entries(variantsRecord)) {
-            defineOwnEnumerable(variants, variantKey, validateVariant(variantKey, variantValue));
-        }
-        if (Object.keys(variants).length === 0) {
-            throw new Error(`v1 edge route ${JSON.stringify(routeKey)} variants must be omitted when empty`);
-        }
-    }
-    return {
-        pattern,
-        priority: requiredSafeInteger(record.priority, 'v1 edge route priority'),
-        dispatch: validateDispatch(record.dispatch),
-        ...(variants ? { variants } : {}),
-    };
-}
-function validateVariant(mapKey, value) {
-    const record = requiredRecord(value, `v1 edge variant ${JSON.stringify(mapKey)}`);
-    assertExactKeys(record, ['variantKey', 'priority', 'dispatch'], ['variantValues', 'rule'], `v1 edge variant ${JSON.stringify(mapKey)}`);
-    const variantKey = requiredString(record.variantKey, 'v1 edge variant key');
-    if (variantKey !== mapKey) {
-        throw new Error(`v1 edge variant ${JSON.stringify(mapKey)} has identity `
-            + `${JSON.stringify(variantKey)}`);
-    }
-    let variantValues;
-    if (Object.prototype.hasOwnProperty.call(record, 'variantValues')) {
-        const values = requiredRecord(record.variantValues, `v1 edge variant ${JSON.stringify(mapKey)} values`);
-        variantValues = {};
-        for (const [key, item] of Object.entries(values)) {
-            defineOwnEnumerable(variantValues, key, requiredString(item, `v1 edge variant value ${JSON.stringify(key)}`));
-        }
-        if (Object.keys(variantValues).length === 0) {
-            throw new Error(`v1 edge variant ${JSON.stringify(mapKey)} values must be omitted when empty`);
-        }
-    }
-    return {
-        variantKey,
-        ...(variantValues ? { variantValues } : {}),
-        priority: requiredSafeInteger(record.priority, 'v1 edge variant priority'),
-        ...(Object.prototype.hasOwnProperty.call(record, 'rule')
-            ? { rule: validateRule(record.rule) }
-            : {}),
-        dispatch: validateDispatch(record.dispatch),
-    };
-}
-function validateDispatch(value) {
-    const record = requiredRecord(value, 'v1 edge dispatch');
-    assertExactKeys(record, ['kind'], ['artifactPath', 'contentPath'], 'v1 edge dispatch');
-    return {
-        kind: requiredString(record.kind, 'v1 edge dispatch kind'),
-        ...(Object.prototype.hasOwnProperty.call(record, 'artifactPath')
-            ? {
-                artifactPath: requiredString(record.artifactPath, 'v1 edge dispatch artifact path'),
-            }
-            : {}),
-        ...(Object.prototype.hasOwnProperty.call(record, 'contentPath')
-            ? {
-                contentPath: requiredString(record.contentPath, 'v1 edge dispatch content path'),
-            }
-            : {}),
-    };
-}
-function validateRule(value) {
-    const record = requiredRecord(value, 'v1 edge variant rule');
-    assertExactKeys(record, [], ['all', 'any'], 'v1 edge variant rule');
-    const rule = {};
-    if (Object.prototype.hasOwnProperty.call(record, 'all')) {
-        const all = validateConditions(record.all, 'all');
-        if (all.length === 0) {
-            throw new Error('v1 edge rule all must be omitted when empty');
-        }
-        rule.all = all;
-    }
-    if (Object.prototype.hasOwnProperty.call(record, 'any')) {
-        const any = validateConditions(record.any, 'any');
-        if (any.length === 0) {
-            throw new Error('v1 edge rule any must be omitted when empty');
-        }
-        rule.any = any;
-    }
-    return rule;
-}
-function validateConditions(value, group) {
-    if (!Array.isArray(value)) {
-        throw new Error(`v1 edge rule ${group} must be an array`);
-    }
-    return value.map((item, index) => {
-        const record = requiredRecord(item, `v1 edge rule ${group}[${index}]`);
-        assertExactKeys(record, ['field', 'operator'], ['value'], `v1 edge rule ${group}[${index}]`);
-        return {
-            field: requiredString(record.field, 'v1 edge rule field'),
-            operator: requiredString(record.operator, 'v1 edge rule operator'),
-            ...(Object.prototype.hasOwnProperty.call(record, 'value')
-                ? {
-                    value: requiredRuntimeRuleScalar(record.value, 'v1 edge rule value'),
-                }
-                : {}),
-        };
-    });
-}
-function validateExperiment(value) {
-    const record = requiredRecord(value, 'v1 edge experiment');
-    assertExactKeys(record, [
-        'id',
-        'status',
-        'kind',
-        'priority',
-        'allocationVersion',
-        'salt',
-        'arms',
-    ], [], 'v1 edge experiment');
-    if (!Array.isArray(record.arms)) {
-        throw new Error('v1 edge experiment arms must be an array');
-    }
-    const armIDs = new Set();
-    const arms = record.arms.map((value, index) => {
-        const arm = requiredRecord(value, `v1 edge experiment arm ${index}`);
-        assertExactKeys(arm, ['id', 'role', 'allocationBasisPoints'], ['variantKey'], `v1 edge experiment arm ${index}`);
-        const id = requiredString(arm.id, 'v1 edge experiment arm ID');
-        if (armIDs.has(id)) {
-            throw new Error(`duplicate v1 edge experiment arm ID ${JSON.stringify(id)}`);
-        }
-        armIDs.add(id);
-        const role = requiredString(arm.role, 'v1 edge experiment arm role');
-        return {
-            id,
-            role,
-            allocationBasisPoints: requiredBoundedInteger(arm.allocationBasisPoints, 0, 10_000, 'v1 edge experiment arm allocation'),
-            variantKey: Object.prototype.hasOwnProperty.call(arm, 'variantKey')
-                ? requiredString(arm.variantKey, 'v1 edge experiment arm variant key')
-                : '',
-        };
-    });
-    return {
-        id: requiredString(record.id, 'v1 edge experiment ID'),
-        status: requiredString(record.status, 'v1 edge experiment status'),
-        kind: requiredString(record.kind, 'v1 edge experiment kind'),
-        priority: requiredSafeInteger(record.priority, 'v1 edge experiment priority'),
-        allocationVersion: optionalString(record.allocationVersion, 'v1 edge experiment allocation version'),
-        salt: optionalString(record.salt, 'v1 edge experiment assignment salt'),
-        arms,
-    };
-}
-function validateCollectSDK(value) {
-    const record = requiredRecord(value, 'v1 edge collect SDK');
-    assertExactKeys(record, ['hash', 'path'], [], 'v1 edge collect SDK');
-    const hash = requiredSHA256(record.hash, 'v1 edge collect SDK hash');
-    const path = requiredString(record.path, 'v1 edge collect SDK path');
-    const expectedPath = `_aci/aci.${hash}.js`;
-    if (path !== expectedPath) {
-        throw new Error(`v1 edge collect SDK path ${JSON.stringify(path)} must equal `
-            + `${JSON.stringify(expectedPath)}`);
-    }
-    return { hash, path };
-}
-function canonicalRuntimeProjectionJSON(value) {
-    const record = requiredRecord(value, 'v1 edge runtime projection');
-    return encodeCanonicalJSONNode(canonicalObject([
-        ['manifestVersion', canonicalUnknownNode(record.manifestVersion)],
-        ['releaseId', canonicalUnknownNode(record.releaseId)],
-        ['siteId', canonicalUnknownNode(record.siteId)],
-        [
-            'routes',
-            canonicalSortedMap(requiredRecord(record.routes, 'v1 edge runtime routes'), canonicalRouteNode),
-        ],
-        ...optionalCanonicalEntry(record, 'experiments', (experiments) => (canonicalSortedMap(requiredRecord(experiments, 'v1 edge runtime experiments'), canonicalExperimentNode))),
-        ...optionalCanonicalEntry(record, 'collectSdk', canonicalCollectSDKNode),
-    ]));
-}
-function canonicalRouteNode(value) {
-    const record = requiredRecord(value, 'v1 edge route');
-    return canonicalObject([
-        ['pattern', canonicalUnknownNode(record.pattern)],
-        ['priority', canonicalUnknownNode(record.priority)],
-        ['dispatch', canonicalDispatchNode(record.dispatch)],
-        ...optionalCanonicalEntry(record, 'variants', (variants) => (canonicalSortedMap(requiredRecord(variants, 'v1 edge route variants'), canonicalVariantNode))),
-    ]);
-}
-function canonicalVariantNode(value) {
-    const record = requiredRecord(value, 'v1 edge variant');
-    return canonicalObject([
-        ['variantKey', canonicalUnknownNode(record.variantKey)],
-        ...optionalCanonicalEntry(record, 'variantValues', (values) => (canonicalSortedMap(requiredRecord(values, 'v1 edge variant values'), canonicalUnknownNode))),
-        ['priority', canonicalUnknownNode(record.priority)],
-        ...optionalCanonicalEntry(record, 'rule', canonicalRuleNode),
-        ['dispatch', canonicalDispatchNode(record.dispatch)],
-    ]);
-}
-function canonicalDispatchNode(value) {
-    const record = requiredRecord(value, 'v1 edge dispatch');
-    return canonicalObject([
-        ['kind', canonicalUnknownNode(record.kind)],
-        ...optionalCanonicalEntry(record, 'artifactPath', canonicalUnknownNode),
-        ...optionalCanonicalEntry(record, 'contentPath', canonicalUnknownNode),
-    ]);
-}
-function canonicalRuleNode(value) {
-    const record = requiredRecord(value, 'v1 edge rule');
-    return canonicalObject([
-        ...optionalCanonicalEntry(record, 'all', canonicalConditionArrayNode),
-        ...optionalCanonicalEntry(record, 'any', canonicalConditionArrayNode),
-    ]);
-}
-function canonicalConditionArrayNode(value) {
-    if (!Array.isArray(value)) {
-        throw new Error('v1 edge rule conditions must be an array');
-    }
-    return value.map((condition) => {
-        const record = requiredRecord(condition, 'v1 edge rule condition');
-        return canonicalObject([
-            ['field', canonicalUnknownNode(record.field)],
-            ['operator', canonicalUnknownNode(record.operator)],
-            ...optionalCanonicalEntry(record, 'value', canonicalUnknownNode),
-        ]);
-    });
-}
-function canonicalExperimentNode(value) {
-    const record = requiredRecord(value, 'v1 edge experiment');
-    if (!Array.isArray(record.arms)) {
-        throw new Error('v1 edge experiment arms must be an array');
-    }
-    return canonicalObject([
-        ['id', canonicalUnknownNode(record.id)],
-        ['status', canonicalUnknownNode(record.status)],
-        ['kind', canonicalUnknownNode(record.kind)],
-        ['priority', canonicalUnknownNode(record.priority)],
-        ['allocationVersion', canonicalUnknownNode(record.allocationVersion)],
-        ['salt', canonicalUnknownNode(record.salt)],
-        [
-            'arms',
-            record.arms.map((armValue) => {
-                const arm = requiredRecord(armValue, 'v1 edge experiment arm');
-                return canonicalObject([
-                    ['id', canonicalUnknownNode(arm.id)],
-                    ['role', canonicalUnknownNode(arm.role)],
-                    [
-                        'allocationBasisPoints',
-                        canonicalUnknownNode(arm.allocationBasisPoints),
-                    ],
-                    ...optionalCanonicalEntry(arm, 'variantKey', canonicalUnknownNode),
-                ]);
-            }),
-        ],
-    ]);
-}
-function canonicalCollectSDKNode(value) {
-    const record = requiredRecord(value, 'v1 edge collect SDK');
-    return canonicalObject([
-        ['hash', canonicalUnknownNode(record.hash)],
-        ['path', canonicalUnknownNode(record.path)],
-    ]);
-}
-function optionalCanonicalEntry(record, key, encode) {
-    return Object.prototype.hasOwnProperty.call(record, key)
-        ? [[key, encode(record[key])]]
-        : [];
-}
 function canonicalSortedMap(record, encode) {
     const entries = Object.entries(record)
         .sort(([left], [right]) => Buffer.compare(Buffer.from(left, 'utf8'), Buffer.from(right, 'utf8')))
@@ -630,26 +172,12 @@ function requiredRecord(value, label) {
     }
     return value;
 }
-function defineOwnEnumerable(record, key, value) {
-    Object.defineProperty(record, key, {
-        value,
-        enumerable: true,
-        configurable: true,
-        writable: true,
-    });
-}
 function requiredString(value, label) {
     if (typeof value !== 'string' || value.length === 0) {
         throw new Error(`${label} must be a non-empty string`);
     }
     return value;
 }
-function optionalString(value, label) {
-    if (typeof value !== 'string') {
-        throw new Error(`${label} must be a string`);
-    }
-    return value;
-}
 function requiredIdentity(value, label) {
     const result = requiredString(value, label);
     if (result === '.'
@@ -660,34 +188,6 @@ function requiredIdentity(value, label) {
     }
     return result;
 }
-function requiredSHA256(value, label) {
-    const digest = requiredString(value, label);
-    if (!SHA256_HEX.test(digest)) {
-        throw new Error(`${label} must be lowercase SHA-256`);
-    }
-    return digest;
-}
-function requiredRuntimeRuleScalar(value, label) {
-    if (value === null
-        || typeof value === 'string'
-        || typeof value === 'boolean'
-        || (typeof value === 'number' && Number.isFinite(value))) {
-        return value;
-    }
-    throw new Error(`${label} must be a JSON string, number, boolean, or null`);
-}
-function requiredSafeInteger(value, label) {
-    if (typeof value !== 'number' || !Number.isSafeInteger(value)) {
-        throw new Error(`${label} must be a safe integer`);
-    }
-    return value;
-}
-function requiredPositiveSafeInteger(value, label) {
-    const result = requiredSafeInteger(value, label);
-    if (result <= 0)
-        throw new Error(`${label} must be positive`);
-    return result;
-}
 function requiredPositiveDecimalBigInt(value, label) {
     if (typeof value !== 'string' || !POSITIVE_DECIMAL.test(value)) {
         throw new Error(`${label} must be a canonical positive decimal string`);
@@ -698,39 +198,9 @@ function requiredPositiveDecimalBigInt(value, label) {
     }
     return result;
 }
-function requiredBoundedInteger(value, minimum, maximum, label) {
-    const result = requiredSafeInteger(value, label);
-    if (result < minimum || result > maximum) {
-        throw new Error(`${label} must be between ${minimum} and ${maximum}`);
-    }
-    return result;
-}
-function sha256(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
 function edgeKeySegment(value) {
     return value.replace(/[^A-Za-z0-9_-]/gu, '_');
 }
-function hex32(value) {
-    return value.toString(16).padStart(8, '0');
-}
-const CRC32_TABLE = new Uint32Array(256);
-for (let index = 0; index < CRC32_TABLE.length; index += 1) {
-    let value = index;
-    for (let bit = 0; bit < 8; bit += 1) {
-        value = (value & 1) !== 0
-            ? (value >>> 1) ^ 0xedb88320
-            : value >>> 1;
-    }
-    CRC32_TABLE[index] = value >>> 0;
-}
-function crc32(value) {
-    let result = 0xffffffff;
-    for (const byte of value) {
-        result = CRC32_TABLE[(result ^ byte) & 0xff] ^ (result >>> 8);
-    }
-    return (result ^ 0xffffffff) >>> 0;
-}
 function assertCanonicalJSONSyntax(value, label) {
     let index = 0;
     function parseValue(depth) {

package/dist/preview/core.d.ts

@@ -37,6 +37,7 @@ export interface PreviewCookie {
 export declare const PREVIEW_TOKEN_COOKIE = "aci_preview";
 export declare const PREVIEW_RELEASE_COOKIE = "aci_preview_release";
 export declare function validatePreviewToken(token: string, signKey: string): Promise<PreviewClaims | null>;
+export declare function parseCookies(header: string): Map<string, string>;
 export declare function extractPreviewToken(source: PreviewTokenSource): string | undefined;
 export declare function previewSignKey(): string | undefined;
 export declare function resolvePreviewContext(options: PreviewResolveOptions): Promise<PreviewContext>;

package/dist/preview/core.js

@@ -18,6 +18,33 @@ export async function validatePreviewToken(token, signKey) {
         return null;
     }
 }
+// parseCookies is the SDK-side raw Cookie-header parser for callers that only
+// have the header string (the Astro integration; Next hands us its own parsed
+// cookies). It is deliberately not the canonical edge parser
+// (internal/domain/edge/identity.ts parseCookieHeader): SDK source cannot
+// import internal/domain/edge — assemble-dist re-roots the emitted tree and
+// the relative specifier depth changes — and framework cookie writers
+// URI-encode values, so this one decodes them (falling back to the raw value
+// on a malformed escape rather than throwing mid-request).
+export function parseCookies(header) {
+    const cookies = new Map();
+    for (const part of header.split(';')) {
+        const separator = part.indexOf('=');
+        if (separator < 0)
+            continue;
+        const name = part.slice(0, separator).trim();
+        if (!name)
+            continue;
+        const value = part.slice(separator + 1).trim();
+        try {
+            cookies.set(name, decodeURIComponent(value));
+        }
+        catch {
+            cookies.set(name, value);
+        }
+    }
+    return cookies;
+}
 export function extractPreviewToken(source) {
     const query = source.query?.get('preview_token');
     if (query)

package/dist/providers/s3.js

@@ -78,12 +78,13 @@ export class S3ContentProvider {
     }
     async getLayout(name) {
         const manifest = await this.manifest();
-        const layouts = manifest.layouts;
-        if (!layouts || !layouts[name]) {
+        const entry = manifest.layouts?.[name];
+        if (!entry) {
             throw new LayoutNotFoundError(name);
         }
+        const ref = entry.payloadRef;
         try {
-            return await this.getJSON(`layouts/${name}.json`);
+            return await this.getJSON(ref);
         }
         catch (error) {
             throw new LayoutNotFoundError(name, error);

package/dist/react/VideoPlayer.d.ts

@@ -25,7 +25,6 @@ export declare function VideoPlayer({ video, ...attrs }: VideoPlayerProps): impo
     } | undefined | undefined;
     children?: import("react").ReactNode;
     className?: string | undefined | undefined;
-    lang?: string | undefined | undefined;
     crossOrigin?: "" | "anonymous" | "use-credentials" | undefined;
     defaultChecked?: boolean | undefined | undefined;
     defaultValue?: string | number | readonly string[] | undefined;
@@ -38,6 +37,7 @@ export declare function VideoPlayer({ video, ...attrs }: VideoPlayerProps): impo
     contextMenu?: string | undefined | undefined;
     draggable?: (boolean | "true" | "false") | undefined;
     enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | undefined;
+    lang?: string | undefined | undefined;
     nonce?: string | undefined | undefined;
     spellCheck?: (boolean | "true" | "false") | undefined;
     tabIndex?: number | undefined | undefined;