@lemonadecms/client 0.0.0-stage → 0.1.1

package/dist/transport.js

@@ -0,0 +1,519 @@
+// Shared, framework-independent HTTP implementation behind the fluent SDK.
+// Configuration and query options are validated before sending a request. The
+// selected factory supplies the credential and route; callers cannot switch modes
+// through list options. Responses are checked as unknown data before their envelope
+// is converted from API snake_case to SDK camelCase. No automatic retries occur.
+import { CMSConfigurationError, CMSRequestError, CMSResponseError, CMSTimeoutError, CMSNotFoundError } from "./errors.js";
+const identifier = /^[a-z][a-z0-9_]{0,47}$/;
+const cursor = (value) => uuid.test(value) || (value.length <= 8192 && /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/.test(value));
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const serviceURL = "https://lemonadecms.com";
+const localeTag = /^[a-z]{2,3}(?:-[A-Z][a-z]{3})?(?:-(?:[A-Z]{2}|[0-9]{3}))?$/;
+// Narrow unknown JSON to an object before accessing properties. Arrays and null
+// are not valid objects for the API envelope even though typeof reports object.
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readOptions(value, allowed, method) {
+    const controls = ["limit", "page", "pageSize", "after", "before", "maxPages", "select", "sort", "filters", "includeRemote", "ids", "search"];
+    if (!record(value) || Object.keys(value).some(key => !allowed.includes(key)) ||
+        controls.some(key => !allowed.includes(key) && key in value)) {
+        throw new TypeError(`${method} supports ${allowed.join(", ")}.`);
+    }
+}
+// Only configured deadlines need a local controller/race. Keep the default
+// fetch signal unchanged, while rejecting already-cancelled work before I/O.
+// Native composition preserves fetch-style cancellation even when another caller
+// listener suppresses the caller's abort event. Reject the new timeout+signal
+// combination when that capability is absent rather than weaken cancellation.
+// One cleanup path releases the timer and private listener regardless of outcome.
+// The attached fulfillment/rejection handlers also consume late custom-fetch
+// completions when a transport ignores cancellation; they cannot settle twice.
+function withinDeadline(timeoutMs, callerSignal, execute) {
+    callerSignal?.throwIfAborted();
+    if (timeoutMs === undefined)
+        return execute(callerSignal);
+    if (callerSignal && typeof AbortSignal.any !== "function") {
+        throw new CMSConfigurationError("Combining timeoutMs and signal requires AbortSignal.any support.");
+    }
+    const controller = new AbortController();
+    const requestSignal = callerSignal ? AbortSignal.any([callerSignal, controller.signal]) : controller.signal;
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let timer;
+        const finish = (complete) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            requestSignal.removeEventListener("abort", cancel);
+            complete();
+        };
+        const cancel = () => {
+            const reason = requestSignal.reason;
+            finish(() => reject(reason));
+            controller.abort(reason);
+        };
+        requestSignal.addEventListener("abort", cancel, { once: true });
+        timer = setTimeout(() => {
+            const error = requestSignal.aborted ? requestSignal.reason : callerSignal?.aborted ? callerSignal.reason : new CMSTimeoutError(timeoutMs);
+            finish(() => reject(error));
+            controller.abort(error);
+        }, timeoutMs);
+        try {
+            execute(requestSignal).then(value => finish(() => resolve(value)), error => finish(() => reject(error)));
+        }
+        catch (error) {
+            finish(() => reject(error));
+        }
+    });
+}
+function validateFilters(value) {
+    let nodes = 0, leaves = 0, stringUnits = 0;
+    const scalar = (v) => {
+        if (typeof v === "string") {
+            stringUnits += v.length;
+            return stringUnits <= 4096 && !v.includes("\0");
+        }
+        return typeof v === "boolean" || typeof v === "number" && Number.isFinite(v);
+    };
+    const walk = (node, depth) => {
+        if (!record(node) || depth > 4 || ++nodes > 31)
+            return false;
+        const keys = Object.keys(node);
+        if (keys.length === 1 && ["and", "or", "not"].includes(keys[0])) {
+            const group = keys[0];
+            if (group === "not")
+                return walk(node.not, depth + 1);
+            const children = node[group];
+            return Array.isArray(children) && children.length >= 1 && children.length <= 10 && Array.from(children).every(child => walk(child, depth + 1));
+        }
+        if (++leaves > 10 || keys.sort().join(",") !== "field,op,value" || typeof node.field !== "string" ||
+            !identifier.test(node.field) || typeof node.op !== "string")
+            return false;
+        const v = node.value;
+        if (["eq", "ne"].includes(node.op))
+            return v === null || scalar(v);
+        if (["in", "not_in"].includes(node.op))
+            return Array.isArray(v) && v.length >= 1 && v.length <= 100 && Array.from(v).every(scalar);
+        if (["contains_any", "contains_all"].includes(node.op))
+            return Array.isArray(v) && v.length >= 1 && v.length <= 100 && new Set(v).size === v.length &&
+                Array.from(v).every(option => typeof option === "string" && option.trim().length > 0 && scalar(option));
+        if (["gt", "gte", "lt", "lte"].includes(node.op))
+            return (typeof v === "string" || typeof v === "number") && scalar(v);
+        if (["eqi", "contains", "containsi", "starts_with", "starts_withi", "ends_with", "ends_withi"].includes(node.op))
+            return typeof v === "string" && (node.op === "eqi" || v.length > 0) && scalar(v);
+        return false;
+    };
+    const valid = Array.isArray(value) ? value.length <= 10 && Array.from(value).every(node => walk(node, 0)) : walk(value, 0);
+    if (!valid)
+        throw new TypeError("filters require valid conditions or nonempty and/or/not groups, at most ten leaves, 31 nodes and depth four.");
+}
+function query(options) {
+    if (!record(options) || Object.keys(options).some(key => !["select", "limit", "page", "pageSize", "after", "before", "signal", "locale", "filters", "sort", "search", "includeRemote"].includes(key))) {
+        throw new TypeError("Supported list options are select, limit, page, pageSize, after, before, locale, filters, sort, search, includeRemote and signal.");
+    }
+    const params = new URLSearchParams();
+    if (options.includeRemote !== undefined) {
+        if (typeof options.includeRemote !== "boolean")
+            throw new TypeError("includeRemote must be a boolean.");
+        params.set("includeRemote", String(options.includeRemote));
+    }
+    if (options.select !== undefined) {
+        if (!Array.isArray(options.select) || options.select.length < 1 || options.select.length > 24 ||
+            new Set(options.select).size !== options.select.length ||
+            !options.select.every(key => typeof key === "string" && identifier.test(key))) {
+            throw new TypeError("select must contain 1–24 unique field identifiers.");
+        }
+        params.set("select", options.select.join(","));
+    }
+    if (options.page !== undefined || options.pageSize !== undefined) {
+        if (options.limit !== undefined || options.after !== undefined || options.before !== undefined)
+            throw new TypeError("Use page/pageSize or limit/after/before, never both modes.");
+        const page = options.page ?? 1, size = options.pageSize ?? 25;
+        if (!Number.isSafeInteger(page) || page < 1 || !Number.isInteger(size) || size < 1 || size > 100 || (page - 1) * size > 10000)
+            throw new TypeError("page must be positive, pageSize 1–100, and skipped rows at most 10000.");
+        params.set("page", String(page));
+        params.set("pageSize", String(size));
+    }
+    if (options.limit !== undefined) {
+        if (typeof options.limit !== "number" || !Number.isInteger(options.limit) || options.limit < 1 || options.limit > 100) {
+            throw new TypeError("limit must be an integer between 1 and 100.");
+        }
+        params.set("limit", String(options.limit));
+    }
+    if (options.locale !== undefined) {
+        if (typeof options.locale !== "string" || !localeTag.test(options.locale)) {
+            throw new TypeError("locale must be a language code such as en, es or pt-BR.");
+        }
+        params.set("locale", options.locale);
+    }
+    if (options.after !== undefined && options.before !== undefined) {
+        throw new TypeError("Use either after or before, never both.");
+    }
+    for (const direction of ["after", "before"]) {
+        const boundary = options[direction];
+        if (boundary !== undefined) {
+            if (typeof boundary !== "string" || !cursor(boundary)) {
+                throw new TypeError(`${direction} must be a cursor returned by the CMS.`);
+            }
+            params.set(direction, boundary);
+        }
+    }
+    if (options.filters !== undefined) {
+        validateFilters(options.filters);
+        const encoded = JSON.stringify(options.filters);
+        if (new TextEncoder().encode(encoded).length > 4096)
+            throw new TypeError("filters exceed 4 KiB.");
+        params.set("filters", encoded);
+    }
+    if (options.search !== undefined) {
+        const search = options.search;
+        if (!record(search) || Object.keys(search).some(key => !["query", "fields"].includes(key)) ||
+            typeof search.query !== "string" || search.query.includes("\0") ||
+            new TextEncoder().encode(search.query).length > 512 || Array.from(search.query.trim()).length < 1 ||
+            Array.from(search.query.trim()).length > 200 || search.query.trim().split(/\s+/u).length > 16 ||
+            search.fields !== undefined && (!Array.isArray(search.fields) || search.fields.length < 1 || search.fields.length > 24 ||
+                new Set(search.fields).size !== search.fields.length || !Array.from(search.fields).every(key => typeof key === "string" && identifier.test(key)))) {
+            throw new TypeError("search requires 1–200 characters/512 UTF-8 bytes, at most 16 terms, and optionally 1–24 unique text field keys.");
+        }
+        params.set("search", JSON.stringify({ query: search.query.trim(), ...(search.fields !== undefined ? { fields: search.fields } : {}) }));
+    }
+    if (options.sort !== undefined) {
+        const orders = Array.isArray(options.sort) ? options.sort : [options.sort];
+        if (orders.length < 1 || orders.length > 3 || !Array.from(orders).every(order => record(order) && Object.keys(order).sort().join(",") === "direction,field" &&
+            typeof order.field === "string" && identifier.test(order.field) && ["asc", "desc"].includes(String(order.direction))) ||
+            new Set(orders.map(order => order.field)).size !== orders.length)
+            throw new TypeError("sort requires 1–3 unique scalar fields and asc/desc directions.");
+        params.set("sort", JSON.stringify(options.sort));
+    }
+    return params;
+}
+// Network responses start as unknown even in TypeScript. Check structural
+// properties before returning them, and translate HTTP snake_case metadata into
+// SDK camelCase. This does not validate the caller-declared model field types.
+function decodePage(value, projectId, model, locale) {
+    if (!record(value) || !Array.isArray(value.data) || !record(value.meta) ||
+        typeof value.meta.limit !== "number" || !Number.isInteger(value.meta.limit) ||
+        value.meta.limit < 1 || value.meta.limit > 100 || value.data.length > value.meta.limit ||
+        !(value.meta.next_cursor === null || (typeof value.meta.next_cursor === "string" && cursor(value.meta.next_cursor)))) {
+        throw new CMSResponseError("CMS returned an invalid content page.");
+    }
+    const data = value.data.map(entry => decodeEntry(entry, projectId, model, locale));
+    const meta = { limit: value.meta.limit, nextCursor: value.meta.next_cursor };
+    if (value.meta.page !== undefined || value.meta.page_size !== undefined) {
+        if (typeof value.meta.page !== "number" || !Number.isInteger(value.meta.page) || value.meta.page < 1 || value.meta.page_size !== value.meta.limit || (value.meta.page - 1) * value.meta.limit > 10000)
+            throw new CMSResponseError("CMS returned invalid numbered pagination metadata.");
+        meta.page = value.meta.page;
+        meta.pageSize = value.meta.limit;
+    }
+    // Additive metadata is optional for older installations. When supplied, check
+    // it rather than silently treating a malformed boundary as the end of a list.
+    if (value.meta.previous_cursor !== undefined) {
+        if (!(value.meta.previous_cursor === null || typeof value.meta.previous_cursor === "string" && cursor(value.meta.previous_cursor)))
+            throw new CMSResponseError("CMS returned an invalid previous cursor.");
+        meta.previousCursor = value.meta.previous_cursor;
+    }
+    for (const [wire, sdk] of [["has_next_page", "hasNextPage"], ["has_previous_page", "hasPreviousPage"]]) {
+        if (value.meta[wire] !== undefined) {
+            if (typeof value.meta[wire] !== "boolean")
+                throw new CMSResponseError("CMS returned invalid pagination metadata.");
+            meta[sdk] = value.meta[wire];
+        }
+    }
+    if (meta.hasNextPage !== undefined && meta.hasNextPage !== (meta.nextCursor !== null) ||
+        meta.hasPreviousPage !== undefined && meta.previousCursor !== undefined && meta.hasPreviousPage !== (meta.previousCursor !== null)) {
+        throw new CMSResponseError("CMS returned inconsistent pagination metadata.");
+    }
+    return { data, meta };
+}
+function decodeEntry(entry, projectId, model, locale) {
+    if (!record(entry) || typeof entry.id !== "string" || !uuid.test(entry.id) || !record(entry.fields) ||
+        !(entry.published_at === null || typeof entry.published_at === "string"))
+        throw new CMSResponseError("CMS returned an invalid content entry.");
+    const result = {
+        id: entry.id, fields: entry.fields, publishedAt: entry.published_at,
+        projectId, contentType: { key: model },
+    };
+    // Old servers omit this metadata. Retain only known request identity until
+    // the server supplies the rest; never infer an environment from a credential.
+    if (entry.project_id !== undefined &&
+        (typeof entry.project_id !== "string" || entry.project_id.toLowerCase() !== projectId.toLowerCase())) {
+        throw new CMSResponseError("CMS returned conflicting workspace metadata.");
+    }
+    if (entry.content_type !== undefined) {
+        const type = entry.content_type;
+        if (!record(type) || typeof type.id !== "string" || !uuid.test(type.id) ||
+            type.key !== model || typeof type.name !== "string" || !type.name.trim()) {
+            throw new CMSResponseError("CMS returned invalid content-type metadata.");
+        }
+        result.contentType = { id: type.id, key: model, name: type.name };
+    }
+    if (entry.environment !== undefined) {
+        const environment = entry.environment;
+        if (!record(environment) || typeof environment.id !== "string" || !uuid.test(environment.id) ||
+            typeof environment.key !== "string" || !/^[a-z][a-z0-9_-]{0,31}$/.test(environment.key)) {
+            throw new CMSResponseError("CMS returned invalid environment metadata.");
+        }
+        result.environment = { id: environment.id, key: environment.key };
+    }
+    if (entry.locale !== undefined) {
+        if (typeof entry.locale !== "string" || !localeTag.test(entry.locale) || locale !== undefined && entry.locale !== locale) {
+            throw new CMSResponseError("CMS returned invalid locale metadata.");
+        }
+        result.locale = entry.locale;
+    }
+    else if (locale !== undefined)
+        result.locale = locale;
+    if (entry.remote !== undefined) {
+        const remote = entry.remote;
+        if (remote === null)
+            result.remote = null;
+        else {
+            if (!record(remote) || !["available", "error", "disabled", "not_linked"].includes(String(remote.status)) ||
+                remote.read_only !== true || typeof remote.stale !== "boolean" || typeof remote.source !== "string" ||
+                !(remote.error === null || typeof remote.error === "string") ||
+                !(remote.fetched_at === null || typeof remote.fetched_at === "string") ||
+                !(remote.expires_at === null || typeof remote.expires_at === "string") ||
+                !(remote.data === null || record(remote.data) && Object.values(remote.data).every(v => v === null ||
+                    typeof v === "string" || typeof v === "boolean" || typeof v === "number" && Number.isFinite(v)))) {
+                throw new CMSResponseError("CMS returned invalid remote metadata.");
+            }
+            result.remote = { source: remote.source, status: remote.status,
+                readOnly: true, stale: remote.stale, data: remote.data,
+                error: remote.error, fetchedAt: remote.fetched_at, expiresAt: remote.expires_at };
+        }
+    }
+    return result;
+}
+/** Internal shared transport; public exports choose the credential and route. */
+export function createTransport(options, key, mode) {
+    if (!record(options)) {
+        throw new CMSConfigurationError("CMS client options must be an object.");
+    }
+    // Reject old host configuration rather than silently sending a developer's
+    // credentials to production. Check inherited options too: spreads and plain
+    // JavaScript callers must receive the same migration error as TypeScript.
+    if (["url", "baseURL", "baseUrl", "host", "endpoint"].some(option => option in options)) {
+        throw new CMSConfigurationError("CMS clients connect to https://lemonadecms.com. Remove custom URL configuration.");
+    }
+    const credential = mode === "content" ? "publicKey" : "secretKey";
+    if (Object.keys(options).some(option => !["projectId", credential, "fetch", "timeoutMs"].includes(option)) || "environment" in options) {
+        throw new CMSConfigurationError("Supported CMS options are projectId, the delivery key, fetch and timeoutMs. Select a content environment with its delivery key.");
+    }
+    const timeoutMs = options.timeoutMs;
+    if (timeoutMs !== undefined && (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647)) {
+        throw new CMSConfigurationError("CMS timeoutMs must be an integer between 1 and 2147483647 milliseconds.");
+    }
+    if (typeof options.projectId !== "string" || !uuid.test(options.projectId)) {
+        throw new CMSConfigurationError("CMS projectId is required and must be a UUID.");
+    }
+    // Each factory chooses its credential kind. Prefix and length detect mistakes
+    // early; only the backend can verify whether the credential is currently valid.
+    const prefix = mode === "content" ? "pk" : "sk";
+    // Named tokens retain a visible public/preview distinction. The server owns
+    // scope and revocation checks; the browser factory still rejects preview keys.
+    const scoped = new RegExp(`^lmd_${prefix}_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\\.[A-Za-z0-9_-]{43}$`);
+    if (typeof key !== "string" || (!new RegExp(`^${prefix}_[A-Za-z0-9_-]{43}$`).test(key) && !scoped.test(key))) {
+        throw new CMSConfigurationError(mode === "content"
+            ? "A valid publicKey (pk_ or lmd_pk_) is required. Never pass a secret key to the browser client."
+            : "A valid secretKey (sk_ or lmd_sk_) is required for the server preview client.");
+    }
+    // Dependency injection supports framework server contexts and deterministic tests
+    // without coupling the client to Vue, React, or a particular HTTP library.
+    const fetcher = options.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (typeof fetcher !== "function") {
+        throw new CMSConfigurationError("This environment needs fetch; supply a compatible fetch implementation.");
+    }
+    const projectId = options.projectId;
+    const endpoint = `${serviceURL}/api/v1/projects/${projectId}/${mode}`;
+    return {
+        content(model) {
+            if (typeof model !== "string" || !identifier.test(model)) {
+                throw new TypeError("Content type must be a lowercase model identifier.");
+            }
+            return {
+                async list(options = {}) {
+                    return await request(options);
+                },
+                async search(text, options = {}) {
+                    if (!record(options) || "search" in options)
+                        throw new TypeError("search accepts a query string and list options with optional fields.");
+                    const { fields, ...list } = options;
+                    return await request({ ...list, search: { query: text, ...(fields !== undefined ? { fields } : {}) } });
+                },
+                async findOne(options = {}) {
+                    return await firstMatch(options);
+                },
+                async findOneOrThrow(options = {}) {
+                    const entry = await firstMatch(options);
+                    if (entry === null)
+                        throw new CMSNotFoundError(model);
+                    return entry;
+                },
+                async count(options = {}) {
+                    return await statistic("count", options);
+                },
+                async exists(options = {}) {
+                    return await statistic("exists", options);
+                },
+                async getMany(ids, options = {}) {
+                    readOptions(options, ["select", "locale", "signal", "includeRemote"], "getMany");
+                    if (!Array.isArray(ids) || ids.length > 100 || !Array.from(ids).every(id => typeof id === "string" && uuid.test(id))) {
+                        throw new TypeError("getMany ids must contain at most 100 entry UUIDs.");
+                    }
+                    query(options);
+                    options.signal?.throwIfAborted();
+                    const ordered = ids.map(id => id.toLowerCase());
+                    if (ordered.length === 0)
+                        return [];
+                    const requested = new Set(ordered);
+                    const requestedLocale = options.locale;
+                    return await send(options, "/_many", body => {
+                        if (!record(body) || !Array.isArray(body.data) || body.data.length > requested.size) {
+                            throw new CMSResponseError("CMS returned an invalid bulk response.");
+                        }
+                        const entries = new Map();
+                        for (const value of body.data) {
+                            const entry = decodeEntry(value, projectId, model, requestedLocale);
+                            const id = entry.id.toLowerCase();
+                            if (!requested.has(id) || entries.has(id))
+                                throw new CMSResponseError("CMS returned unexpected or duplicate bulk entries.");
+                            entries.set(id, entry);
+                        }
+                        return ordered.map(id => entries.get(id) ?? null);
+                    }, [...requested]);
+                },
+                pages(options = {}) {
+                    return iteratePages(options);
+                },
+                async *entries(options = {}) {
+                    const signal = options?.signal;
+                    for await (const page of iteratePages(options)) {
+                        for (const entry of page.data) {
+                            signal?.throwIfAborted();
+                            yield entry;
+                        }
+                    }
+                },
+                async get(id, options = {}) {
+                    if (typeof id !== "string" || !uuid.test(id))
+                        throw new TypeError("id must be an entry UUID.");
+                    if (!record(options) || Object.keys(options).some(k => !["select", "locale", "signal", "includeRemote"].includes(k)))
+                        throw new TypeError("get supports select, locale, includeRemote and signal.");
+                    return await request(options, id);
+                },
+            };
+            async function firstMatch(options) {
+                readOptions(options, ["select", "locale", "filters", "sort", "search", "signal", "includeRemote"], "findOne/findOneOrThrow");
+                const page = await request({ ...options, limit: 1 });
+                if (page.meta.limit !== 1)
+                    throw new CMSResponseError("CMS returned an invalid single-match page.");
+                return (page.data[0] ?? null);
+            }
+            async function statistic(operation, options) {
+                readOptions(options, ["locale", "filters", "search", "signal"], operation);
+                return await send(options, `/_${operation}`, body => {
+                    if (!record(body) || !record(body.data))
+                        throw new CMSResponseError("CMS returned an invalid statistic.");
+                    const value = body.data[operation];
+                    if (operation === "count" ? typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 : typeof value !== "boolean") {
+                        throw new CMSResponseError("CMS returned an invalid statistic.");
+                    }
+                    return value;
+                });
+            }
+            // No eager fetch or prefetch: the iterator asks for a page only after the
+            // previous yield is consumed. A break/error closes it without more requests.
+            async function* iteratePages(options = {}) {
+                if (!record(options) || "before" in options || "page" in options || "pageSize" in options)
+                    throw new TypeError("pages/entries support forward traversal with after.");
+                const { maxPages = 1000, ...list } = options;
+                if (!Number.isInteger(maxPages) || maxPages < 1 || maxPages > 10000)
+                    throw new TypeError("maxPages must be an integer between 1 and 10000.");
+                query(list);
+                // Freeze query semantics at first consumption; callers can reuse/mutate
+                // their form state without changing a traversal halfway through.
+                const { signal, ...serializable } = list;
+                const snapshot = { ...JSON.parse(JSON.stringify(serializable)), ...(signal ? { signal } : {}) };
+                let after = snapshot.after;
+                const seen = new Set(after ? [after] : []);
+                for (let count = 0; count < maxPages; count++) {
+                    signal?.throwIfAborted();
+                    const page = await request({ ...snapshot, ...(after ? { after } : {}) });
+                    const next = page.meta.nextCursor;
+                    if (next !== null && seen.has(next))
+                        throw new CMSResponseError("CMS returned a repeated pagination cursor.");
+                    yield page;
+                    if (next === null)
+                        return;
+                    if (count + 1 === maxPages)
+                        throw new RangeError("Pagination reached maxPages; resume with the last nextCursor or raise the limit.");
+                    seen.add(next);
+                    after = next;
+                }
+            }
+            async function request(options, id) {
+                const requestedLocale = options.locale;
+                return await send(options, id ? `/${id}` : "", body => {
+                    if (id) {
+                        if (!record(body))
+                            throw new CMSResponseError("CMS returned an invalid content item.");
+                        const entry = decodeEntry(body.data, projectId, model, requestedLocale);
+                        if (entry.id.toLowerCase() !== id.toLowerCase())
+                            throw new CMSResponseError("CMS returned a different entry than requested.");
+                        return entry;
+                    }
+                    return decodePage(body, projectId, model, requestedLocale);
+                });
+            }
+            async function send(options, path, decode, ids) {
+                const params = query(options);
+                if (ids)
+                    params.set("ids", ids.join(","));
+                const suffix = params.size ? `?${params}` : "";
+                return withinDeadline(timeoutMs, options.signal, async (signal) => {
+                    const checkCancellation = () => {
+                        signal?.throwIfAborted();
+                        options.signal?.throwIfAborted();
+                    };
+                    checkCancellation();
+                    // Use only bearer authorization: omit browser cookies, refuse redirects that
+                    // could change the destination, and request fresh data. Abort and network errors
+                    // propagate to the caller; this client does not silently retry a request.
+                    const response = await fetcher(`${endpoint}/${model}${path}${suffix}`, {
+                        method: "GET",
+                        headers: { Accept: "application/json", Authorization: `Bearer ${key}` },
+                        credentials: "omit",
+                        redirect: "error",
+                        cache: "no-store",
+                        ...(signal ? { signal } : {}),
+                    });
+                    checkCancellation();
+                    let body;
+                    try {
+                        body = await response.json();
+                    }
+                    catch (error) {
+                        checkCancellation();
+                        if (error instanceof Error && error.name === "AbortError")
+                            throw error;
+                        if (response.ok)
+                            throw new CMSResponseError("CMS returned invalid JSON.");
+                    }
+                    checkCancellation();
+                    // An unsuccessful HTTP status becomes CMSRequestError, even if the response
+                    // was not JSON. A successful response with malformed JSON instead signals a
+                    // response-contract error. Consumers can distinguish these failure categories.
+                    if (!response.ok) {
+                        throw new CMSRequestError(record(body) && typeof body.error === "string" ? body.error : `CMS request failed (${response.status}).`, response.status, record(body) && typeof body.code === "string" ? body.code : "http_error");
+                    }
+                    // Validate the envelope at runtime. Model field types are the caller's
+                    // declaration until schema-generated types/runtime validators exist.
+                    return decode(body);
+                });
+            }
+        },
+    };
+}