@gradial/aci 0.1.52-rc.41 → 0.1.52-rc.43

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.1.52
+
+### Changed
+
+- Prerelease versions are no longer committed. Canary builds
+  (`@gradial/aci@canary`) publish automatically from every SDK change on
+  `main`; release candidates (`@gradial/aci@rc`) and stable releases publish
+  on demand. All are prereleases or releases of the next stable version.
+
+### Removed
+
+- `@gradial/aci/next/server` no longer reads Vercel Edge Config.
+  `resolveReleaseId()` resolves an explicit release, then the verified routed
+  release, then `ACI_RELEASE_ID`, and otherwise throws; it never falls back to
+  an Edge Config active-release pointer. `FetchConfig` loses `edgeConfig`,
+  `deploymentId`, and `siteId`, which only that pointer read used. The
+  `EDGE_CONFIG` and `VERCEL_DEPLOYMENT_ID` environment variables are ignored.
+
 ## 0.1.52-rc.41
 
 ### Changed

package/README.md

@@ -1,6 +1,6 @@
 # Agentic Content Infrastructure SDK
 
-`@gradial/aci` `0.1.52-rc.41` is a pre-1.0 public-surface reset for the ACI
+`@gradial/aci` `0.1.52-rc.43` is a pre-1.0 public-surface reset for the ACI
 client SDK. Breaking changes from the old `0.1.x` accidental surface are
 intentional: the root import is framework-neutral, framework runtime behavior is
 behind explicit subpaths, and the first required customer path is React/Next.
@@ -8,7 +8,7 @@ behind explicit subpaths, and the first required customer path is React/Next.
 ## Install
 
 ```bash
-npm install @gradial/aci@0.1.52-rc.41 zod@^4
+npm install @gradial/aci@0.1.52-rc.43 zod@^4
 ```
 
 ## Root Import
@@ -137,13 +137,13 @@ host bundles select and serve immutable release artifacts.
 The first RC scaffold path is Next:
 
 ```bash
-npx @gradial/aci@0.1.52-rc.41 init my-site --template next-starter
+npx @gradial/aci@0.1.52-rc.43 init my-site --template next-starter
 ```
 
 List available templates:
 
 ```bash
-npx @gradial/aci@0.1.52-rc.41 init --list
+npx @gradial/aci@0.1.52-rc.43 init --list
 ```
 
 ## Personalization: The One-Tag Install

package/dist/next/server.d.ts

