@cms0/cms0 0.2.20 → 0.2.22

package/dist/cjs/index-old.cjs

@@ -1,1016 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCmsClient = createCmsClient;
-exports.cms0 = cms0;
-const schema_descriptors_1 = require("@cms0/cms0/schema-descriptors");
-const shared_1 = require("@cms0/shared");
-const DEFAULT_REQUEST_CONCURRENCY = 6;
-const DEFAULT_REQUEST_RETRIES = 3;
-const DEFAULT_REQUEST_RETRY_BASE_MS = 250;
-const DEFAULT_REQUEST_RETRY_MAX_MS = 4000;
-const DEFAULT_MODEL_NORMALIZATION_CONCURRENCY = 8;
-const COLLECTION_SHAPE_ERROR = "Invalid collection response. Expected array or { items, total }.";
-function normalizeUploadsPath(uploadsPath) {
-    const raw = uploadsPath?.trim() || "/uploads";
-    const withLeadingSlash = raw.startsWith("/") ? raw : `/${raw}`;
-    const normalized = withLeadingSlash.replace(/\/+$/, "");
-    return normalized || "/uploads";
-}
-function normalizeAssetBaseUrl(baseUrl) {
-    const trimmed = baseUrl?.trim() ?? "";
-    return trimmed.replace(/\/+$/, "");
-}
-function encodeFilenameForUrl(filename) {
-    const normalized = filename.replace(/\\/g, "/").replace(/^\/+/, "").trim();
-    if (!normalized)
-        return "";
-    return normalized
-        .split("/")
-        .filter(Boolean)
-        .map((segment) => encodeURIComponent(segment))
-        .join("/");
-}
-function buildAssetUrlBuilder(apiBaseUrl, assetOptions) {
-    const uploadsPath = normalizeUploadsPath(assetOptions?.uploadsPath);
-    const explicitBaseUrl = normalizeAssetBaseUrl(assetOptions?.baseUrl);
-    if (explicitBaseUrl) {
-        return (filename) => `${explicitBaseUrl}${uploadsPath}/${encodeFilenameForUrl(filename)}`;
-    }
-    let inferredBaseUrl = "";
-    try {
-        inferredBaseUrl = new URL(apiBaseUrl).origin;
-    }
-    catch {
-        inferredBaseUrl = "";
-    }
-    return (filename) => `${inferredBaseUrl}${uploadsPath}/${encodeFilenameForUrl(filename)}`;
-}
-function maybeAttachAssetUrl(value, assetUrlBuilder) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const source = value;
-    const filename = typeof source.filename === "string" ? source.filename.trim() : "";
-    if (!filename)
-        return value;
-    const isAssetShape = typeof source.mimeType === "string" ||
-        typeof source.extension === "string" ||
-        typeof source.size === "number" ||
-        typeof source.width === "number" ||
-        typeof source.height === "number" ||
-        typeof source.length === "number";
-    if (!isAssetShape)
-        return value;
-    const existingUrl = typeof source.url === "string" && source.url.trim().length > 0
-        ? source.url
-        : null;
-    return {
-        ...source,
-        url: existingUrl ?? assetUrlBuilder(filename),
-    };
-}
-function toPlainText(value) {
-    if (typeof value === "string")
-        return value;
-    if (typeof value === "number" || typeof value === "boolean")
-        return String(value);
-    if (!value || typeof value !== "object")
-        return "";
-    const node = value;
-    if (typeof node.text === "string")
-        return node.text;
-    if ("value" in node)
-        return toPlainText(node.value);
-    if (Array.isArray(node.content)) {
-        return node.content
-            .map((child) => toPlainText(child))
-            .filter(Boolean)
-            .join(" ")
-            .trim();
-    }
-    return "";
-}
-function coerceRichTextValue(value) {
-    const source = value && typeof value === "object" ? value : {};
-    const nested = source.value && typeof source.value === "object"
-        ? source.value
-        : null;
-    const normalizedValue = source.value !== undefined ? source.value : value ?? {};
-    const html = typeof source.html === "string"
-        ? source.html
-        : typeof nested?.html === "string"
-            ? nested.html
-            : "";
-    return {
-        value: normalizedValue ?? {},
-        html,
-    };
-}
-function normalizeLocaleTag(value) {
-    return typeof value === "string" ? value.trim() : "";
-}
-function normalizeLocalizedMap(source, normalizeValue) {
-    const record = source && typeof source === "object" ? source : {};
-    const localesSource = record.locales && typeof record.locales === "object" && !Array.isArray(record.locales)
-        ? record.locales
-        : {};
-    const locales = {};
-    for (const [locale, raw] of Object.entries(localesSource)) {
-        const localeKey = normalizeLocaleTag(locale);
-        if (!localeKey)
-            continue;
-        locales[localeKey] = normalizeValue(raw);
-    }
-    const explicitDefault = normalizeLocaleTag(record.defaultLocale);
-    const firstLocale = Object.keys(locales)[0] ?? "";
-    const defaultLocale = explicitDefault || firstLocale;
-    return { defaultLocale, locales };
-}
-function projectLocalizedByLocale(localized, locale) {
-    if (!locale || locale === "all")
-        return localized;
-    const requested = normalizeLocaleTag(locale);
-    if (!requested)
-        return localized;
-    const requestedValue = localized.locales[requested];
-    if (requestedValue === undefined) {
-        return {
-            defaultLocale: requested,
-            locales: {},
-        };
-    }
-    return {
-        defaultLocale: requested,
-        locales: {
-            [requested]: requestedValue,
-        },
-    };
-}
-function coerceLocalizedStringValue(value, locale, defaultLocale) {
-    const normalized = normalizeLocalizedMap(value, (entry) => toPlainText(entry));
-    if (!normalized.defaultLocale && defaultLocale) {
-        normalized.defaultLocale = defaultLocale;
-    }
-    return projectLocalizedByLocale(normalized, locale);
-}
-function coerceLocalizedRichTextValue(value, locale, defaultLocale) {
-    const normalized = normalizeLocalizedMap(value, (entry) => coerceRichTextValue(entry));
-    if (!normalized.defaultLocale && defaultLocale) {
-        normalized.defaultLocale = defaultLocale;
-    }
-    return projectLocalizedByLocale(normalized, locale);
-}
-function coerceCustomTypeValue(descriptor, value, options) {
-    const customType = descriptor.customType;
-    if (!customType)
-        return value;
-    if (customType === "RichText")
-        return coerceRichTextValue(value);
-    if (customType === "File" || customType === "Image" || customType === "Video") {
-        return maybeAttachAssetUrl(value, options?.assetUrlBuilder ?? ((filename) => filename));
-    }
-    if (customType === "LocalizedString") {
-        return coerceLocalizedStringValue(value, options?.locale, options?.defaultLocale);
-    }
-    if (customType === "LocalizedRichText") {
-        return coerceLocalizedRichTextValue(value, options?.locale, options?.defaultLocale);
-    }
-    return value;
-}
-function isPrimitiveDescriptor(desc) {
-    return desc.kind === "primitive";
-}
-function isModelRefDescriptor(desc) {
-    return desc.kind === "modelRef";
-}
-function isObjectDescriptor(desc) {
-    return desc.type === "object" && !!desc.properties;
-}
-function isArrayDescriptor(desc) {
-    return desc.type === "array" && !!desc.items;
-}
-function asModelObjectDescriptor(modelName, descriptor) {
-    const model = descriptor.models?.[modelName];
-    if (!model) {
-        throw new Error(`Unknown model '${modelName}' in schema descriptor.`);
-    }
-    return {
-        type: "object",
-        properties: model.properties,
-        optional: false,
-        nullable: false,
-    };
-}
-function normalizeBaseUrl(baseUrl) {
-    const cleaned = baseUrl?.trim().replace(/\/$/, "") ?? "";
-    if (!cleaned) {
-        throw new Error("cms0: apiConfig.baseUrl is required to consume API resources.");
-    }
-    return cleaned;
-}
-function resolveIncludeIdMode(includeId) {
-    if (includeId === true)
-        return "all";
-    if (includeId === false)
-        return "none";
-    return "collections";
-}
-function shouldIncludeObjectId(mode, isCollectionItem) {
-    if (mode === "all")
-        return true;
-    if (mode === "collections")
-        return isCollectionItem;
-    return false;
-}
-function buildSearchParams(query) {
-    const params = new URLSearchParams();
-    if (!query)
-        return params;
-    for (const [key, rawValue] of Object.entries(query)) {
-        if (rawValue === undefined || rawValue === null)
-            continue;
-        if (Array.isArray(rawValue)) {
-            rawValue.forEach((value) => {
-                if (value === undefined || value === null)
-                    return;
-                params.append(key, String(value));
-            });
-            continue;
-        }
-        params.set(key, String(rawValue));
-    }
-    return params;
-}
-function ensureCollectionEnvelope(data, path) {
-    if (Array.isArray(data)) {
-        return { items: data, total: data.length };
-    }
-    if (data && typeof data === "object" && Array.isArray(data.items)) {
-        return {
-            items: data.items,
-            total: Number(data.total ?? data.items.length ?? 0),
-        };
-    }
-    throw new Error(`${COLLECTION_SHAPE_ERROR} Path: '${path}'.`);
-}
-function clampInteger(value, fallback, minimum) {
-    if (!Number.isFinite(value))
-        return fallback;
-    const normalized = Math.floor(value);
-    return normalized >= minimum ? normalized : fallback;
-}
-function normalizeRequestOptions(options) {
-    const concurrency = clampInteger(options?.concurrency, DEFAULT_REQUEST_CONCURRENCY, 1);
-    const retries = clampInteger(options?.retries, DEFAULT_REQUEST_RETRIES, 0);
-    const baseDelayMs = clampInteger(options?.retryBaseMs, DEFAULT_REQUEST_RETRY_BASE_MS, 1);
-    const maxDelayCandidate = clampInteger(options?.retryMaxMs, DEFAULT_REQUEST_RETRY_MAX_MS, 1);
-    const maxDelayMs = Math.max(maxDelayCandidate, baseDelayMs);
-    const modelNormalizationConcurrency = Math.max(concurrency, DEFAULT_MODEL_NORMALIZATION_CONCURRENCY);
-    return {
-        concurrency,
-        retry: {
-            retries,
-            baseDelayMs,
-            maxDelayMs,
-        },
-        modelNormalizationConcurrency,
-    };
-}
-function createAbortError() {
-    const error = new Error("The operation was aborted.");
-    error.name = "AbortError";
-    return error;
-}
-function isAbortError(error) {
-    return !!error && typeof error === "object" && error.name === "AbortError";
-}
-function waitForDelay(ms, signal) {
-    if (!Number.isFinite(ms) || ms <= 0) {
-        if (signal?.aborted)
-            return Promise.reject(createAbortError());
-        return Promise.resolve();
-    }
-    return new Promise((resolve, reject) => {
-        if (signal?.aborted) {
-            reject(createAbortError());
-            return;
-        }
-        const timer = setTimeout(() => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        function onAbort() {
-            clearTimeout(timer);
-            signal?.removeEventListener("abort", onAbort);
-            reject(createAbortError());
-        }
-        signal?.addEventListener("abort", onAbort, { once: true });
-    });
-}
-function parseRetryAfterMs(retryAfterValue) {
-    if (!retryAfterValue)
-        return null;
-    const value = retryAfterValue.trim();
-    if (!value)
-        return null;
-    const seconds = Number(value);
-    if (Number.isFinite(seconds)) {
-        return Math.max(0, Math.round(seconds * 1000));
-    }
-    const at = Date.parse(value);
-    if (Number.isNaN(at))
-        return null;
-    return Math.max(0, at - Date.now());
-}
-function shouldRetryStatus(status) {
-    return status === 429 || (status >= 500 && status <= 599);
-}
-function createRequestScheduler(maxConcurrency) {
-    let active = 0;
-    const queue = [];
-    const pump = () => {
-        while (active < maxConcurrency && queue.length > 0) {
-            const next = queue.shift();
-            if (!next)
-                continue;
-            next();
-        }
-    };
-    return (task, signal) => new Promise((resolve, reject) => {
-        if (signal?.aborted) {
-            reject(createAbortError());
-            return;
-        }
-        let queued = true;
-        let settled = false;
-        const run = () => {
-            if (settled)
-                return;
-            queued = false;
-            active += 1;
-            Promise.resolve()
-                .then(task)
-                .then(resolve, reject)
-                .finally(() => {
-                settled = true;
-                active = Math.max(0, active - 1);
-                signal?.removeEventListener("abort", onAbort);
-                pump();
-            });
-        };
-        const onAbort = () => {
-            if (!queued || settled)
-                return;
-            settled = true;
-            const index = queue.indexOf(run);
-            if (index >= 0) {
-                queue.splice(index, 1);
-            }
-            reject(createAbortError());
-        };
-        signal?.addEventListener("abort", onAbort, { once: true });
-        queue.push(run);
-        pump();
-    });
-}
-async function mapWithConcurrency(items, concurrency, mapper) {
-    if (items.length === 0)
-        return [];
-    const limit = Math.max(1, Math.floor(concurrency));
-    if (limit >= items.length) {
-        return Promise.all(items.map((item, index) => mapper(item, index)));
-    }
-    const results = new Array(items.length);
-    let nextIndex = 0;
-    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
-        while (true) {
-            const current = nextIndex++;
-            if (current >= items.length)
-                break;
-            results[current] = await mapper(items[current], current);
-        }
-    });
-    await Promise.all(workers);
-    return results;
-}
-function extractId(value) {
-    if (typeof value === "string" && value.length > 0)
-        return value;
-    if (value && typeof value === "object" && typeof value.id === "string") {
-        return value.id;
-    }
-    return null;
-}
-function capitalize(input) {
-    return input ? input[0].toUpperCase() + input.slice(1) : input;
-}
-function lowerFirst(input) {
-    return input ? input[0].toLowerCase() + input.slice(1) : input;
-}
-function camelCaseModelIdKey(modelName) {
-    return `${lowerFirst(modelName)}Id`;
-}
-function snakeCaseModelIdKey(modelName) {
-    const snake = modelName
-        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
-        .replace(/\s+/g, "_")
-        .toLowerCase();
-    return `${snake}_id`;
-}
-function extractModelRefId(raw, modelName, options) {
-    if (typeof raw === "string")
-        return raw;
-    if (!raw || typeof raw !== "object")
-        return null;
-    const object = raw;
-    const prop = options?.propertyName ?? "";
-    const propertyCandidates = [
-        prop ? `${prop}Id` : "",
-        prop
-            ? `${prop.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase()}_id`
-            : "",
-    ].filter(Boolean);
-    const modelCandidates = [
-        camelCaseModelIdKey(modelName),
-        snakeCaseModelIdKey(modelName),
-    ];
-    // Prefer property-specific FKs (e.g., logoId) over model-level defaults
-    // (e.g., imageId) when multiple refs share the same model in one object row.
-    const candidates = Array.from(new Set([...propertyCandidates, ...modelCandidates, "value"]));
-    for (const key of candidates) {
-        const found = extractId(object[key]);
-        if (found)
-            return found;
-    }
-    const allowObjectIdFallback = options?.allowObjectIdFallback ?? true;
-    if (allowObjectIdFallback) {
-        const keys = Object.keys(object);
-        const hasOnlyId = keys.length === 1 && keys[0] === "id";
-        if (hasOnlyId) {
-            const byId = extractId(object);
-            if (byId)
-                return byId;
-        }
-    }
-    return null;
-}
-function buildModelRefCacheKey(modelName, id, context, isCollectionItem) {
-    const locale = context.options.locale ?? "";
-    const defaultLocale = context.options.defaultLocale ?? "";
-    const includeIdMode = context.options.includeIdMode;
-    const refsMode = context.options.resolveModelRefs ? "resolve" : "ids";
-    const collectionFlag = isCollectionItem ? "collection" : "single";
-    return [
-        modelName,
-        id,
-        locale,
-        defaultLocale,
-        includeIdMode,
-        refsMode,
-        collectionFlag,
-    ].join("|");
-}
-function extractInlineModelObject(raw, modelDescriptor) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return null;
-    if (!isObjectDescriptor(modelDescriptor))
-        return null;
-    const source = raw;
-    const propertyKeys = Object.keys(modelDescriptor.properties ?? {});
-    const hasModelField = propertyKeys.some((key) => key in source);
-    if (!hasModelField)
-        return null;
-    return source;
-}
-function formatValidationError(name, error) {
-    const payload = error && typeof error === "object" && "format" in error
-        ? error.format()
-        : error;
-    return `Invalid data received for '${name}': ${JSON.stringify(payload)}`;
-}
-function levenshtein(a, b) {
-    if (a === b)
-        return 0;
-    if (!a.length)
-        return b.length;
-    if (!b.length)
-        return a.length;
-    const rows = a.length + 1;
-    const cols = b.length + 1;
-    const matrix = Array.from({ length: rows }, () => new Array(cols).fill(0));
-    for (let i = 0; i < rows; i++)
-        matrix[i][0] = i;
-    for (let j = 0; j < cols; j++)
-        matrix[0][j] = j;
-    for (let i = 1; i < rows; i++) {
-        for (let j = 1; j < cols; j++) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
-        }
-    }
-    return matrix[rows - 1][cols - 1];
-}
-function unknownKeyError(key, roots, models) {
-    const candidates = [...roots, ...models];
-    const normalized = key.toLowerCase();
-    const suggestions = candidates
-        .map((candidate) => ({
-        candidate,
-        distance: levenshtein(normalized, candidate.toLowerCase()),
-    }))
-        .sort((a, b) => a.distance - b.distance)
-        .slice(0, 3)
-        .map((entry) => entry.candidate);
-    const suggestionText = suggestions.length
-        ? ` Did you mean: ${suggestions.join(", ")}?`
-        : "";
-    const rootsText = `Available roots: [${roots.join(", ")}]`;
-    const modelsText = models.length
-        ? `, models (under data.models.*): [${models.join(", ")}]`
-        : "";
-    throw new Error(`Unknown schema key '${key}'. ${rootsText}${modelsText}.${suggestionText}`);
-}
-async function normalizeModelRef(modelName, id, context, trail, isCollectionItem, inlineValue) {
-    if (!id)
-        return null;
-    if (!context.options.resolveModelRefs)
-        return id;
-    const nodeKey = buildModelRefCacheKey(modelName, id, context, isCollectionItem);
-    if (trail.has(nodeKey)) {
-        return shouldIncludeObjectId(context.options.includeIdMode, isCollectionItem)
-            ? { id }
-            : id;
-    }
-    const modelDescriptor = context.modelDescriptors.get(modelName);
-    if (!modelDescriptor) {
-        return id;
-    }
-    const inlineModel = extractInlineModelObject(inlineValue, modelDescriptor);
-    const cached = context.modelCache.get(nodeKey);
-    if (cached) {
-        return cached;
-    }
-    const sharedInflight = context.sharedModelInflightCache.get(nodeKey);
-    if (sharedInflight) {
-        context.modelCache.set(nodeKey, sharedInflight);
-        return sharedInflight;
-    }
-    const nextTrail = new Set(trail);
-    nextTrail.add(nodeKey);
-    const promise = (async () => {
-        const rawModel = inlineModel ??
-            (await context.requestJson(`models/${modelName}/${id}`, {
-                query: {
-                    raw: 1,
-                    ...(context.options.locale ? { locale: context.options.locale } : {}),
-                },
-            }));
-        return normalizeField(modelDescriptor, `models/${modelName}/${encodeURIComponent(id)}`, rawModel, context, nextTrail, isCollectionItem);
-    })();
-    context.modelCache.set(nodeKey, promise);
-    context.sharedModelInflightCache.set(nodeKey, promise);
-    promise
-        .then(() => undefined, () => {
-        context.modelCache.delete(nodeKey);
-    })
-        .finally(() => {
-        context.sharedModelInflightCache.delete(nodeKey);
-    });
-    return promise;
-}
-function missingModelRefValue(descriptor) {
-    if (descriptor.nullable)
-        return null;
-    if (descriptor.optional)
-        return undefined;
-    return null;
-}
-async function normalizeObjectField(descriptor, path, raw, context, trail, isCollectionItem) {
-    const source = raw && typeof raw === "object" ? raw : {};
-    const output = {};
-    for (const [propertyName, propertyDescriptor] of Object.entries(descriptor.properties)) {
-        if (isPrimitiveDescriptor(propertyDescriptor)) {
-            output[propertyName] = coerceCustomTypeValue(propertyDescriptor, source[propertyName], {
-                locale: context.options.locale,
-                defaultLocale: context.options.defaultLocale,
-                assetUrlBuilder: context.options.assetUrlBuilder,
-            });
-            continue;
-        }
-        if (isModelRefDescriptor(propertyDescriptor)) {
-            const inlineValue = source[propertyName];
-            const inlineModelDescriptor = context.modelDescriptors.get(propertyDescriptor.model);
-            const inlineModel = inlineModelDescriptor
-                ? extractInlineModelObject(inlineValue, inlineModelDescriptor)
-                : null;
-            const refId = extractModelRefId(inlineValue, propertyDescriptor.model, {
-                allowObjectIdFallback: true,
-            }) ??
-                (inlineModel ? extractId(inlineModel) : null) ??
-                extractModelRefId(source, propertyDescriptor.model, {
-                    propertyName,
-                    allowObjectIdFallback: false,
-                });
-            if (!refId) {
-                const missing = missingModelRefValue(propertyDescriptor);
-                if (missing !== undefined) {
-                    output[propertyName] = missing;
-                }
-                continue;
-            }
-            output[propertyName] = await normalizeModelRef(propertyDescriptor.model, refId, context, trail, false, inlineValue);
-            continue;
-        }
-        if (isArrayDescriptor(propertyDescriptor)) {
-            const childPath = `${path}/${propertyName}`;
-            const childRaw = await context.requestJson(childPath, {
-                query: {
-                    raw: 1,
-                    ...(context.options.locale ? { locale: context.options.locale } : {}),
-                },
-            });
-            const normalizedChild = await normalizeArrayField(propertyDescriptor, childPath, childRaw, context, trail);
-            output[propertyName] = coerceCustomTypeValue(propertyDescriptor, normalizedChild, {
-                locale: context.options.locale,
-                defaultLocale: context.options.defaultLocale,
-                assetUrlBuilder: context.options.assetUrlBuilder,
-            });
-            continue;
-        }
-        if (isObjectDescriptor(propertyDescriptor)) {
-            const childPath = `${path}/${propertyName}`;
-            const childRaw = await context.requestJson(childPath, {
-                query: {
-                    raw: 1,
-                    ...(context.options.locale ? { locale: context.options.locale } : {}),
-                },
-            });
-            const normalizedChild = await normalizeObjectField(propertyDescriptor, childPath, childRaw, context, trail, false);
-            output[propertyName] = coerceCustomTypeValue(propertyDescriptor, normalizedChild, {
-                locale: context.options.locale,
-                defaultLocale: context.options.defaultLocale,
-                assetUrlBuilder: context.options.assetUrlBuilder,
-            });
-        }
-    }
-    if (shouldIncludeObjectId(context.options.includeIdMode, isCollectionItem)) {
-        const rowId = extractId(source);
-        if (rowId)
-            output.id = rowId;
-    }
-    if (typeof source.url === "string" &&
-        source.url.trim().length > 0 &&
-        typeof output.filename === "string") {
-        output.url = source.url;
-    }
-    return maybeAttachAssetUrl(output, context.options.assetUrlBuilder);
-}
-async function normalizeArrayField(descriptor, path, raw, context, trail) {
-    const envelope = ensureCollectionEnvelope(raw, path);
-    const itemDescriptor = descriptor.items;
-    if (isPrimitiveDescriptor(itemDescriptor)) {
-        return envelope.items.map((row) => {
-            const value = row && typeof row === "object" && "value" in row
-                ? row.value
-                : row;
-            if (context.options.includeIdMode !== "all") {
-                return value;
-            }
-            const id = extractId(row);
-            return id ? { id, value } : value;
-        });
-    }
-    if (isModelRefDescriptor(itemDescriptor)) {
-        const inlineModelDescriptor = context.modelDescriptors.get(itemDescriptor.model);
-        return mapWithConcurrency(envelope.items, context.options.modelNormalizationConcurrency, async (row) => {
-            const inlineModel = inlineModelDescriptor
-                ? extractInlineModelObject(row, inlineModelDescriptor)
-                : null;
-            const refId = extractModelRefId(row, itemDescriptor.model, {
-                allowObjectIdFallback: false,
-            }) ?? (inlineModel ? extractId(inlineModel) : null);
-            return normalizeModelRef(itemDescriptor.model, refId, context, trail, true, row);
-        });
-    }
-    if (isObjectDescriptor(itemDescriptor)) {
-        return mapWithConcurrency(envelope.items, context.options.modelNormalizationConcurrency, async (row) => {
-            const rowId = extractId(row);
-            const rowPath = rowId
-                ? `${path}/${encodeURIComponent(rowId)}`
-                : path;
-            return normalizeObjectField(itemDescriptor, rowPath, row, context, trail, true);
-        });
-    }
-    return envelope.items;
-}
-async function normalizeField(descriptor, path, raw, context, trail, isCollectionItem) {
-    if (isPrimitiveDescriptor(descriptor)) {
-        const value = raw && typeof raw === "object" && "value" in raw
-            ? raw.value
-            : raw;
-        return coerceCustomTypeValue(descriptor, value, {
-            locale: context.options.locale,
-            defaultLocale: context.options.defaultLocale,
-            assetUrlBuilder: context.options.assetUrlBuilder,
-        });
-    }
-    if (isModelRefDescriptor(descriptor)) {
-        const inlineModelDescriptor = context.modelDescriptors.get(descriptor.model);
-        const inlineModel = inlineModelDescriptor
-            ? extractInlineModelObject(raw, inlineModelDescriptor)
-            : null;
-        const refId = extractModelRefId(raw, descriptor.model, {
-            allowObjectIdFallback: true,
-        }) ?? (inlineModel ? extractId(inlineModel) : null);
-        if (!refId) {
-            return missingModelRefValue(descriptor);
-        }
-        return normalizeModelRef(descriptor.model, refId, context, trail, isCollectionItem, raw);
-    }
-    if (isArrayDescriptor(descriptor)) {
-        const normalized = await normalizeArrayField(descriptor, path, raw, context, trail);
-        return coerceCustomTypeValue(descriptor, normalized, {
-            locale: context.options.locale,
-            defaultLocale: context.options.defaultLocale,
-            assetUrlBuilder: context.options.assetUrlBuilder,
-        });
-    }
-    if (isObjectDescriptor(descriptor)) {
-        const normalized = await normalizeObjectField(descriptor, path, raw, context, trail, isCollectionItem);
-        return coerceCustomTypeValue(descriptor, normalized, {
-            locale: context.options.locale,
-            defaultLocale: context.options.defaultLocale,
-            assetUrlBuilder: context.options.assetUrlBuilder,
-        });
-    }
-    return raw;
-}
-function createResourceRegistry(descriptor) {
-    const roots = new Map();
-    const rootsCaseInsensitive = new Map();
-    for (const [key, rootDescriptor] of Object.entries(descriptor.roots ?? {})) {
-        const entry = {
-            kind: "root",
-            key,
-            path: key,
-            descriptor: rootDescriptor,
-            isCollection: isArrayDescriptor(rootDescriptor),
-        };
-        roots.set(key, entry);
-        rootsCaseInsensitive.set(key.toLowerCase(), entry);
-    }
-    const models = new Map();
-    const modelsCaseInsensitive = new Map();
-    for (const modelName of Object.keys(descriptor.models ?? {})) {
-        const entry = {
-            kind: "model",
-            key: modelName,
-            path: `models/${modelName}`,
-            descriptor: asModelObjectDescriptor(modelName, descriptor),
-            isCollection: true,
-            modelName,
-        };
-        models.set(modelName, entry);
-        modelsCaseInsensitive.set(modelName.toLowerCase(), entry);
-    }
-    return {
-        roots,
-        rootsCaseInsensitive,
-        models,
-        modelsCaseInsensitive,
-    };
-}
-async function requestJson(baseUrl, apiKey, path, options, runtime) {
-    const params = buildSearchParams(options?.query);
-    const url = `${baseUrl}/${path}${params.toString() ? `?${params.toString()}` : ""}`;
-    const execute = async () => {
-        const retry = runtime?.retry ?? {
-            retries: DEFAULT_REQUEST_RETRIES,
-            baseDelayMs: DEFAULT_REQUEST_RETRY_BASE_MS,
-            maxDelayMs: DEFAULT_REQUEST_RETRY_MAX_MS,
-        };
-        let attempt = 0;
-        while (true) {
-            let response;
-            try {
-                response = runtime?.scheduler
-                    ? await runtime.scheduler(() => fetch(url, {
-                        method: "GET",
-                        signal: options?.signal,
-                        headers: {
-                            ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
-                        },
-                    }), options?.signal)
-                    : await fetch(url, {
-                        method: "GET",
-                        signal: options?.signal,
-                        headers: {
-                            ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
-                        },
-                    });
-            }
-            catch (error) {
-                if (isAbortError(error))
-                    throw error;
-                if (attempt >= retry.retries)
-                    throw error;
-                const delayMs = Math.min(retry.baseDelayMs * 2 ** attempt, retry.maxDelayMs);
-                attempt += 1;
-                await waitForDelay(delayMs, options?.signal);
-                continue;
-            }
-            if (response.ok) {
-                return response.json();
-            }
-            const canRetry = shouldRetryStatus(response.status) && attempt < retry.retries;
-            if (!canRetry) {
-                throw new Error(`Request failed for '${path}' with status ${response.status}: ${response.statusText}`);
-            }
-            const retryAfterMs = parseRetryAfterMs(response.headers.get("retry-after"));
-            const fallbackDelay = Math.min(retry.baseDelayMs * 2 ** attempt, retry.maxDelayMs);
-            const delayMs = retryAfterMs ?? fallbackDelay;
-            attempt += 1;
-            await waitForDelay(delayMs, options?.signal);
-        }
-    };
-    const useInflightDedup = !options?.signal && !!runtime;
-    if (!useInflightDedup || !runtime) {
-        return execute();
-    }
-    const cached = runtime.inflightRequestCache.get(url);
-    if (cached)
-        return cached;
-    const promise = execute().finally(() => {
-        runtime.inflightRequestCache.delete(url);
-    });
-    runtime.inflightRequestCache.set(url, promise);
-    return promise;
-}
-function validateResult(resource, result, descriptor, includeIdMode, zodSchemas, modelZodSchemas) {
-    if (includeIdMode === "all")
-        return;
-    if (resource.kind === "root") {
-        const schema = zodSchemas[resource.key];
-        if (!schema)
-            return;
-        const parsed = schema.safeParse(result);
-        if (!parsed.success) {
-            throw new Error(formatValidationError(resource.key, parsed.error));
-        }
-        return;
-    }
-    const modelName = resource.modelName;
-    if (!modelName)
-        return;
-    const modelSchema = modelZodSchemas[modelName];
-    if (!modelSchema)
-        return;
-    if (Array.isArray(result)) {
-        const parsed = modelSchema.array().safeParse(result);
-        if (!parsed.success) {
-            throw new Error(formatValidationError(modelName, parsed.error));
-        }
-        return;
-    }
-    if (result === null || result === undefined)
-        return;
-    const parsed = modelSchema.safeParse(result);
-    if (!parsed.success) {
-        throw new Error(formatValidationError(modelName, parsed.error));
-    }
-}
-async function runResource(resource, descriptor, baseUrl, apiKey, defaultLocale, assetUrlBuilder, requestRuntime, sharedModelInflightCache, modelNormalizationConcurrency, zodSchemas, modelZodSchemas, options, byId) {
-    const responseMode = options?.response ?? "normalized";
-    const includeIdMode = resolveIncludeIdMode(options?.includeId);
-    const resolveModelRefs = options?.resolveModelRefs !== false;
-    const requestedLocale = options?.locale ??
-        (typeof options?.query?.locale === "string"
-            ? options.query.locale
-            : undefined);
-    const locale = requestedLocale ??
-        (responseMode === "normalized" ? "all" : undefined);
-    const query = {
-        ...(options?.query ?? {}),
-    };
-    const shouldNormalize = responseMode !== "raw";
-    if (shouldNormalize && query.raw === undefined) {
-        query.raw = 1;
-    }
-    if (locale && query.locale === undefined) {
-        query.locale = locale;
-    }
-    const resourcePath = byId
-        ? `${resource.path}/${encodeURIComponent(byId)}`
-        : resource.path;
-    const rawData = await requestJson(baseUrl, apiKey, resourcePath, {
-        query,
-        signal: options?.signal,
-    }, requestRuntime);
-    if (!shouldNormalize) {
-        return rawData;
-    }
-    const modelDescriptors = new Map();
-    for (const modelName of Object.keys(descriptor.models ?? {})) {
-        modelDescriptors.set(modelName, asModelObjectDescriptor(modelName, descriptor));
-    }
-    const context = {
-        requestJson: (path, requestOptions) => requestJson(baseUrl, apiKey, path, {
-            ...requestOptions,
-            signal: options?.signal,
-        }, requestRuntime),
-        modelDescriptors,
-        modelCache: new Map(),
-        sharedModelInflightCache,
-        options: {
-            includeIdMode,
-            resolveModelRefs,
-            locale,
-            defaultLocale,
-            assetUrlBuilder,
-            modelNormalizationConcurrency,
-        },
-    };
-    if (resource.isCollection && !byId) {
-        const envelope = ensureCollectionEnvelope(rawData, resource.path);
-        const descriptorForCollection = resource.kind === "root" && isArrayDescriptor(resource.descriptor)
-            ? resource.descriptor
-            : {
-                type: "array",
-                items: resource.descriptor,
-                optional: false,
-                nullable: false,
-            };
-        const normalizedItems = await normalizeArrayField(descriptorForCollection, resource.path, envelope, context, new Set());
-        if (responseMode === "envelope") {
-            validateResult(resource, normalizedItems, descriptor, includeIdMode, zodSchemas, modelZodSchemas);
-            return {
-                items: normalizedItems,
-                total: envelope.total,
-            };
-        }
-        validateResult(resource, normalizedItems, descriptor, includeIdMode, zodSchemas, modelZodSchemas);
-        return normalizedItems;
-    }
-    const normalized = await normalizeField(resource.descriptor, resourcePath, rawData, context, new Set(), false);
-    validateResult(resource, normalized, descriptor, includeIdMode, zodSchemas, modelZodSchemas);
-    return normalized;
-}
-function createCmsClient(descriptor, config) {
-    const baseUrl = normalizeBaseUrl(config.apiConfig?.baseUrl);
-    const apiKey = config.apiConfig?.key;
-    const assetUrlBuilder = buildAssetUrlBuilder(baseUrl, config.assets);
-    const registry = createResourceRegistry(descriptor);
-    const rootKeys = Array.from(registry.roots.keys());
-    const modelKeys = Array.from(registry.models.keys());
-    const { zodSchemas, modelZodSchemas } = (0, shared_1.buildZodSchemasFromDescriptor)(descriptor);
-    const requestOptions = normalizeRequestOptions(config.requests);
-    const requestRuntime = {
-        scheduler: createRequestScheduler(requestOptions.concurrency),
-        inflightRequestCache: new Map(),
-        retry: requestOptions.retry,
-    };
-    const sharedModelInflightCache = new Map();
-    const buildModelAccessor = (entry) => {
-        const accessor = (async (options) => runResource(entry, descriptor, baseUrl, apiKey, config.defaultLocale, assetUrlBuilder, requestRuntime, sharedModelInflightCache, requestOptions.modelNormalizationConcurrency, zodSchemas, modelZodSchemas, options));
-        accessor.byId = async (id, options) => runResource(entry, descriptor, baseUrl, apiKey, config.defaultLocale, assetUrlBuilder, requestRuntime, sharedModelInflightCache, requestOptions.modelNormalizationConcurrency, zodSchemas, modelZodSchemas, options, id);
-        return accessor;
-    };
-    const modelsProxy = new Proxy({}, {
-        get(_target, property) {
-            if (typeof property !== "string")
-                return undefined;
-            if (property === "then")
-                return undefined;
-            const modelEntry = registry.models.get(property) ??
-                registry.modelsCaseInsensitive.get(property.toLowerCase());
-            if (!modelEntry) {
-                unknownKeyError(property, [], modelKeys);
-            }
-            return buildModelAccessor(modelEntry);
-        },
-    });
-    const rootProxy = new Proxy({}, {
-        get(_target, property) {
-            if (typeof property !== "string")
-                return undefined;
-            if (property === "then")
-                return undefined;
-            if (property === "models")
-                return modelsProxy;
-            const entry = registry.roots.get(property) ??
-                registry.rootsCaseInsensitive.get(property.toLowerCase());
-            if (!entry) {
-                unknownKeyError(property, rootKeys, []);
-            }
-            return async (options) => runResource(entry, descriptor, baseUrl, apiKey, config.defaultLocale, assetUrlBuilder, requestRuntime, sharedModelInflightCache, requestOptions.modelNormalizationConcurrency, zodSchemas, modelZodSchemas, options);
-        },
-    });
-    return rootProxy;
-}
-/**
- * Initializes the CMS SDK for a given schema.
- * @param config configuration including API base URL and API key.
- * @returns typed accessors for root resources and model resources.
- */
-function cms0(config) {
-    return createCmsClient(schema_descriptors_1.schemaDescriptor, config);
-}