@gradial/aci 0.1.45 → 0.1.47

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

@@ -0,0 +1,880 @@
+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;
+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)}`;
+}
+export function decodeActiveReleaseV1(value) {
+    const pointer = parseCanonicalJSONStringRecord(value, 'v1 active release pointer');
+    const orderedKeys = ['releaseId', 'sequence'];
+    assertExactKeys(pointer, orderedKeys, [], 'v1 active release pointer');
+    if (Object.keys(pointer).some((key, index) => key !== orderedKeys[index])) {
+        throw new Error('v1 active release pointer fields are not canonical');
+    }
+    return {
+        releaseId: requiredIdentity(pointer.releaseId, 'v1 active release ID'),
+        sequence: requiredPositiveDecimalBigInt(pointer.sequence, 'v1 active release sequence'),
+    };
+}
+export function decodeDeploymentCompatibilityV1(value) {
+    const compatibility = parseCanonicalJSONStringRecord(value, 'v1 deployment compatibility');
+    const orderedKeys = [
+        'minReleaseId',
+        'minSequence',
+        'maxReleaseId',
+        'maxSequence',
+    ];
+    assertExactKeys(compatibility, [], orderedKeys, 'v1 deployment compatibility');
+    const actualKeys = Object.keys(compatibility);
+    const expectedKeys = orderedKeys.filter((key) => (Object.prototype.hasOwnProperty.call(compatibility, key)));
+    if (actualKeys.some((key, index) => key !== expectedKeys[index])) {
+        throw new Error('v1 deployment compatibility fields are not canonical');
+    }
+    const hasMinRelease = Object.prototype.hasOwnProperty.call(compatibility, 'minReleaseId');
+    const hasMinSequence = Object.prototype.hasOwnProperty.call(compatibility, 'minSequence');
+    const hasMaxRelease = Object.prototype.hasOwnProperty.call(compatibility, 'maxReleaseId');
+    const hasMaxSequence = Object.prototype.hasOwnProperty.call(compatibility, 'maxSequence');
+    if (hasMinRelease !== hasMinSequence || hasMaxRelease !== hasMaxSequence) {
+        throw new Error('v1 deployment compatibility release IDs and sequences must be paired');
+    }
+    return {
+        ...(hasMinRelease
+            ? {
+                minReleaseId: requiredIdentity(compatibility.minReleaseId, 'v1 deployment compatibility minimum release ID'),
+                minSequence: requiredPositiveDecimalBigInt(compatibility.minSequence, 'v1 deployment compatibility minimum sequence'),
+            }
+            : {}),
+        ...(hasMaxRelease
+            ? {
+                maxReleaseId: requiredIdentity(compatibility.maxReleaseId, 'v1 deployment compatibility maximum release ID'),
+                maxSequence: requiredPositiveDecimalBigInt(compatibility.maxSequence, 'v1 deployment compatibility maximum sequence'),
+            }
+            : {}),
+    };
+}
+export function clampDeploymentCompatibleReleaseV1(active, compatibility) {
+    if (compatibility.minSequence !== undefined
+        && active.sequence < compatibility.minSequence
+        && compatibility.minReleaseId) {
+        return compatibility.minReleaseId;
+    }
+    if (compatibility.maxSequence !== undefined
+        && active.sequence > compatibility.maxSequence
+        && compatibility.maxReleaseId) {
+        return compatibility.maxReleaseId;
+    }
+    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`);
+    }
+    if (Buffer.byteLength(value, 'utf8') > MAX_EDGE_CONFIG_VALUE_BYTES) {
+        throw new Error(`${label} exceeds the Edge Config value bound`);
+    }
+    assertCanonicalJSONSyntax(value, label);
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (error) {
+        throw new Error(`${label} is malformed JSON`, { cause: error });
+    }
+    const record = requiredRecord(parsed, label);
+    if (canonicalRecordJSONInInputOrder(record) !== value) {
+        throw new Error(`${label} is not canonical JSON`);
+    }
+    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')))
+        .map(([key, item]) => [key, encode(item)]);
+    return canonicalObject(entries);
+}
+function canonicalUnknownNode(value) {
+    if (value === null
+        || typeof value === 'boolean'
+        || typeof value === 'number'
+        || typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(canonicalUnknownNode);
+    }
+    if (value && typeof value === 'object') {
+        return canonicalSortedMap(value, canonicalUnknownNode);
+    }
+    throw new Error('v1 edge runtime payload contains an unsupported JSON value');
+}
+function canonicalObject(entries) {
+    return { entries };
+}
+function canonicalRecordJSONInInputOrder(record) {
+    const entries = Object.entries(record).map(([key, item]) => [
+        key,
+        canonicalUnknownNode(item),
+    ]);
+    return encodeCanonicalJSONNode(canonicalObject(entries));
+}
+function encodeCanonicalJSONNode(value) {
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string')
+        return encodeGoJSONString(value);
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(encodeCanonicalJSONNode).join(',')}]`;
+    }
+    return `{${value.entries.map(([key, item]) => (`${encodeGoJSONString(key)}:${encodeCanonicalJSONNode(item)}`)).join(',')}}`;
+}
+function encodeGoJSONString(value) {
+    const normalized = Array.from(value, (character) => {
+        const code = character.charCodeAt(0);
+        return character.length === 1 && code >= 0xd800 && code <= 0xdfff
+            ? '\ufffd'
+            : character;
+    }).join('');
+    return JSON.stringify(normalized).replace(/[<>&\u2028\u2029]/gu, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, '0')}`);
+}
+function assertExactKeys(record, required, optional, label) {
+    const allowed = new Set([...required, ...optional]);
+    for (const key of Object.keys(record)) {
+        if (!allowed.has(key)) {
+            throw new Error(`${label} contains unsupported field ${JSON.stringify(key)}`);
+        }
+    }
+    for (const key of required) {
+        if (!Object.prototype.hasOwnProperty.call(record, key)) {
+            throw new Error(`${label} is missing field ${JSON.stringify(key)}`);
+        }
+    }
+}
+function requiredRecord(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label} must be an object`);
+    }
+    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 === '.'
+        || result === '..'
+        || result.includes('/')
+        || result.includes('\\')) {
+        throw new Error(`${label} must be one path segment`);
+    }
+    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`);
+    }
+    const result = BigInt(value);
+    if (result > MAX_INT64) {
+        throw new Error(`${label} exceeds the signed 64-bit sequence bound`);
+    }
+    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) {
+        if (depth > MAX_JSON_DEPTH) {
+            throw new Error(`${label} exceeds the JSON nesting bound`);
+        }
+        const token = value[index];
+        if (token === '{') {
+            if (depth >= MAX_JSON_DEPTH) {
+                throw new Error(`${label} exceeds the JSON nesting bound`);
+            }
+            parseObject(depth + 1);
+            return;
+        }
+        if (token === '[') {
+            if (depth >= MAX_JSON_DEPTH) {
+                throw new Error(`${label} exceeds the JSON nesting bound`);
+            }
+            parseArray(depth + 1);
+            return;
+        }
+        if (token === '"') {
+            parseString();
+            return;
+        }
+        if (token === 't') {
+            parseLiteral('true');
+            return;
+        }
+        if (token === 'f') {
+            parseLiteral('false');
+            return;
+        }
+        if (token === 'n') {
+            parseLiteral('null');
+            return;
+        }
+        const match = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/
+            .exec(value.slice(index));
+        if (!match)
+            throw new Error(`${label} contains invalid JSON at byte ${index}`);
+        index += match[0].length;
+    }
+    function parseObject(depth) {
+        index += 1;
+        const keys = new Set();
+        if (value[index] === '}') {
+            index += 1;
+            return;
+        }
+        for (;;) {
+            if (value[index] !== '"') {
+                throw new Error(`${label} contains invalid object key at byte ${index}`);
+            }
+            const key = parseString();
+            if (keys.has(key)) {
+                throw new Error(`${label} contains duplicate object key ${JSON.stringify(key)}`);
+            }
+            keys.add(key);
+            if (value[index] !== ':') {
+                throw new Error(`${label} contains invalid object separator at byte ${index}`);
+            }
+            index += 1;
+            parseValue(depth);
+            if (value[index] === '}') {
+                index += 1;
+                return;
+            }
+            if (value[index] !== ',') {
+                throw new Error(`${label} contains invalid object delimiter at byte ${index}`);
+            }
+            index += 1;
+        }
+    }
+    function parseArray(depth) {
+        index += 1;
+        if (value[index] === ']') {
+            index += 1;
+            return;
+        }
+        for (;;) {
+            parseValue(depth);
+            if (value[index] === ']') {
+                index += 1;
+                return;
+            }
+            if (value[index] !== ',') {
+                throw new Error(`${label} contains invalid array delimiter at byte ${index}`);
+            }
+            index += 1;
+        }
+    }
+    function parseString() {
+        const start = index;
+        index += 1;
+        while (index < value.length) {
+            const code = value.charCodeAt(index);
+            if (code === 0x22) {
+                index += 1;
+                try {
+                    return JSON.parse(value.slice(start, index));
+                }
+                catch (error) {
+                    throw new Error(`${label} contains an invalid JSON string`, {
+                        cause: error,
+                    });
+                }
+            }
+            if (code < 0x20) {
+                throw new Error(`${label} contains an unescaped control character`);
+            }
+            if (code === 0x5c) {
+                index += 1;
+                const escaped = value[index];
+                if (escaped === 'u') {
+                    const digits = value.slice(index + 1, index + 5);
+                    if (!/^[0-9a-fA-F]{4}$/.test(digits)) {
+                        throw new Error(`${label} contains an invalid Unicode escape`);
+                    }
+                    index += 5;
+                    continue;
+                }
+                if (!escaped || !'"\\/bfnrt'.includes(escaped)) {
+                    throw new Error(`${label} contains an invalid string escape`);
+                }
+            }
+            index += 1;
+        }
+        throw new Error(`${label} contains an unterminated JSON string`);
+    }
+    function parseLiteral(literal) {
+        if (!value.startsWith(literal, index)) {
+            throw new Error(`${label} contains invalid JSON at byte ${index}`);
+        }
+        index += literal.length;
+    }
+    if (value.length === 0)
+        throw new Error(`${label} is empty`);
+    parseValue(0);
+    if (index !== value.length) {
+        const remaining = value.slice(index);
+        if (/^\s/u.test(remaining)) {
+            throw new Error(`${label} contains noncanonical whitespace`);
+        }
+        throw new Error(`${label} contains trailing JSON at byte ${index}`);
+    }
+}