@oxchannels/sdk 1.0.0

package/dist/generated/contracts/api-errors.js

@@ -0,0 +1,296 @@
+// Generated by packages/openapi-client/scripts/generate.mjs from packages/contracts/src/api-errors.ts; do not edit.
+import { assertExactOwnFields, deepFreezeJsonData, denseArrayValues, jsonSchemaToOpenApiFragment, ownDataRecord, ownDataValue, snapshotOwnJsonDataTree, } from './json-data.js';
+export const PARITY_CONTRACT_SET_VERSION = '2.0.0';
+/**
+ * The response header that names who imposed a delayed retry.
+ *
+ * It is a header rather than an envelope field on purpose. Contract-set 2.0.0 error envelopes are
+ * closed schemas, and this repository's compatibility rule treats *any* added output property —
+ * required or optional — as breaking, because the generated clients parse closed-world and would
+ * reject a wider body. A header carries the same machine-readable fact additively, so a client
+ * pinned to 1.13.52 keeps working byte-for-byte while a client that wants the distinction can read
+ * it today. Moving it into the envelope belongs to the next contract major.
+ *
+ * Why the distinction matters at all: before Task 18.2 an OxChannels policy limit and a provider
+ * throttle both arrived as a bare `RATE_LIMITED`, and the backend answered every non-public 429
+ * with a hardcoded sixty seconds. Retrying at an interval we invented, inside a window somebody
+ * else set, is how a connected account gets suspended.
+ *
+ * The operator-facing surfaces publish the same distinction in full: `GET /privacy/limits` returns
+ * our thresholds and the provider's observed limits as two separate lists, and
+ * `GET /privacy/limit-decisions` records every judgement with its authority.
+ */
+export const LIMIT_AUTHORITY_HEADER = 'oxchannels-limit-authority';
+export const LIMIT_AUTHORITY_HEADER_VALUES = Object.freeze(['OXCHANNELS', 'PROVIDER']);
+export const ACTIVE_API_ERROR_CODES = Object.freeze([
+    'INVALID_REQUEST',
+    'AUTHENTICATION_REQUIRED',
+    'FORBIDDEN',
+    'NOT_FOUND',
+    'IDEMPOTENCY_CONFLICT',
+    'RATE_LIMITED',
+    'INTERNAL_SAFE_FAILURE',
+]);
+export const ACTIVE_API_ERROR_CODES_V2 = Object.freeze([
+    ...ACTIVE_API_ERROR_CODES,
+    'CONFLICT',
+]);
+export const COLLABORATION_CONFLICT_CODES = Object.freeze([
+    'DUPLICATE_INVITATION',
+    'LAST_OWNER',
+    'ROLE_CEILING',
+    'SELF_MUTATION_REQUIRES_TRANSFER',
+    'STALE_ACCESS_GENERATION',
+    'STALE_ACCOUNT_GROUP',
+    'STALE_INVITATION',
+    'STALE_MEMBERSHIP',
+]);
+export const RESERVED_API_ERROR_CODES = Object.freeze([
+    'SCHEMA_UNSUPPORTED',
+    'STALE_CAPABILITY',
+    'UNSUPPORTED_ACTION',
+    'CONNECTION_REQUIRED',
+    'PROVIDER_REAUTH_REQUIRED',
+    'PROVIDER_REVIEW_REQUIRED',
+    'PROVIDER_PERMISSION_DENIED',
+    'PROVIDER_REJECTED',
+    'DEPENDENCY_UNAVAILABLE',
+    'UNKNOWN_EFFECT',
+]);
+function entry(code, status, category, defaultHttpStatus, retry, effect) {
+    return { code, status, category, defaultHttpStatus, retry, effect };
+}
+const API_ERROR_TAXONOMY_ENTRIES = [
+    entry('INVALID_REQUEST', 'ACTIVE', 'VALIDATION', 400, 'NONE', 'NOT_APPLIED'),
+    entry('AUTHENTICATION_REQUIRED', 'ACTIVE', 'AUTHENTICATION', 401, 'REFRESH_AUTH', 'NOT_APPLIED'),
+    entry('FORBIDDEN', 'ACTIVE', 'AUTHORIZATION', 403, 'NONE', 'NOT_APPLIED'),
+    entry('NOT_FOUND', 'ACTIVE', 'RESOURCE', 404, 'NONE', 'NOT_APPLIED'),
+    entry('IDEMPOTENCY_CONFLICT', 'ACTIVE', 'CONFLICT', 409, 'NONE', 'NO_EFFECT_CLAIM'),
+    entry('RATE_LIMITED', 'ACTIVE', 'RATE_LIMIT', 429, 'AFTER_DELAY', 'NO_EFFECT_CLAIM'),
+    entry('INTERNAL_SAFE_FAILURE', 'ACTIVE', 'INTERNAL', 500, 'NONE', 'NO_EFFECT_CLAIM'),
+    entry('SCHEMA_UNSUPPORTED', 'RESERVED', 'VALIDATION', 400, 'NONE', 'NOT_APPLIED'),
+    entry('CONFLICT', 'ACTIVE', 'CONFLICT', 409, 'NONE', 'NO_EFFECT_CLAIM'),
+    entry('STALE_CAPABILITY', 'RESERVED', 'CAPABILITY', 409, 'NONE', 'NOT_APPLIED'),
+    entry('UNSUPPORTED_ACTION', 'RESERVED', 'CAPABILITY', 422, 'NONE', 'NOT_APPLIED'),
+    entry('CONNECTION_REQUIRED', 'RESERVED', 'AUTHENTICATION', 409, 'NONE', 'NOT_APPLIED'),
+    entry('PROVIDER_REAUTH_REQUIRED', 'RESERVED', 'AUTHENTICATION', 409, 'REFRESH_AUTH', 'NOT_APPLIED'),
+    entry('PROVIDER_REVIEW_REQUIRED', 'RESERVED', 'PROVIDER', 409, 'NONE', 'NOT_APPLIED'),
+    entry('PROVIDER_PERMISSION_DENIED', 'RESERVED', 'PROVIDER', 403, 'NONE', 'NOT_APPLIED'),
+    entry('PROVIDER_REJECTED', 'RESERVED', 'PROVIDER', 422, 'NONE', 'NOT_APPLIED'),
+    entry('DEPENDENCY_UNAVAILABLE', 'RESERVED', 'DEPENDENCY', 503, 'AFTER_DELAY', 'NO_EFFECT_CLAIM'),
+    entry('UNKNOWN_EFFECT', 'RESERVED', 'PROVIDER', 409, 'MANUAL_REVIEW', 'UNKNOWN'),
+];
+export const API_ERROR_TAXONOMY = deepFreezeJsonData(Object.fromEntries(API_ERROR_TAXONOMY_ENTRIES.map((definition) => [definition.code, definition])));
+function exactObjectSchema(properties, required) {
+    return { type: 'object', additionalProperties: false, properties, required };
+}
+function errorViolationSchema() {
+    return exactObjectSchema({ path: { type: 'string' }, code: { type: 'string' } }, [
+        'path',
+        'code',
+    ]);
+}
+function taxonomyVariant(definition) {
+    return exactObjectSchema({
+        code: { const: definition.code },
+        status: { const: definition.status },
+        category: { const: definition.category },
+        defaultHttpStatus: { const: definition.defaultHttpStatus },
+        retry: { const: definition.retry },
+        effect: { const: definition.effect },
+    }, ['code', 'status', 'category', 'defaultHttpStatus', 'retry', 'effect']);
+}
+const ERROR_ENVELOPE_V1_PROPERTIES = {
+    version: { type: 'string', enum: ['v1'] },
+    code: { type: 'string', enum: ACTIVE_API_ERROR_CODES },
+    message: { type: 'string' },
+    traceId: { type: 'string' },
+    retryable: { type: 'boolean' },
+};
+export const API_ERROR_TAXONOMY_ENTRY_JSON_SCHEMA = deepFreezeJsonData({
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://schemas.oxchannels.dev/contracts/v2/api-error-taxonomy-entry.schema.json',
+    title: 'OxChannels API error taxonomy entry',
+    oneOf: API_ERROR_TAXONOMY_ENTRIES.map(taxonomyVariant),
+});
+export const ERROR_ENVELOPE_V1_JSON_SCHEMA = deepFreezeJsonData({
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://schemas.oxchannels.dev/contracts/v2/error-envelope-v1.schema.json',
+    title: 'OxChannels ErrorEnvelope v1',
+    ...exactObjectSchema(ERROR_ENVELOPE_V1_PROPERTIES, [
+        'version',
+        'code',
+        'message',
+        'traceId',
+        'retryable',
+    ]),
+});
+function errorEnvelopeV2Variant(code) {
+    const definition = API_ERROR_TAXONOMY[code];
+    const expectedEffectEvidence = effectEvidence(definition.effect);
+    const retryProperties = definition.retry === 'AFTER_DELAY'
+        ? { retryAfterSeconds: { type: 'integer', minimum: 0, maximum: 86_400 } }
+        : {};
+    return exactObjectSchema({
+        schemaVersion: { const: PARITY_CONTRACT_SET_VERSION },
+        code: { const: code },
+        category: { const: definition.category },
+        message: { type: 'string' },
+        traceId: { type: 'string' },
+        correlationId: { type: 'string' },
+        retryable: { const: defaultRetryable(definition.retry) },
+        effectEvidence: { const: expectedEffectEvidence },
+        ...retryProperties,
+        violations: {
+            type: 'array',
+            maxItems: 100,
+            items: errorViolationSchema(),
+        },
+    }, [
+        'schemaVersion',
+        'code',
+        'category',
+        'message',
+        'traceId',
+        'correlationId',
+        'retryable',
+        'effectEvidence',
+        ...(definition.retry === 'AFTER_DELAY' ? ['retryAfterSeconds'] : []),
+    ]);
+}
+export const ERROR_ENVELOPE_V2_JSON_SCHEMA = deepFreezeJsonData({
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://schemas.oxchannels.dev/contracts/v2/error-envelope-v2.schema.json',
+    title: 'OxChannels ErrorEnvelope v2',
+    discriminator: { propertyName: 'code' },
+    oneOf: ACTIVE_API_ERROR_CODES_V2.map(errorEnvelopeV2Variant),
+});
+export const API_ERROR_TAXONOMY_ENTRY_OPENAPI_SCHEMA = jsonSchemaToOpenApiFragment(API_ERROR_TAXONOMY_ENTRY_JSON_SCHEMA);
+export const ERROR_ENVELOPE_V1_OPENAPI_SCHEMA = jsonSchemaToOpenApiFragment(ERROR_ENVELOPE_V1_JSON_SCHEMA);
+export const ERROR_ENVELOPE_V2_OPENAPI_SCHEMA = jsonSchemaToOpenApiFragment(ERROR_ENVELOPE_V2_JSON_SCHEMA);
+export const ERROR_ENVELOPE_V2_VARIANT_OPENAPI_SCHEMAS = deepFreezeJsonData(Object.fromEntries(ACTIVE_API_ERROR_CODES_V2.map((code) => [
+    code,
+    jsonSchemaToOpenApiFragment(errorEnvelopeV2Variant(code)),
+])));
+function activeV1Code(value) {
+    if (typeof value !== 'string' || !ACTIVE_API_ERROR_CODES.includes(value)) {
+        throw new TypeError('Error envelope code is not active in contract set 2.0.0');
+    }
+    return value;
+}
+function activeV2Code(value) {
+    if (typeof value !== 'string' ||
+        !ACTIVE_API_ERROR_CODES_V2.includes(value)) {
+        throw new TypeError('Error envelope code is not active in contract set 2.0.0');
+    }
+    return value;
+}
+function requiredString(value, label) {
+    if (typeof value !== 'string')
+        throw new TypeError(`${label} must be a string`);
+    return value;
+}
+export function isCollaborationConflictCode(value) {
+    return (typeof value === 'string' &&
+        COLLABORATION_CONFLICT_CODES.includes(value));
+}
+function defaultRetryable(retry) {
+    return retry === 'AFTER_DELAY' || retry === 'REFRESH_AUTH' || retry === 'POLL';
+}
+function effectEvidence(effect) {
+    return effect === 'NO_EFFECT_CLAIM' ? null : effect;
+}
+export function parseApiErrorEnvelopeV1(value) {
+    const snapshot = snapshotOwnJsonDataTree(value, 'ErrorEnvelope v1');
+    const envelope = ownDataRecord(snapshot, 'ErrorEnvelope v1');
+    assertExactOwnFields(envelope, ['version', 'code', 'message', 'traceId', 'retryable'], 'ErrorEnvelope v1');
+    if (ownDataValue(envelope, 'version', 'ErrorEnvelope v1') !== 'v1') {
+        throw new TypeError('ErrorEnvelope v1 has an unsupported version');
+    }
+    const retryable = ownDataValue(envelope, 'retryable', 'ErrorEnvelope v1');
+    if (typeof retryable !== 'boolean')
+        throw new TypeError('ErrorEnvelope v1 retryable is invalid');
+    return Object.freeze({
+        version: 'v1',
+        code: activeV1Code(ownDataValue(envelope, 'code', 'ErrorEnvelope v1')),
+        message: requiredString(ownDataValue(envelope, 'message', 'ErrorEnvelope v1'), 'message'),
+        traceId: requiredString(ownDataValue(envelope, 'traceId', 'ErrorEnvelope v1'), 'traceId'),
+        retryable,
+    });
+}
+export function parseApiErrorEnvelopeV2(value) {
+    const snapshot = snapshotOwnJsonDataTree(value, 'ErrorEnvelope v2');
+    const envelope = ownDataRecord(snapshot, 'ErrorEnvelope v2');
+    const required = [
+        'schemaVersion',
+        'code',
+        'category',
+        'message',
+        'traceId',
+        'correlationId',
+        'retryable',
+        'effectEvidence',
+    ];
+    const allowed = [...required, 'retryAfterSeconds', 'violations'];
+    const fields = Object.getOwnPropertyNames(envelope);
+    if (fields.some((field) => !allowed.includes(field)) ||
+        required.some((field) => !fields.includes(field))) {
+        throw new TypeError(`ErrorEnvelope v2 must contain only: ${allowed.join(', ')}`);
+    }
+    if (ownDataValue(envelope, 'schemaVersion', 'ErrorEnvelope v2') !== PARITY_CONTRACT_SET_VERSION) {
+        throw new TypeError('ErrorEnvelope v2 has an unsupported version');
+    }
+    const code = activeV2Code(ownDataValue(envelope, 'code', 'ErrorEnvelope v2'));
+    const definition = API_ERROR_TAXONOMY[code];
+    const retryable = ownDataValue(envelope, 'retryable', 'ErrorEnvelope v2');
+    if (retryable !== defaultRetryable(definition.retry)) {
+        throw new TypeError('ErrorEnvelope v2 retryability differs from the active taxonomy');
+    }
+    if (ownDataValue(envelope, 'category', 'ErrorEnvelope v2') !== definition.category) {
+        throw new TypeError('ErrorEnvelope v2 category differs from the active taxonomy');
+    }
+    if (ownDataValue(envelope, 'effectEvidence', 'ErrorEnvelope v2') !==
+        effectEvidence(definition.effect)) {
+        throw new TypeError('ErrorEnvelope v2 effectEvidence differs from the active taxonomy');
+    }
+    const retryAfterSeconds = Object.hasOwn(envelope, 'retryAfterSeconds')
+        ? ownDataValue(envelope, 'retryAfterSeconds', 'ErrorEnvelope v2')
+        : undefined;
+    if ((definition.retry === 'AFTER_DELAY') !== (retryAfterSeconds !== undefined) ||
+        (retryAfterSeconds !== undefined &&
+            (!Number.isSafeInteger(retryAfterSeconds) ||
+                Number(retryAfterSeconds) < 0 ||
+                Number(retryAfterSeconds) > 86_400 ||
+                definition.retry !== 'AFTER_DELAY'))) {
+        throw new TypeError('ErrorEnvelope v2 retryAfterSeconds is invalid for the active taxonomy');
+    }
+    const violations = Object.hasOwn(envelope, 'violations')
+        ? denseArrayValues(ownDataValue(envelope, 'violations', 'ErrorEnvelope v2'), 'violations')
+        : undefined;
+    if (violations !== undefined && violations.length > 100) {
+        throw new TypeError('ErrorEnvelope v2 has too many violations');
+    }
+    const parsedViolations = violations?.map((candidate, index) => {
+        const violation = ownDataRecord(candidate, `violation ${index}`);
+        assertExactOwnFields(violation, ['path', 'code'], `violation ${index}`);
+        const path = requiredString(ownDataValue(violation, 'path', `violation ${index}`), 'violation.path');
+        const violationCode = requiredString(ownDataValue(violation, 'code', `violation ${index}`), 'violation.code');
+        if (path === 'collaboration' &&
+            (code !== 'CONFLICT' || !isCollaborationConflictCode(violationCode))) {
+            throw new TypeError('ErrorEnvelope v2 collaboration violation is not active');
+        }
+        return { path, code: violationCode };
+    });
+    return deepFreezeJsonData({
+        schemaVersion: PARITY_CONTRACT_SET_VERSION,
+        code,
+        category: definition.category,
+        message: requiredString(ownDataValue(envelope, 'message', 'ErrorEnvelope v2'), 'message'),
+        traceId: requiredString(ownDataValue(envelope, 'traceId', 'ErrorEnvelope v2'), 'traceId'),
+        correlationId: requiredString(ownDataValue(envelope, 'correlationId', 'ErrorEnvelope v2'), 'correlationId'),
+        retryable,
+        effectEvidence: effectEvidence(definition.effect),
+        ...(retryAfterSeconds === undefined ? {} : { retryAfterSeconds: Number(retryAfterSeconds) }),
+        ...(parsedViolations === undefined ? {} : { violations: parsedViolations }),
+    });
+}