@@ -3,7 +3,6 @@ import { type ReleaseObjectReader } from '../providers/object.js';
 import type { RenderInput } from '../content/types.js';
 export { FragmentNotFoundError, PageNotFoundError, LayoutNotFoundError };
 export interface FetchConfig {
-    siteId?: string;
     bucket?: string;
     keyPrefix?: string;
     region?: string;
@@ -13,8 +12,6 @@ export interface FetchConfig {
     roleArn?: string;
     endpoint?: string;
     releaseId?: string;
-    edgeConfig?: string;
-    deploymentId?: string;
 }
 export interface ServerRenderInput<TPage, TSite extends SiteConfig = SiteConfig> {
     route: string;
@@ -60,6 +57,7 @@ export declare function getDamAssetResponse(assetPath: string, config?: FetchCon
  * router dispatched this request to (release-context.ts — the same release,
  * for code such as the not-found seat that receives no route params), else a
  * process pin. A routed release outranks the pin because the catch-all of the
- * same request renders the routed release regardless of the pin.
+ * same request renders the routed release regardless of the pin. There is no
+ * further source: without one of the three the read fails.
  */
 export declare function resolveReleaseId(config?: FetchConfig): Promise<string>;

package/dist/next/server.js

@@ -7,9 +7,7 @@ import { S3ContentProvider } from '../providers/s3.js';
 import { VercelReleaseObjectReader } from '../providers/vercel-object-reader.js';
 import { GRADIAL_RENDER_INPUT_HEADER, getPendingRenderInput } from '../runtime/page.js';
 import { attachRenderProofReceipt, selectVerifiedPage, } from '../internal/render-proof.js';
-import { getUncachedEdgeConfigValue } from './edge-config.js';
 import { routedRelease } from './release-context.js';
-import { activeReleaseV1Key, clampDeploymentCompatibleReleaseV1, decodeActiveReleaseV1, decodeDeploymentCompatibilityV1, deploymentCompatibilityKey, } from './vercel-edge-projection-v1.js';
 export { FragmentNotFoundError, PageNotFoundError, LayoutNotFoundError };
 const releaseObjectReaderSymbol = Symbol.for('@gradial/aci.release-object-reader');
 const objectProviders = new WeakMap();
@@ -299,7 +297,8 @@ async function safeResponseText(res) {
  * router dispatched this request to (release-context.ts — the same release,
  * for code such as the not-found seat that receives no route params), else a
  * process pin. A routed release outranks the pin because the catch-all of the
- * same request renders the routed release regardless of the pin.
+ * same request renders the routed release regardless of the pin. There is no
+ * further source: without one of the three the read fails.
  */
 export async function resolveReleaseId(config = {}) {
     if (config.releaseId)
@@ -309,9 +308,6 @@ export async function resolveReleaseId(config = {}) {
         return routed.releaseId;
     if (process.env.ACI_RELEASE_ID)
         return process.env.ACI_RELEASE_ID;
-    const activeReleaseId = await activeReleaseFromEdgeConfig(config);
-    if (activeReleaseId)
-        return activeReleaseId;
     throw new Error('ACI release ID is required. Pass releaseId from the release-scoped route or set ACI_RELEASE_ID.'
         + (routed.rejected ? ` The request carried a release context that was not used: ${routed.rejected}.` : ''));
 }
@@ -400,34 +396,9 @@ function sameS3ProviderConfig(left, right) {
         && left.roleArn === right.roleArn
         && left.endpoint === right.endpoint;
 }
-async function activeReleaseFromEdgeConfig(config) {
-    const edgeConfig = config.edgeConfig || process.env.EDGE_CONFIG || '';
-    const siteId = config.siteId || process.env.ACI_SITE_ID || '';
-    if (!edgeConfig || !siteId)
-        return '';
-    const active = await activeReleasePointer(edgeConfig, siteId);
-    if (active == null)
-        return '';
-    const deploymentId = config.deploymentId || process.env.VERCEL_DEPLOYMENT_ID || '';
-    if (!deploymentId)
-        return active.releaseId;
-    const compatibilityValue = await getEdgeConfigValue(edgeConfig, deploymentCompatibilityKey(siteId, deploymentId));
-    if (compatibilityValue == null)
-        return active.releaseId;
-    return clampDeploymentCompatibleReleaseV1(active, decodeDeploymentCompatibilityV1(compatibilityValue));
-}
-async function getEdgeConfigValue(edgeConfig, key) {
-    return getUncachedEdgeConfigValue(edgeConfig, key);
-}
 function releaseKey(config, releaseId) {
     return joinKey(config.keyPrefix || process.env.ACI_S3_KEY_PREFIX || '', 'releases', releaseId);
 }
-async function activeReleasePointer(edgeConfig, siteId) {
-    const value = await getEdgeConfigValue(edgeConfig, activeReleaseV1Key(siteId));
-    if (value == null)
-        return null;
-    return decodeActiveReleaseV1(value);
-}
 class InjectedReaderProvider {
     releaseId;
     reader;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gradial/aci",
-  "version": "0.1.52-rc.41",
+  "version": "0.1.52-rc.43",
   "repository": {
     "type": "git",
     "url": "https://github.com/gradial/bare-metal-go.git",
@@ -160,11 +160,11 @@
     "zod": "^4.0.0"
   },
   "optionalDependencies": {
-    "@gradial/aci-cli-darwin-arm64": "0.1.52-rc.41",
-    "@gradial/aci-cli-darwin-x64": "0.1.52-rc.41",
-    "@gradial/aci-cli-linux-arm64": "0.1.52-rc.41",
-    "@gradial/aci-cli-linux-x64": "0.1.52-rc.41",
-    "@gradial/aci-cli-win32-arm64": "0.1.52-rc.41",
-    "@gradial/aci-cli-win32-x64": "0.1.52-rc.41"
+    "@gradial/aci-cli-darwin-arm64": "0.1.52-rc.43",
+    "@gradial/aci-cli-darwin-x64": "0.1.52-rc.43",
+    "@gradial/aci-cli-linux-arm64": "0.1.52-rc.43",
+    "@gradial/aci-cli-linux-x64": "0.1.52-rc.43",
+    "@gradial/aci-cli-win32-arm64": "0.1.52-rc.43",
+    "@gradial/aci-cli-win32-x64": "0.1.52-rc.43"
   }
 }

package/dist/next/edge-config.d.ts

@@ -1 +0,0 @@
-export declare function getUncachedEdgeConfigValue(edgeConfig: string, key: string): Promise<unknown>;

package/dist/next/edge-config.js

@@ -1,92 +0,0 @@
-export async function getUncachedEdgeConfigValue(edgeConfig, key) {
-    const connection = parseEdgeConfigConnection(edgeConfig);
-    if (!connection) {
-        throw new Error('Invalid Edge Config connection string');
-    }
-    const headers = new Headers({
-        authorization: `Bearer ${connection.token}`,
-        'x-edge-config-min-updated-at': `${Number.MAX_SAFE_INTEGER}`,
-    });
-    if (process.env.VERCEL_ENV) {
-        headers.set('x-edge-config-vercel-env', process.env.VERCEL_ENV);
-    }
-    const url = `${connection.baseUrl}/item/${encodeURIComponent(key)}?version=${encodeURIComponent(connection.version)}`;
-    const response = await fetch(url, {
-        headers,
-        cache: 'no-store',
-    });
-    if (response.ok) {
-        return response.json();
-    }
-    if (response.status === 404 && response.headers.has('x-edge-config-digest')) {
-        return undefined;
-    }
-    const body = await response.text().catch(() => '');
-    throw new Error(`Edge Config read ${key} returned ${response.status}: ${body.slice(0, 500)}`);
-}
-function parseEdgeConfigConnection(value) {
-    const text = value.trim();
-    if (!text)
-        return null;
-    return parseEdgeConfigQueryConnection(text)
-        || parseVercelEdgeConfigURL(text)
-        || parseExternalEdgeConfigURL(text);
-}
-function parseEdgeConfigQueryConnection(value) {
-    if (!value.startsWith('edge-config:'))
-        return null;
-    const params = new URLSearchParams(value.slice('edge-config:'.length));
-    const id = params.get('id') || '';
-    const token = params.get('token') || '';
-    if (!id || !token)
-        return null;
-    return {
-        baseUrl: `https://edge-config.vercel.com/${id}`,
-        token,
-        version: params.get('version') || '1',
-    };
-}
-function parseVercelEdgeConfigURL(value) {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch {
-        return null;
-    }
-    if (url.protocol !== 'https:' || url.host !== 'edge-config.vercel.com')
-        return null;
-    const id = url.pathname.split('/').filter(Boolean)[0] || '';
-    const token = url.searchParams.get('token') || '';
-    if (!id || !id.startsWith('ecfg') || !token)
-        return null;
-    return {
-        baseUrl: `https://edge-config.vercel.com/${id}`,
-        token,
-        version: url.searchParams.get('version') || '1',
-    };
-}
-function parseExternalEdgeConfigURL(value) {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch {
-        return null;
-    }
-    let id = url.searchParams.get('id') || '';
-    const token = url.searchParams.get('token') || '';
-    const version = url.searchParams.get('version') || '1';
-    if (!id || url.pathname.startsWith('/ecfg_')) {
-        id = url.pathname.split('/').filter(Boolean)[0] || '';
-    }
-    if (!id || !token)
-        return null;
-    url.search = '';
-    const base = url.toString().replace(/\/+$/, '');
-    return {
-        baseUrl: base,
-        token,
-        version,
-    };
-}

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

@@ -1,15 +0,0 @@
-export interface ActiveReleasePointerV1 {
-    releaseId: string;
-    sequence: bigint;
-}
-export interface DeploymentCompatibilityV1 {
-    minReleaseId?: string;
-    minSequence?: bigint;
-    maxReleaseId?: string;
-    maxSequence?: bigint;
-}
-export declare function activeReleaseV1Key(siteId: string): string;
-export declare function deploymentCompatibilityKey(siteId: string, deploymentId: string): string;
-export declare function decodeActiveReleaseV1(value: unknown): ActiveReleasePointerV1;
-export declare function decodeDeploymentCompatibilityV1(value: unknown): DeploymentCompatibilityV1;
-export declare function clampDeploymentCompatibleReleaseV1(active: ActiveReleasePointerV1, compatibility: DeploymentCompatibilityV1): string;

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

@@ -1,350 +0,0 @@
-// 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 MAX_EDGE_CONFIG_VALUE_BYTES = 65_536;
-const MAX_JSON_DEPTH = 64;
-const POSITIVE_DECIMAL = /^[1-9][0-9]*$/;
-const MAX_INT64 = 9223372036854775807n;
-export function activeReleaseV1Key(siteId) {
-    return `${ACTIVE_RELEASE_V1_PREFIX}${edgeKeySegment(siteId)}`;
-}
-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;
-}
-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 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 requiredString(value, label) {
-    if (typeof value !== 'string' || value.length === 0) {
-        throw new Error(`${label} must be a non-empty 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 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 edgeKeySegment(value) {
-    return value.replace(/[^A-Za-z0-9_-]/gu, '_');
-}
-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}`);
-    }
-}