package/dist/generated/contracts/json-data.d.ts

@@ -0,0 +1,16 @@
+export declare function ownDataRecord(value: unknown, label: string): Readonly<Record<string, unknown>>;
+export declare function ownDataEntries(value: Readonly<Record<string, unknown>>, label: string): readonly (readonly [string, unknown])[];
+export declare function ownDataValue(value: Readonly<Record<string, unknown>>, key: string, label: string): unknown;
+export declare function denseArrayValues(value: unknown, label: string): readonly unknown[];
+/**
+ * Captures untrusted JSON-shaped input into detached, frozen package-owned data. Every proxy
+ * surface (prototype, own-key inventory and each property descriptor) is observed exactly once;
+ * validation after this boundary never reads the caller-owned object again.
+ */
+export declare function snapshotOwnJsonDataTree(value: unknown, label: string): unknown;
+export declare function assertOwnJsonDataTree(value: unknown, label: string): void;
+export declare function assertExactOwnFields(value: Readonly<Record<string, unknown>>, fields: readonly string[], label: string): void;
+export declare function canonicalJsonDataEqual(left: unknown, right: unknown): boolean;
+export declare function deepFreezeJsonData<T>(value: T): Readonly<T>;
+/** Converts the supported closed JSON Schema fragments to OpenAPI 3.0 Schema Objects. */
+export declare function jsonSchemaToOpenApiFragment(value: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>>;

package/dist/generated/contracts/json-data.js

@@ -0,0 +1,308 @@
+// Generated by packages/openapi-client/scripts/generate.mjs from packages/contracts/src/json-data.ts; do not edit.
+const MAX_JSON_DATA_DEPTH = 64;
+const MAX_JSON_DATA_NODES = 50_000;
+function ownNames(value, label) {
+    try {
+        return Object.getOwnPropertyNames(value);
+    }
+    catch {
+        throw new TypeError(`${label} cannot be inspected as JSON data`);
+    }
+}
+function ownSymbols(value, label) {
+    try {
+        return Object.getOwnPropertySymbols(value);
+    }
+    catch {
+        throw new TypeError(`${label} cannot be inspected as JSON data`);
+    }
+}
+function ownDescriptor(value, key, label) {
+    let descriptor;
+    try {
+        descriptor = Object.getOwnPropertyDescriptor(value, key);
+    }
+    catch {
+        throw new TypeError(`${label}.${key} cannot be inspected as JSON data`);
+    }
+    if (descriptor === undefined ||
+        descriptor.enumerable !== true ||
+        !Object.hasOwn(descriptor, 'value')) {
+        throw new TypeError(`${label}.${key} must be an enumerable data field`);
+    }
+    return descriptor;
+}
+function prototypeOf(value, label) {
+    try {
+        return Object.getPrototypeOf(value);
+    }
+    catch {
+        throw new TypeError(`${label} cannot be inspected as JSON data`);
+    }
+}
+export function ownDataRecord(value, label) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new TypeError(`${label} must be a plain object`);
+    }
+    const prototype = prototypeOf(value, label);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError(`${label} must be a plain object with no inherited fields`);
+    }
+    if (ownSymbols(value, label).length > 0) {
+        throw new TypeError(`${label} contains symbol fields`);
+    }
+    for (const key of ownNames(value, label))
+        ownDescriptor(value, key, label);
+    return value;
+}
+export function ownDataEntries(value, label) {
+    ownDataRecord(value, label);
+    return ownNames(value, label).map((key) => [key, ownDescriptor(value, key, label).value]);
+}
+export function ownDataValue(value, key, label) {
+    const descriptor = ownDescriptor(value, key, label);
+    return descriptor.value;
+}
+export function denseArrayValues(value, label) {
+    if (!Array.isArray(value))
+        throw new TypeError(`${label} must be a dense array`);
+    const prototype = prototypeOf(value, label);
+    if (prototype !== Array.prototype && prototype !== null) {
+        throw new TypeError(`${label} must be a dense array with no inherited fields`);
+    }
+    if (ownSymbols(value, label).length > 0)
+        throw new TypeError(`${label} contains symbol fields`);
+    const names = ownNames(value, label);
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(value, 'length');
+    if (lengthDescriptor === undefined ||
+        !Object.hasOwn(lengthDescriptor, 'value') ||
+        !Number.isSafeInteger(lengthDescriptor.value) ||
+        Number(lengthDescriptor.value) < 0) {
+        throw new TypeError(`${label} has an invalid array length`);
+    }
+    const length = Number(lengthDescriptor.value);
+    const expectedNames = [...Array.from({ length }, (_, index) => String(index)), 'length'];
+    if (names.length !== expectedNames.length ||
+        names.some((name, index) => name !== expectedNames[index])) {
+        throw new TypeError(`${label} must be a dense array without named fields`);
+    }
+    return expectedNames.slice(0, -1).map((key) => ownDescriptor(value, key, label).value);
+}
+/**
+ * Captures untrusted JSON-shaped input into detached, frozen package-owned data. Every proxy
+ * surface (prototype, own-key inventory and each property descriptor) is observed exactly once;
+ * validation after this boundary never reads the caller-owned object again.
+ */
+export function snapshotOwnJsonDataTree(value, label) {
+    const activePath = new Set();
+    let nodes = 0;
+    const snapshot = (candidate, candidateLabel, depth) => {
+        nodes += 1;
+        if (nodes > MAX_JSON_DATA_NODES)
+            throw new TypeError(`${label} exceeds the node budget`);
+        if (depth > MAX_JSON_DATA_DEPTH)
+            throw new TypeError(`${label} exceeds the depth budget`);
+        const kind = typeof candidate;
+        if (candidate === null || kind === 'string' || kind === 'boolean')
+            return candidate;
+        if (kind === 'number') {
+            if (!Number.isFinite(candidate)) {
+                throw new TypeError(`${candidateLabel} must be a finite JSON number`);
+            }
+            return candidate;
+        }
+        if (kind !== 'object')
+            throw new TypeError(`${candidateLabel} is not JSON data`);
+        const object = candidate;
+        if (activePath.has(object))
+            throw new TypeError(`${candidateLabel} contains a cycle`);
+        activePath.add(object);
+        try {
+            let array;
+            let prototype;
+            let keys;
+            try {
+                array = Array.isArray(object);
+                prototype = Reflect.getPrototypeOf(object);
+                keys = Reflect.ownKeys(object);
+            }
+            catch {
+                throw new TypeError(`${candidateLabel} cannot be inspected as JSON data`);
+            }
+            if (keys.length > MAX_JSON_DATA_NODES) {
+                throw new TypeError(`${candidateLabel} exceeds the property budget`);
+            }
+            const descriptors = new Map();
+            for (const key of keys) {
+                let descriptor;
+                try {
+                    descriptor = Reflect.getOwnPropertyDescriptor(object, key);
+                }
+                catch {
+                    throw new TypeError(`${candidateLabel} cannot be inspected as JSON data`);
+                }
+                if (descriptor === undefined) {
+                    throw new TypeError(`${candidateLabel} has an unstable property inventory`);
+                }
+                descriptors.set(key, descriptor);
+            }
+            if (array) {
+                if (prototype !== Array.prototype && prototype !== null) {
+                    throw new TypeError(`${candidateLabel} must be a plain dense array`);
+                }
+                if (keys.some((key) => typeof key !== 'string')) {
+                    throw new TypeError(`${candidateLabel} contains symbol fields`);
+                }
+                const lengthDescriptor = descriptors.get('length');
+                if (lengthDescriptor === undefined ||
+                    !Object.hasOwn(lengthDescriptor, 'value') ||
+                    !Number.isSafeInteger(lengthDescriptor.value) ||
+                    Number(lengthDescriptor.value) < 0 ||
+                    Number(lengthDescriptor.value) > MAX_JSON_DATA_NODES) {
+                    throw new TypeError(`${candidateLabel} has an invalid array length`);
+                }
+                const length = Number(lengthDescriptor.value);
+                if (keys.length !== length + 1) {
+                    throw new TypeError(`${candidateLabel} must be a dense array without named fields`);
+                }
+                const result = new Array(length);
+                for (let index = 0; index < length; index += 1) {
+                    const descriptor = descriptors.get(String(index));
+                    if (descriptor === undefined ||
+                        descriptor.enumerable !== true ||
+                        !Object.hasOwn(descriptor, 'value')) {
+                        throw new TypeError(`${candidateLabel} must be a dense array without accessors`);
+                    }
+                    result[index] = snapshot(descriptor.value, `${candidateLabel}[${index}]`, depth + 1);
+                }
+                return Object.freeze(result);
+            }
+            if (prototype !== Object.prototype && prototype !== null) {
+                throw new TypeError(`${candidateLabel} must be a plain object with no inherited fields`);
+            }
+            if (keys.some((key) => typeof key !== 'string')) {
+                throw new TypeError(`${candidateLabel} contains symbol fields`);
+            }
+            const result = Object.create(null);
+            for (const key of keys) {
+                const descriptor = descriptors.get(key);
+                if (descriptor === undefined ||
+                    descriptor.enumerable !== true ||
+                    !Object.hasOwn(descriptor, 'value')) {
+                    throw new TypeError(`${candidateLabel}.${key} must be an enumerable data field`);
+                }
+                Object.defineProperty(result, key, {
+                    value: snapshot(descriptor.value, `${candidateLabel}.${key}`, depth + 1),
+                    enumerable: true,
+                    configurable: false,
+                    writable: false,
+                });
+            }
+            return Object.freeze(result);
+        }
+        finally {
+            activePath.delete(object);
+        }
+    };
+    return snapshot(value, label, 0);
+}
+export function assertOwnJsonDataTree(value, label) {
+    snapshotOwnJsonDataTree(value, label);
+}
+export function assertExactOwnFields(value, fields, label) {
+    const actual = ownDataEntries(value, label).map(([key]) => key);
+    if (actual.length !== fields.length ||
+        actual.some((field) => !fields.includes(field)) ||
+        fields.some((field) => !actual.includes(field))) {
+        throw new TypeError(`${label} must contain exactly: ${fields.join(', ')}`);
+    }
+}
+export function canonicalJsonDataEqual(left, right) {
+    const work = [[left, right]];
+    while (work.length > 0) {
+        const pair = work.pop();
+        if (pair === undefined)
+            break;
+        const [leftValue, rightValue] = pair;
+        if (Object.is(leftValue, rightValue))
+            continue;
+        const leftIsArray = Array.isArray(leftValue);
+        if (leftValue === null ||
+            rightValue === null ||
+            typeof leftValue !== 'object' ||
+            typeof rightValue !== 'object' ||
+            leftIsArray !== Array.isArray(rightValue)) {
+            return false;
+        }
+        const leftEntries = leftIsArray
+            ? denseArrayValues(leftValue, 'left value').map((item, index) => [String(index), item])
+            : ownDataEntries(ownDataRecord(leftValue, 'left value'), 'left value');
+        const rightEntries = leftIsArray
+            ? denseArrayValues(rightValue, 'right value').map((item, index) => [String(index), item])
+            : ownDataEntries(ownDataRecord(rightValue, 'right value'), 'right value');
+        if (leftEntries.length !== rightEntries.length)
+            return false;
+        if (leftIsArray) {
+            for (let index = leftEntries.length - 1; index >= 0; index -= 1) {
+                const leftEntry = leftEntries[index];
+                const rightEntry = rightEntries[index];
+                if (leftEntry === undefined || rightEntry === undefined || leftEntry[0] !== rightEntry[0]) {
+                    return false;
+                }
+                work.push([leftEntry[1], rightEntry[1]]);
+            }
+        }
+        else {
+            const rightByName = new Map(rightEntries);
+            for (const [key, item] of leftEntries) {
+                if (!rightByName.has(key))
+                    return false;
+                work.push([item, rightByName.get(key)]);
+            }
+        }
+    }
+    return true;
+}
+export function deepFreezeJsonData(value) {
+    const work = [];
+    if (value !== null && typeof value === 'object')
+        work.push(value);
+    const visited = new Set();
+    while (work.length > 0) {
+        const current = work.pop();
+        if (current === undefined || visited.has(current))
+            continue;
+        visited.add(current);
+        const children = Array.isArray(current)
+            ? current
+            : Object.values(current);
+        for (const child of children) {
+            if (child !== null && typeof child === 'object')
+                work.push(child);
+        }
+        Object.freeze(current);
+    }
+    return value;
+}
+/** Converts the supported closed JSON Schema fragments to OpenAPI 3.0 Schema Objects. */
+export function jsonSchemaToOpenApiFragment(value) {
+    const transform = (candidate) => {
+        if (Array.isArray(candidate))
+            return candidate.map(transform);
+        if (candidate === null || typeof candidate !== 'object')
+            return candidate;
+        const result = {};
+        for (const [key, item] of Object.entries(candidate)) {
+            if (key === '$schema' || key === '$id')
+                continue;
+            if (key === 'const') {
+                result.enum = [transform(item)];
+            }
+            else {
+                result[key] = transform(item);
+            }
+        }
+        return result;
+    };
+    return deepFreezeJsonData(transform(value));
+}