@uniformdev/canvas 20.50.2-alpha.149 → 20.50.2-alpha.167

package/dist/index.mjs

@@ -1,560 +1,25 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 
-// ../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js
-var require_yocto_queue = __commonJS({
-  "../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js"(exports, module) {
-    "use strict";
-    var Node = class {
-      /// value;
-      /// next;
-      constructor(value) {
-        this.value = value;
-        this.next = void 0;
-      }
-    };
-    var Queue = class {
-      // TODO: Use private class fields when targeting Node.js 12.
-      // #_head;
-      // #_tail;
-      // #_size;
-      constructor() {
-        this.clear();
-      }
-      enqueue(value) {
-        const node = new Node(value);
-        if (this._head) {
-          this._tail.next = node;
-          this._tail = node;
-        } else {
-          this._head = node;
-          this._tail = node;
-        }
-        this._size++;
-      }
-      dequeue() {
-        const current = this._head;
-        if (!current) {
-          return;
-        }
-        this._head = this._head.next;
-        this._size--;
-        return current.value;
-      }
-      clear() {
-        this._head = void 0;
-        this._tail = void 0;
-        this._size = 0;
-      }
-      get size() {
-        return this._size;
-      }
-      *[Symbol.iterator]() {
-        let current = this._head;
-        while (current) {
-          yield current.value;
-          current = current.next;
-        }
-      }
-    };
-    module.exports = Queue;
-  }
-});
-
-// ../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js
-var require_p_limit = __commonJS({
-  "../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js"(exports, module) {
-    "use strict";
-    var Queue = require_yocto_queue();
-    var pLimit2 = (concurrency) => {
-      if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
-        throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-      }
-      const queue = new Queue();
-      let activeCount = 0;
-      const next = () => {
-        activeCount--;
-        if (queue.size > 0) {
-          queue.dequeue()();
-        }
-      };
-      const run = async (fn, resolve, ...args) => {
-        activeCount++;
-        const result = (async () => fn(...args))();
-        resolve(result);
-        try {
-          await result;
-        } catch (e) {
-        }
-        next();
-      };
-      const enqueue = (fn, resolve, ...args) => {
-        queue.enqueue(run.bind(null, fn, resolve, ...args));
-        (async () => {
-          await Promise.resolve();
-          if (activeCount < concurrency && queue.size > 0) {
-            queue.dequeue()();
-          }
-        })();
-      };
-      const generator = (fn, ...args) => new Promise((resolve) => {
-        enqueue(fn, resolve, ...args);
-      });
-      Object.defineProperties(generator, {
-        activeCount: {
-          get: () => activeCount
-        },
-        pendingCount: {
-          get: () => queue.size
-        },
-        clearQueue: {
-          value: () => {
-            queue.clear();
-          }
-        }
-      });
-      return generator;
-    };
-    module.exports = pLimit2;
-  }
-});
-
-// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js
-var require_retry_operation = __commonJS({
-  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports, module) {
-    "use strict";
-    function RetryOperation(timeouts, options) {
-      if (typeof options === "boolean") {
-        options = { forever: options };
-      }
-      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
-      this._timeouts = timeouts;
-      this._options = options || {};
-      this._maxRetryTime = options && options.maxRetryTime || Infinity;
-      this._fn = null;
-      this._errors = [];
-      this._attempts = 1;
-      this._operationTimeout = null;
-      this._operationTimeoutCb = null;
-      this._timeout = null;
-      this._operationStart = null;
-      this._timer = null;
-      if (this._options.forever) {
-        this._cachedTimeouts = this._timeouts.slice(0);
-      }
-    }
-    module.exports = RetryOperation;
-    RetryOperation.prototype.reset = function() {
-      this._attempts = 1;
-      this._timeouts = this._originalTimeouts.slice(0);
-    };
-    RetryOperation.prototype.stop = function() {
-      if (this._timeout) {
-        clearTimeout(this._timeout);
-      }
-      if (this._timer) {
-        clearTimeout(this._timer);
-      }
-      this._timeouts = [];
-      this._cachedTimeouts = null;
-    };
-    RetryOperation.prototype.retry = function(err) {
-      if (this._timeout) {
-        clearTimeout(this._timeout);
-      }
-      if (!err) {
-        return false;
-      }
-      var currentTime = (/* @__PURE__ */ new Date()).getTime();
-      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
-        this._errors.push(err);
-        this._errors.unshift(new Error("RetryOperation timeout occurred"));
-        return false;
-      }
-      this._errors.push(err);
-      var timeout = this._timeouts.shift();
-      if (timeout === void 0) {
-        if (this._cachedTimeouts) {
-          this._errors.splice(0, this._errors.length - 1);
-          timeout = this._cachedTimeouts.slice(-1);
-        } else {
-          return false;
-        }
-      }
-      var self = this;
-      this._timer = setTimeout(function() {
-        self._attempts++;
-        if (self._operationTimeoutCb) {
-          self._timeout = setTimeout(function() {
-            self._operationTimeoutCb(self._attempts);
-          }, self._operationTimeout);
-          if (self._options.unref) {
-            self._timeout.unref();
-          }
-        }
-        self._fn(self._attempts);
-      }, timeout);
-      if (this._options.unref) {
-        this._timer.unref();
-      }
-      return true;
-    };
-    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
-      this._fn = fn;
-      if (timeoutOps) {
-        if (timeoutOps.timeout) {
-          this._operationTimeout = timeoutOps.timeout;
-        }
-        if (timeoutOps.cb) {
-          this._operationTimeoutCb = timeoutOps.cb;
-        }
-      }
-      var self = this;
-      if (this._operationTimeoutCb) {
-        this._timeout = setTimeout(function() {
-          self._operationTimeoutCb();
-        }, self._operationTimeout);
-      }
-      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
-      this._fn(this._attempts);
-    };
-    RetryOperation.prototype.try = function(fn) {
-      console.log("Using RetryOperation.try() is deprecated");
-      this.attempt(fn);
-    };
-    RetryOperation.prototype.start = function(fn) {
-      console.log("Using RetryOperation.start() is deprecated");
-      this.attempt(fn);
-    };
-    RetryOperation.prototype.start = RetryOperation.prototype.try;
-    RetryOperation.prototype.errors = function() {
-      return this._errors;
-    };
-    RetryOperation.prototype.attempts = function() {
-      return this._attempts;
-    };
-    RetryOperation.prototype.mainError = function() {
-      if (this._errors.length === 0) {
-        return null;
-      }
-      var counts = {};
-      var mainError = null;
-      var mainErrorCount = 0;
-      for (var i = 0; i < this._errors.length; i++) {
-        var error = this._errors[i];
-        var message = error.message;
-        var count = (counts[message] || 0) + 1;
-        counts[message] = count;
-        if (count >= mainErrorCount) {
-          mainError = error;
-          mainErrorCount = count;
-        }
-      }
-      return mainError;
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js
-var require_retry = __commonJS({
-  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js"(exports) {
-    "use strict";
-    var RetryOperation = require_retry_operation();
-    exports.operation = function(options) {
-      var timeouts = exports.timeouts(options);
-      return new RetryOperation(timeouts, {
-        forever: options && (options.forever || options.retries === Infinity),
-        unref: options && options.unref,
-        maxRetryTime: options && options.maxRetryTime
-      });
-    };
-    exports.timeouts = function(options) {
-      if (options instanceof Array) {
-        return [].concat(options);
-      }
-      var opts = {
-        retries: 10,
-        factor: 2,
-        minTimeout: 1 * 1e3,
-        maxTimeout: Infinity,
-        randomize: false
-      };
-      for (var key in options) {
-        opts[key] = options[key];
-      }
-      if (opts.minTimeout > opts.maxTimeout) {
-        throw new Error("minTimeout is greater than maxTimeout");
-      }
-      var timeouts = [];
-      for (var i = 0; i < opts.retries; i++) {
-        timeouts.push(this.createTimeout(i, opts));
-      }
-      if (options && options.forever && !timeouts.length) {
-        timeouts.push(this.createTimeout(i, opts));
-      }
-      timeouts.sort(function(a, b) {
-        return a - b;
-      });
-      return timeouts;
-    };
-    exports.createTimeout = function(attempt, opts) {
-      var random = opts.randomize ? Math.random() + 1 : 1;
-      var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
-      timeout = Math.min(timeout, opts.maxTimeout);
-      return timeout;
-    };
-    exports.wrap = function(obj, options, methods) {
-      if (options instanceof Array) {
-        methods = options;
-        options = null;
-      }
-      if (!methods) {
-        methods = [];
-        for (var key in obj) {
-          if (typeof obj[key] === "function") {
-            methods.push(key);
-          }
-        }
-      }
-      for (var i = 0; i < methods.length; i++) {
-        var method = methods[i];
-        var original = obj[method];
-        obj[method] = function retryWrapper(original2) {
-          var op = exports.operation(options);
-          var args = Array.prototype.slice.call(arguments, 1);
-          var callback = args.pop();
-          args.push(function(err) {
-            if (op.retry(err)) {
-              return;
-            }
-            if (err) {
-              arguments[0] = op.mainError();
-            }
-            callback.apply(this, arguments);
-          });
-          op.attempt(function() {
-            original2.apply(obj, args);
-          });
-        }.bind(obj, original);
-        obj[method].options = options;
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js
-var require_retry2 = __commonJS({
-  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js"(exports, module) {
-    "use strict";
-    module.exports = require_retry();
-  }
-});
-
-// src/CanvasClient.ts
-import { ApiClient, rewriteFiltersForApi } from "@uniformdev/context/api";
+// src/CategoryClient.ts
+import { ApiClient } from "@uniformdev/context/api";
 
 // src/enhancement/createLimitPolicy.ts
-var import_p_limit = __toESM(require_p_limit());
 import { ApiClientError } from "@uniformdev/context/api";
-
-// ../../node_modules/.pnpm/p-retry@5.1.2/node_modules/p-retry/index.js
-var import_retry = __toESM(require_retry2(), 1);
-var networkErrorMsgs = /* @__PURE__ */ new Set([
-  "Failed to fetch",
-  // Chrome
-  "NetworkError when attempting to fetch resource.",
-  // Firefox
-  "The Internet connection appears to be offline.",
-  // Safari
-  "Network request failed",
-  // `cross-fetch`
-  "fetch failed"
-  // Undici (Node.js)
-]);
-var AbortError = class extends Error {
-  constructor(message) {
-    super();
-    if (message instanceof Error) {
-      this.originalError = message;
-      ({ message } = message);
-    } else {
-      this.originalError = new Error(message);
-      this.originalError.stack = this.stack;
-    }
-    this.name = "AbortError";
-    this.message = message;
-  }
-};
-var decorateErrorWithCounts = (error, attemptNumber, options) => {
-  const retriesLeft = options.retries - (attemptNumber - 1);
-  error.attemptNumber = attemptNumber;
-  error.retriesLeft = retriesLeft;
-  return error;
-};
-var isNetworkError = (errorMessage) => networkErrorMsgs.has(errorMessage);
-var getDOMException = (errorMessage) => globalThis.DOMException === void 0 ? new Error(errorMessage) : new DOMException(errorMessage);
-async function pRetry(input, options) {
-  return new Promise((resolve, reject) => {
-    options = {
-      onFailedAttempt() {
-      },
-      retries: 10,
-      ...options
-    };
-    const operation = import_retry.default.operation(options);
-    operation.attempt(async (attemptNumber) => {
-      try {
-        resolve(await input(attemptNumber));
-      } catch (error) {
-        if (!(error instanceof Error)) {
-          reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
-          return;
-        }
-        if (error instanceof AbortError) {
-          operation.stop();
-          reject(error.originalError);
-        } else if (error instanceof TypeError && !isNetworkError(error.message)) {
-          operation.stop();
-          reject(error);
-        } else {
-          decorateErrorWithCounts(error, attemptNumber, options);
-          try {
-            await options.onFailedAttempt(error);
-          } catch (error2) {
-            reject(error2);
-            return;
-          }
-          if (!operation.retry(error)) {
-            reject(operation.mainError());
-          }
-        }
-      }
-    });
-    if (options.signal && !options.signal.aborted) {
-      options.signal.addEventListener("abort", () => {
-        operation.stop();
-        const reason = options.signal.reason === void 0 ? getDOMException("The operation was aborted.") : options.signal.reason;
-        reject(reason instanceof Error ? reason : getDOMException(reason));
-      }, {
-        once: true
-      });
-    }
-  });
-}
-
-// ../../node_modules/.pnpm/p-throttle@5.0.0/node_modules/p-throttle/index.js
-var AbortError2 = class extends Error {
-  constructor() {
-    super("Throttled function aborted");
-    this.name = "AbortError";
-  }
-};
-function pThrottle({ limit, interval, strict }) {
-  if (!Number.isFinite(limit)) {
-    throw new TypeError("Expected `limit` to be a finite number");
-  }
-  if (!Number.isFinite(interval)) {
-    throw new TypeError("Expected `interval` to be a finite number");
-  }
-  const queue = /* @__PURE__ */ new Map();
-  let currentTick = 0;
-  let activeCount = 0;
-  function windowedDelay() {
-    const now = Date.now();
-    if (now - currentTick > interval) {
-      activeCount = 1;
-      currentTick = now;
-      return 0;
-    }
-    if (activeCount < limit) {
-      activeCount++;
-    } else {
-      currentTick += interval;
-      activeCount = 1;
-    }
-    return currentTick - now;
-  }
-  const strictTicks = [];
-  function strictDelay() {
-    const now = Date.now();
-    if (strictTicks.length < limit) {
-      strictTicks.push(now);
-      return 0;
-    }
-    const earliestTime = strictTicks.shift() + interval;
-    if (now >= earliestTime) {
-      strictTicks.push(now);
-      return 0;
-    }
-    strictTicks.push(earliestTime);
-    return earliestTime - now;
-  }
-  const getDelay = strict ? strictDelay : windowedDelay;
-  return (function_) => {
-    const throttled = function(...args) {
-      if (!throttled.isEnabled) {
-        return (async () => function_.apply(this, args))();
-      }
-      let timeout;
-      return new Promise((resolve, reject) => {
-        const execute = () => {
-          resolve(function_.apply(this, args));
-          queue.delete(timeout);
-        };
-        timeout = setTimeout(execute, getDelay());
-        queue.set(timeout, reject);
-      });
-    };
-    throttled.abort = () => {
-      for (const timeout of queue.keys()) {
-        clearTimeout(timeout);
-        queue.get(timeout)(new AbortError2());
-      }
-      queue.clear();
-      strictTicks.splice(0, strictTicks.length);
-    };
-    throttled.isEnabled = true;
-    return throttled;
-  };
-}
-
-// src/enhancement/createLimitPolicy.ts
+import pLimit from "p-limit";
+import pRetry from "p-retry";
+import pThrottle from "p-throttle";
 function createLimitPolicy({
   throttle = { interval: 1e3, limit: 10 },
-  retry: retry2 = { retries: 1, factor: 1.66 },
+  retry = { retries: 1, factor: 1.66 },
   limit = 10
 }) {
   const throttler = throttle ? pThrottle(throttle) : null;
-  const limiter = limit ? (0, import_p_limit.default)(limit) : null;
+  const limiter = limit ? pLimit(limit) : null;
   return function limitPolicy(func) {
     let currentFunc = async () => await func();
     if (throttler) {
@@ -565,13 +30,13 @@ function createLimitPolicy({
       const limitFunc = currentFunc;
       currentFunc = () => limiter(limitFunc);
     }
-    if (retry2) {
+    if (retry) {
       const retryFunc = currentFunc;
       currentFunc = () => pRetry(retryFunc, {
-        ...retry2,
+        ...retry,
         onFailedAttempt: async (error) => {
-          if (retry2.onFailedAttempt) {
-            await retry2.onFailedAttempt(error);
+          if (retry.onFailedAttempt) {
+            await retry.onFailedAttempt(error);
           }
           if (error instanceof ApiClientError && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
             throw error;
@@ -584,9 +49,697 @@ function createLimitPolicy({
 }
 var nullLimitPolicy = async (func) => await func();
 
-// src/CanvasClient.ts
-var CANVAS_URL = "/api/v1/canvas";
-var CanvasClient = class extends ApiClient {
+// src/CategoryClient.ts
+var CATEGORIES_URL = "/api/v1/categories";
+var CategoryClient = class extends ApiClient {
+  constructor(options) {
+    if (!options.limitPolicy) {
+      options.limitPolicy = createLimitPolicy({});
+    }
+    super(options);
+  }
+  /** Fetches a list of categories created in given project */
+  async list(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl("/api/v1/categories", { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** @deprecated Use {@link list} instead. */
+  async getCategories(options) {
+    return this.list(options);
+  }
+  /** Updates or creates a category, also used to re-order them */
+  async save(categories) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(CATEGORIES_URL);
+    return await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ categories, projectId }),
+      expectNoContent: true
+    });
+  }
+  /** @deprecated Use {@link save} instead. */
+  async upsertCategories(categories) {
+    return this.save(categories);
+  }
+  /** Deletes a category */
+  async remove(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(CATEGORIES_URL);
+    return await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ projectId, categoryId: options.categoryId }),
+      expectNoContent: true
+    });
+  }
+  /** @deprecated Use {@link remove} instead. */
+  async removeCategory(options) {
+    return this.remove(options);
+  }
+};
+var UncachedCategoryClient = class extends CategoryClient {
+  constructor(options) {
+    super({ ...options, bypassCache: true });
+  }
+};
+
+// src/clients/ComponentDefinitionClient.ts
+import { ApiClientError as ApiClientError2 } from "@uniformdev/context/api";
+
+// src/clients/ContentClientBase.ts
+import { ApiClient as ApiClient2 } from "@uniformdev/context/api";
+var CANONICAL_FORMAT = "canonical";
+var ContentClientBase = class extends ApiClient2 {
+  constructor(options, defaultBypassCache) {
+    var _a, _b;
+    super({
+      ...options,
+      limitPolicy: (_a = options.limitPolicy) != null ? _a : createLimitPolicy({}),
+      bypassCache: (_b = options.bypassCache) != null ? _b : defaultBypassCache
+    });
+  }
+};
+
+// src/clients/ComponentDefinitionClient.ts
+var DEFINITIONS_URL = "/api/v1/canvas-definitions";
+var ComponentDefinitionClient = class extends ContentClientBase {
+  constructor(options) {
+    super(
+      options,
+      /* defaultBypassCache */
+      true
+    );
+  }
+  /** Fetches one component definition by id (throws `ApiClientError(404)` if absent). */
+  async get(args) {
+    var _a;
+    const url = this.createUrl(DEFINITIONS_URL, {
+      componentId: args.componentId,
+      projectId: this.options.projectId
+    });
+    const res = await this.apiClient(url);
+    const definition = (_a = res.componentDefinitions) == null ? void 0 : _a[0];
+    if (!definition) {
+      throw new ApiClientError2("Component definition not found", "GET", url.toString(), 404, "Not Found");
+    }
+    return definition;
+  }
+  /** Fetches a list of component definitions. */
+  list(args) {
+    const url = this.createUrl(DEFINITIONS_URL, { ...args, projectId: this.options.projectId });
+    return this.apiClient(url);
+  }
+  /** Creates or updates a component definition. */
+  async save(def) {
+    const url = this.createUrl(DEFINITIONS_URL);
+    await this.apiClient(url, {
+      method: "PUT",
+      body: JSON.stringify({ ...def, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes a component definition. */
+  async remove(args) {
+    const url = this.createUrl(DEFINITIONS_URL);
+    await this.apiClient(url, {
+      method: "DELETE",
+      body: JSON.stringify({ ...args, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+
+// src/clients/CompositionDeliveryClient.ts
+import { rewriteFiltersForApi } from "@uniformdev/context/api";
+
+// src/projection/types.ts
+var SELECT_QUERY_PREFIX = "select.";
+
+// src/projection/projectionToQuery.ts
+function appendCsv(out, key, values) {
+  if (values === void 0) {
+    return;
+  }
+  out[key] = values.join(",");
+}
+function projectionToQuery(spec) {
+  const out = {};
+  if (!spec) {
+    return out;
+  }
+  const { fields, fieldTypes, slots } = spec;
+  const p = SELECT_QUERY_PREFIX;
+  if (fields) {
+    appendCsv(out, `${p}fields[only]`, fields.only);
+    appendCsv(out, `${p}fields[except]`, fields.except);
+    appendCsv(out, `${p}fields[locales]`, fields.locales);
+  }
+  if (fieldTypes) {
+    appendCsv(out, `${p}fieldTypes[only]`, fieldTypes.only);
+    appendCsv(out, `${p}fieldTypes[except]`, fieldTypes.except);
+  }
+  if (slots) {
+    appendCsv(out, `${p}slots[only]`, slots.only);
+    appendCsv(out, `${p}slots[except]`, slots.except);
+    if (typeof slots.depth === "number") {
+      out[`${p}slots[depth]`] = String(slots.depth);
+    }
+    if (slots.named) {
+      const slotNames = Object.keys(slots.named).sort();
+      for (const slotName of slotNames) {
+        const named = slots.named[slotName];
+        if (named && typeof named.depth === "number") {
+          out[`${p}slots.${slotName}[depth]`] = String(named.depth);
+        }
+      }
+    }
+  }
+  return out;
+}
+
+// src/utils/constants.ts
+var CANVAS_PERSONALIZE_TYPE = "$personalization";
+var CANVAS_TEST_TYPE = "$test";
+var CANVAS_LOCALIZATION_TYPE = "$localization";
+var CANVAS_SLOT_SECTION_TYPE = "$slotSection";
+var CANVAS_INTENT_TAG_PARAM = "intentTag";
+var CANVAS_LOCALE_TAG_PARAM = "locale";
+var CANVAS_BLOCK_PARAM_TYPE = "$block";
+var CANVAS_PERSONALIZE_SLOT = "pz";
+var CANVAS_TEST_SLOT = "test";
+var CANVAS_LOCALIZATION_SLOT = "localized";
+var CANVAS_SLOT_SECTION_SLOT = "$slotSectionItems";
+var CANVAS_SLOT_SECTION_NAME_PARAM = "name";
+var CANVAS_SLOT_SECTION_MIN_PARAM = "min";
+var CANVAS_SLOT_SECTION_MAX_PARAM = "max";
+var CANVAS_SLOT_SECTION_GROUP_TYPE_PARAM = "groupType";
+var CANVAS_SLOT_SECTION_SPECIFIC_PARAM = "specific";
+var CANVAS_DRAFT_STATE = 0;
+var CANVAS_PUBLISHED_STATE = 64;
+var CANVAS_EDITOR_STATE = 63;
+var CANVAS_PERSONALIZATION_PARAM = "$pzCrit";
+var CANVAS_PERSONALIZATION_EVENT_NAME_PARAM = "trackingEventName";
+var CANVAS_PERSONALIZATION_ALGORITHM_PARAM = "algorithm";
+var CANVAS_PERSONALIZATION_ALGORITHM_TYPE = "pzAlgorithm";
+var CANVAS_PERSONALIZATION_TAKE_PARAM = "count";
+var CANVAS_TEST_VARIANT_PARAM = "$tstVrnt";
+var CANVAS_ENRICHMENT_TAG_PARAM = "$enr";
+var CANVAS_INTERNAL_PARAM_PREFIX = "$internal_";
+var CANVAS_COMPONENT_DISPLAY_NAME_PARAM = `${CANVAS_INTERNAL_PARAM_PREFIX}displayName`;
+var CANVAS_HYPOTHESIS_PARAM = `${CANVAS_INTERNAL_PARAM_PREFIX}hypothesis`;
+var CANVAS_CONTEXTUAL_EDITING_PARAM = "$contextualEditing";
+var SECRET_QUERY_STRING_PARAM = "secret";
+var IN_CONTEXT_EDITOR_QUERY_STRING_PARAM = "is_incontext_editing_mode";
+var IN_CONTEXT_EDITOR_PLAYGROUND_QUERY_STRING_PARAM = "is_incontext_editing_playground";
+var IN_CONTEXT_EDITOR_FORCED_SETTINGS_QUERY_STRING_PARAM = "is_incontext_editing_forced_settings";
+var IN_CONTEXT_EDITOR_CONFIG_CHECK_QUERY_STRING_PARAM = "is_config_check";
+var IN_CONTEXT_EDITOR_COMPONENT_START_ROLE = "uniform-component-start";
+var IN_CONTEXT_EDITOR_COMPONENT_END_ROLE = "uniform-component-end";
+var IN_CONTEXT_EDITOR_EMBED_SCRIPT_ID = "uniform-canvas-preview-script";
+var IS_RENDERED_BY_UNIFORM_ATTRIBUTE = "data-is-rendered-by-uniform";
+var PLACEHOLDER_ID = "placeholder";
+var EMPTY_COMPOSITION = {
+  _id: "_empty_composition_id",
+  _name: "An empty composition used for contextual editing",
+  type: "_empty_composition_type"
+};
+var EDGE_MIN_CACHE_TTL = 10;
+var EDGE_MAX_CACHE_TTL = 24 * 60 * 60;
+var EDGE_DEFAULT_CACHE_TTL = 30;
+var EDGE_CACHE_DISABLED = -1;
+var ASSET_PARAMETER_TYPE = "asset";
+var ASSETS_SOURCE_UNIFORM = "uniform-assets";
+var ASSETS_SOURCE_CUSTOM_URL = "custom-url";
+var REFERENCE_DATA_TYPE_ID = "uniformContentInternalReference";
+
+// src/clients/compositionHelpers.ts
+function resolveCompositionSelector(args) {
+  if ("compositionId" in args) {
+    const { compositionId, editionId, versionId, ...readOptions } = args;
+    return {
+      readOptions,
+      // raw mode matches on composition OR edition id via the compositionId param
+      compositionId: editionId != null ? editionId : compositionId,
+      versionId,
+      hasCompositionId: true,
+      pinnedEdition: editionId !== void 0
+    };
+  }
+  return { readOptions: args, hasCompositionId: false, pinnedEdition: false };
+}
+
+// src/clients/DeliveryClientBase.ts
+var DEFAULT_EDGE_API_HOST = "https://uniform.global";
+var DeliveryClientBase = class extends ContentClientBase {
+  constructor(options) {
+    var _a;
+    super(
+      options,
+      /* defaultBypassCache */
+      false
+    );
+    this.edgeApiHost = (_a = options.edgeApiHost) != null ? _a : DEFAULT_EDGE_API_HOST;
+    this.edgeRequestInit = options.disableSWR ? { headers: { "x-disable-swr": "true" } } : void 0;
+  }
+  /** Coerces the `diagnostics` option into the shape the edge endpoints accept. */
+  coerceDiagnostics(diagnostics) {
+    return typeof diagnostics === "boolean" ? diagnostics : diagnostics === "no-data" ? "no-data" : void 0;
+  }
+};
+
+// src/clients/CompositionDeliveryClient.ts
+var EDGE_SINGLE_URL = "/api/v1/composition";
+var EDGE_LIST_URL = "/api/v1/compositions";
+var CompositionDeliveryClient = class extends DeliveryClientBase {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches exactly one composition (throws `ApiClientError(404)` if absent). */
+  get(args) {
+    var _a;
+    const { diagnostics, select, ...rest } = args;
+    const { readOptions, compositionId, versionId, pinnedEdition } = resolveCompositionSelector(rest);
+    const url = this.createUrl(
+      EDGE_SINGLE_URL,
+      {
+        ...readOptions,
+        ...projectionToQuery(select),
+        // A pinned edition is folded into compositionId (raw matches edition or
+        // composition id); there is no editionId query param on this endpoint.
+        compositionId,
+        versionId,
+        projectId: this.options.projectId,
+        state: (_a = args.state) != null ? _a : CANVAS_PUBLISHED_STATE,
+        // editionId pins a specific edition for preview; otherwise locale-best.
+        editions: pinnedEdition ? "raw" : "auto",
+        diagnostics: this.coerceDiagnostics(diagnostics)
+      },
+      this.edgeApiHost
+    );
+    return this.apiClient(url, this.edgeRequestInit);
+  }
+  /** Fetches a list of compositions, optionally filtered. */
+  list(args = {}) {
+    var _a;
+    const { diagnostics, filters, select, ...rest } = args;
+    const url = this.createUrl(
+      EDGE_LIST_URL,
+      {
+        ...rest,
+        ...rewriteFiltersForApi(filters),
+        ...projectionToQuery(select),
+        projectId: this.options.projectId,
+        state: (_a = args.state) != null ? _a : CANVAS_PUBLISHED_STATE,
+        diagnostics: this.coerceDiagnostics(diagnostics)
+      },
+      this.edgeApiHost
+    );
+    return this.apiClient(url, this.edgeRequestInit);
+  }
+};
+
+// src/clients/CompositionManagementClient.ts
+import { rewriteFiltersForApi as rewriteFiltersForApi2 } from "@uniformdev/context/api";
+
+// src/clients/resolveManagementEditions.ts
+function resolveManagementEditions({
+  explicit,
+  pinnedEdition,
+  hasId,
+  hasLocale
+}) {
+  if (explicit) {
+    return explicit;
+  }
+  if (pinnedEdition) {
+    return "raw";
+  }
+  if (!hasId) {
+    return void 0;
+  }
+  return hasLocale ? "auto" : "raw";
+}
+
+// src/clients/CompositionManagementClient.ts
+var CANVAS_URL = "/api/v1/canvas";
+var CANVAS_HISTORY_URL = "/api/v1/canvas-history";
+var CompositionManagementClient = class extends ContentClientBase {
+  constructor(options) {
+    super(
+      options,
+      /* defaultBypassCache */
+      true
+    );
+  }
+  /**
+   * Fetches one composition in canonical shape (throws `ApiClientError(404)` if
+   * absent).
+   */
+  get(args) {
+    var _a;
+    const { select, ...selectorArgs } = args;
+    const { readOptions, compositionId, versionId, hasCompositionId, pinnedEdition } = resolveCompositionSelector(selectorArgs);
+    const url = this.createUrl(CANVAS_URL, {
+      format: CANONICAL_FORMAT,
+      // Caller-supplied shaping flags and non-id selector keys ride along and
+      // override the format alias server-side.
+      ...readOptions,
+      ...projectionToQuery(select),
+      // A pinned edition is folded into compositionId; there is no editionId
+      // query param on this endpoint.
+      compositionId,
+      versionId,
+      projectId: this.options.projectId,
+      state: (_a = args.state) != null ? _a : CANVAS_DRAFT_STATE,
+      editions: resolveManagementEditions({
+        explicit: readOptions.editions,
+        pinnedEdition,
+        hasId: hasCompositionId,
+        hasLocale: readOptions.locale != null
+      })
+    });
+    return this.apiClient(url);
+  }
+  /** Fetches a list of compositions in canonical shape. */
+  list(args = {}) {
+    var _a;
+    const { filters, select, ...rest } = args;
+    const url = this.createUrl(CANVAS_URL, {
+      format: CANONICAL_FORMAT,
+      ...rest,
+      ...rewriteFiltersForApi2(filters),
+      ...projectionToQuery(select),
+      projectId: this.options.projectId,
+      state: (_a = args.state) != null ? _a : CANVAS_DRAFT_STATE
+    });
+    return this.apiClient(url);
+  }
+  /** Creates or updates a composition. Returns the new `x-modified-at` timestamp. */
+  async save(body, opts) {
+    const url = this.createUrl(CANVAS_URL);
+    const headers = {};
+    if (opts == null ? void 0 : opts.ifUnmodifiedSince) {
+      headers["x-if-unmodified-since"] = opts.ifUnmodifiedSince;
+    }
+    const { response } = await this.apiClientWithResponse(url, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true,
+      headers
+    });
+    return { modified: response.headers.get("x-modified-at") };
+  }
+  /**
+   * Saves the draft and publishes in one call (two PUTs). The optimistic
+   * concurrency guard, if any, applies to the draft write.
+   */
+  async saveAndPublish(body, opts) {
+    await this.save({ ...body, state: CANVAS_DRAFT_STATE }, opts);
+    return this.save({ ...body, state: CANVAS_PUBLISHED_STATE });
+  }
+  /**
+   * Removes only the published state, leaving the draft intact. Scoped to a
+   * single edition when `editionId` is supplied; otherwise unpublishes all editions.
+   * To unpublish only the base edition, pass editionId and compositionId as the same value.
+   */
+  async unpublish(selector) {
+    await this.deleteComposition({ ...selector, state: CANVAS_PUBLISHED_STATE });
+  }
+  /**
+   * Deletes across all states. Scoped to a single edition when `editionId` is
+   * supplied; otherwise deletes all states and editions.
+   * Use `unpublish` to drop only the published state.
+   */
+  async remove(selector) {
+    await this.deleteComposition(selector);
+  }
+  /** Fetches historical versions of a composition or pattern. */
+  history(args) {
+    const url = this.createUrl(CANVAS_HISTORY_URL, { ...args, projectId: this.options.projectId });
+    return this.apiClient(url);
+  }
+  async deleteComposition(body) {
+    const url = this.createUrl(CANVAS_URL);
+    await this.apiClient(url, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+
+// src/clients/ContentTypeClient.ts
+import { ApiClientError as ApiClientError3 } from "@uniformdev/context/api";
+var CONTENT_TYPES_URL = "/api/v1/content-types";
+var ContentTypeClient = class extends ContentClientBase {
+  constructor(options) {
+    super(
+      options,
+      /* defaultBypassCache */
+      true
+    );
+  }
+  /** Fetches one content type by id (throws `ApiClientError(404)` if absent). */
+  async get(args) {
+    var _a;
+    const url = this.createUrl(CONTENT_TYPES_URL, {
+      contentTypeIDs: [args.contentTypeId],
+      limit: 1,
+      projectId: this.options.projectId
+    });
+    const res = await this.apiClient(url);
+    const contentType = (_a = res.contentTypes) == null ? void 0 : _a[0];
+    if (!contentType) {
+      throw new ApiClientError3("Content type not found", "GET", url.toString(), 404, "Not Found");
+    }
+    return contentType;
+  }
+  /** Fetches a list of content types. */
+  list(args) {
+    const url = this.createUrl(CONTENT_TYPES_URL, { ...args, projectId: this.options.projectId });
+    return this.apiClient(url);
+  }
+  /** Creates or updates a content type. */
+  async save(body, opts = {}) {
+    const url = this.createUrl(CONTENT_TYPES_URL);
+    let contentType = body.contentType;
+    if (typeof contentType.slugSettings === "object" && contentType.slugSettings !== null && Object.keys(contentType.slugSettings).length === 0) {
+      const { slugSettings: _omitEmptySlugSettings, ...rest } = contentType;
+      contentType = rest;
+    }
+    await this.apiClient(url, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, contentType, projectId: this.options.projectId }),
+      expectNoContent: true,
+      headers: opts.autogenerateDataTypes ? { "x-uniform-autogenerate-data-types": "true" } : {}
+    });
+  }
+  /** Deletes a content type. */
+  async remove(args) {
+    const url = this.createUrl(CONTENT_TYPES_URL);
+    await this.apiClient(url, {
+      method: "DELETE",
+      body: JSON.stringify({ ...args, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+
+// src/clients/EntryDeliveryClient.ts
+import { rewriteFiltersForApi as rewriteFiltersForApi3 } from "@uniformdev/context/api";
+
+// src/clients/entryHelpers.ts
+import { ApiClientError as ApiClientError4 } from "@uniformdev/context/api";
+function resolveEntrySelector(args) {
+  if ("entryId" in args) {
+    const { entryId, editionId, versionId, ...readOptions2 } = args;
+    return {
+      readOptions: readOptions2,
+      entryIDs: [editionId != null ? editionId : entryId],
+      versionId,
+      pinnedEdition: editionId !== void 0
+    };
+  }
+  const { slug, ...readOptions } = args;
+  return { readOptions, slug, pinnedEdition: false };
+}
+function unwrapSingleEntry(res, url) {
+  var _a;
+  const entry = (_a = res.entries) == null ? void 0 : _a[0];
+  if (!entry) {
+    throw new ApiClientError4("Entry not found", "GET", url.toString(), 404, "Not Found");
+  }
+  return entry;
+}
+
+// src/clients/EntryDeliveryClient.ts
+var ENTRIES_URL = "/api/v1/entries";
+var EntryDeliveryClient = class extends DeliveryClientBase {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches exactly one entry by id or slug (throws `ApiClientError(404)` if absent). */
+  async get(args) {
+    var _a, _b;
+    const { diagnostics, select, ...rest } = args;
+    const { entryIDs, slug, versionId, pinnedEdition, readOptions } = resolveEntrySelector(rest);
+    const url = this.createUrl(
+      ENTRIES_URL,
+      {
+        ...readOptions,
+        ...projectionToQuery(select),
+        projectId: this.options.projectId,
+        state: (_a = args.state) != null ? _a : CANVAS_PUBLISHED_STATE,
+        entryIDs,
+        slug,
+        versionId,
+        // A pinned edition is fetched exactly; otherwise locale-best.
+        editions: pinnedEdition ? "raw" : "auto",
+        // An id lookup wants that exact entity regardless of type, so default the
+        // pattern filter to 'any' (origin default `false` would 404 a pattern id).
+        // Scoped to id lookups; slug reads keep the origin default. Explicit
+        // `pattern` overrides via the `...readOptions` spread above.
+        pattern: (_b = args.pattern) != null ? _b : entryIDs ? "any" : void 0,
+        diagnostics: this.coerceDiagnostics(diagnostics)
+      },
+      this.edgeApiHost
+    );
+    const res = await this.apiClient(url, this.edgeRequestInit);
+    return unwrapSingleEntry(res, url);
+  }
+  /** Fetches a list of entries, optionally filtered. */
+  list(args = {}) {
+    var _a;
+    const { diagnostics, filters, select, ...rest } = args;
+    const url = this.createUrl(
+      ENTRIES_URL,
+      {
+        ...rest,
+        ...rewriteFiltersForApi3(filters),
+        ...projectionToQuery(select),
+        projectId: this.options.projectId,
+        state: (_a = args.state) != null ? _a : CANVAS_PUBLISHED_STATE,
+        diagnostics: this.coerceDiagnostics(diagnostics)
+      },
+      this.edgeApiHost
+    );
+    return this.apiClient(url, this.edgeRequestInit);
+  }
+};
+
+// src/clients/EntryManagementClient.ts
+import { rewriteFiltersForApi as rewriteFiltersForApi4 } from "@uniformdev/context/api";
+var ENTRIES_URL2 = "/api/v1/entries";
+var ENTRIES_HISTORY_URL = "/api/v1/entries-history";
+var EntryManagementClient = class extends ContentClientBase {
+  constructor(options) {
+    super(
+      options,
+      /* defaultBypassCache */
+      true
+    );
+  }
+  /**
+   * Fetches one entry by id or slug in canonical shape (throws
+   * `ApiClientError(404)` if absent).
+   */
+  async get(args) {
+    var _a, _b;
+    const { select, ...selectorArgs } = args;
+    const { entryIDs, slug, versionId, readOptions, pinnedEdition } = resolveEntrySelector(selectorArgs);
+    const url = this.createUrl(ENTRIES_URL2, {
+      format: CANONICAL_FORMAT,
+      ...readOptions,
+      ...projectionToQuery(select),
+      projectId: this.options.projectId,
+      state: (_a = args.state) != null ? _a : CANVAS_DRAFT_STATE,
+      editions: resolveManagementEditions({
+        explicit: readOptions.editions,
+        pinnedEdition,
+        hasId: entryIDs != null,
+        hasLocale: readOptions.locale != null
+      }),
+      // An id lookup wants that exact entity regardless of type, so default the
+      // pattern filter to 'any' (origin default `false` would 404 a pattern id).
+      // Scoped to id lookups; slug reads keep the origin default. Explicit
+      // `pattern` overrides via the `...readOptions` spread above.
+      pattern: (_b = args.pattern) != null ? _b : entryIDs ? "any" : void 0,
+      entryIDs,
+      slug,
+      versionId
+    });
+    const res = await this.apiClient(url);
+    return unwrapSingleEntry(res, url);
+  }
+  /** Fetches a list of entries in canonical shape. */
+  list(args = {}) {
+    var _a;
+    const { filters, select, ...rest } = args;
+    const url = this.createUrl(ENTRIES_URL2, {
+      format: CANONICAL_FORMAT,
+      ...rest,
+      ...rewriteFiltersForApi4(filters),
+      ...projectionToQuery(select),
+      projectId: this.options.projectId,
+      state: (_a = args.state) != null ? _a : CANVAS_DRAFT_STATE
+    });
+    return this.apiClient(url);
+  }
+  /** Creates or updates an entry. Returns the new `x-modified-at` timestamp. */
+  async save(body, opts) {
+    const url = this.createUrl(ENTRIES_URL2);
+    const headers = {};
+    if (opts == null ? void 0 : opts.ifUnmodifiedSince) {
+      headers["x-if-unmodified-since"] = opts.ifUnmodifiedSince;
+    }
+    const { response } = await this.apiClientWithResponse(url, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true,
+      headers
+    });
+    return { modified: response.headers.get("x-modified-at") };
+  }
+  /** Saves the draft and publishes in one call (two PUTs). */
+  async saveAndPublish(body, opts) {
+    await this.save({ ...body, state: CANVAS_DRAFT_STATE }, opts);
+    return this.save({ ...body, state: CANVAS_PUBLISHED_STATE });
+  }
+  /**
+   * Removes only the published state, leaving the draft intact. Scoped to a
+   * single edition when `editionId` is supplied; otherwise unpublishes all editions.
+   * To unpublish only the base edition, pass editionId and entryId as the same value.
+   */
+  async unpublish(selector) {
+    await this.deleteEntry({ ...selector, state: CANVAS_PUBLISHED_STATE });
+  }
+  /**
+   * Deletes across all states. Scoped to a single edition when `editionId` is
+   * supplied; otherwise deletes all states and editions.
+   * Use `unpublish` to drop only the published state.
+   */
+  async remove(selector) {
+    await this.deleteEntry(selector);
+  }
+  /** Fetches historical versions of an entry. */
+  history(args) {
+    const url = this.createUrl(ENTRIES_HISTORY_URL, { ...args, projectId: this.options.projectId });
+    return this.apiClient(url);
+  }
+  async deleteEntry(body) {
+    const url = this.createUrl(ENTRIES_URL2);
+    await this.apiClient(url, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+
+// src/clients/deprecated/CanvasClient.ts
+import { ApiClient as ApiClient3, rewriteFiltersForApi as rewriteFiltersForApi5 } from "@uniformdev/context/api";
+var CANVAS_URL2 = "/api/v1/canvas";
+var CanvasClient = class extends ApiClient3 {
   constructor(options) {
     var _a;
     if (!options.limitPolicy) {
@@ -599,17 +752,24 @@ var CanvasClient = class extends ApiClient {
   /** Fetches lists of Canvas compositions, optionally by type */
   async getCompositionList(params = {}) {
     const { projectId } = this.options;
-    const { resolveData, filters, ...originParams } = params;
-    const rewrittenFilters = rewriteFiltersForApi(filters);
+    const { resolveData, filters, select, ...originParams } = params;
+    const rewrittenFilters = rewriteFiltersForApi5(filters);
+    const rewrittenSelect = projectionToQuery(select);
     if (!resolveData) {
-      const fetchUri = this.createUrl(CANVAS_URL, { ...originParams, projectId, ...rewrittenFilters });
+      const fetchUri = this.createUrl(CANVAS_URL2, {
+        ...originParams,
+        projectId,
+        ...rewrittenFilters,
+        ...rewrittenSelect
+      });
       return this.apiClient(fetchUri);
     }
     const edgeParams = {
       ...originParams,
       projectId,
       diagnostics: typeof params.diagnostics === "boolean" ? params.diagnostics : params.diagnostics === "no-data" ? "no-data" : void 0,
-      ...rewrittenFilters
+      ...rewrittenFilters,
+      ...rewrittenSelect
     };
     const edgeUrl = this.createUrl("/api/v1/compositions", edgeParams, this.edgeApiHost);
     return this.apiClient(edgeUrl, this.edgeApiRequestInit);
@@ -644,7 +804,7 @@ var CanvasClient = class extends ApiClient {
   }) {
     const { projectId } = this.options;
     if (skipDataResolution) {
-      return this.apiClient(this.createUrl(CANVAS_URL, { ...params, projectId }));
+      return this.apiClient(this.createUrl(CANVAS_URL2, { ...params, projectId }));
     }
     const edgeParams = {
       ...params,
@@ -656,7 +816,7 @@ var CanvasClient = class extends ApiClient {
   }
   /** Updates or creates a Canvas component definition */
   async updateComposition(body, options) {
-    const fetchUri = this.createUrl(CANVAS_URL);
+    const fetchUri = this.createUrl(CANVAS_URL2);
     const headers = {};
     if (options == null ? void 0 : options.ifUnmodifiedSince) {
       headers["x-if-unmodified-since"] = options.ifUnmodifiedSince;
@@ -671,7 +831,7 @@ var CanvasClient = class extends ApiClient {
   }
   /** Deletes a Canvas component definition */
   async removeComposition(body) {
-    const fetchUri = this.createUrl(CANVAS_URL);
+    const fetchUri = this.createUrl(CANVAS_URL2);
     const { projectId } = this.options;
     await this.apiClient(fetchUri, {
       method: "DELETE",
@@ -710,53 +870,10 @@ var UncachedCanvasClient = class extends CanvasClient {
   }
 };
 
-// src/CategoryClient.ts
-import { ApiClient as ApiClient2 } from "@uniformdev/context/api";
-var CATEGORIES_URL = "/api/v1/categories";
-var CategoryClient = class extends ApiClient2 {
-  constructor(options) {
-    if (!options.limitPolicy) {
-      options.limitPolicy = createLimitPolicy({});
-    }
-    super(options);
-  }
-  /** Fetches all categories created in given project */
-  async getCategories(options) {
-    const { projectId } = this.options;
-    const fetchUri = this.createUrl("/api/v1/categories", { ...options, projectId });
-    return await this.apiClient(fetchUri);
-  }
-  /** Updates or creates a category, also used to re-order them */
-  async upsertCategories(categories) {
-    const { projectId } = this.options;
-    const fetchUri = this.createUrl(CATEGORIES_URL);
-    return await this.apiClient(fetchUri, {
-      method: "PUT",
-      body: JSON.stringify({ categories, projectId }),
-      expectNoContent: true
-    });
-  }
-  /** Deletes a category */
-  async removeCategory(options) {
-    const { projectId } = this.options;
-    const fetchUri = this.createUrl(CATEGORIES_URL);
-    return await this.apiClient(fetchUri, {
-      method: "DELETE",
-      body: JSON.stringify({ projectId, categoryId: options.categoryId }),
-      expectNoContent: true
-    });
-  }
-};
-var UncachedCategoryClient = class extends CategoryClient {
-  constructor(options) {
-    super({ ...options, bypassCache: true });
-  }
-};
-
-// src/ContentClient.ts
-import { ApiClient as ApiClient3, rewriteFiltersForApi as rewriteFiltersForApi2 } from "@uniformdev/context/api";
+// src/clients/deprecated/ContentClient.ts
+import { ApiClient as ApiClient4, rewriteFiltersForApi as rewriteFiltersForApi6 } from "@uniformdev/context/api";
 var _contentTypesUrl, _entriesUrl;
-var _ContentClient = class _ContentClient extends ApiClient3 {
+var _ContentClient = class _ContentClient extends ApiClient4 {
   constructor(options) {
     var _a;
     super(options);
@@ -769,15 +886,21 @@ var _ContentClient = class _ContentClient extends ApiClient3 {
   }
   getEntries(options) {
     const { projectId } = this.options;
-    const { skipDataResolution, filters, ...params } = options;
-    const rewrittenFilters = rewriteFiltersForApi2(filters);
+    const { skipDataResolution, filters, select, ...params } = options;
+    const rewrittenFilters = rewriteFiltersForApi6(filters);
+    const rewrittenSelect = projectionToQuery(select);
     if (skipDataResolution) {
-      const url = this.createUrl(__privateGet(_ContentClient, _entriesUrl), { ...params, ...rewrittenFilters, projectId });
+      const url = this.createUrl(__privateGet(_ContentClient, _entriesUrl), {
+        ...params,
+        ...rewrittenFilters,
+        ...rewrittenSelect,
+        projectId
+      });
       return this.apiClient(url);
     }
     const edgeUrl = this.createUrl(
       __privateGet(_ContentClient, _entriesUrl),
-      { ...this.getEdgeOptions(params), ...rewrittenFilters },
+      { ...this.getEdgeOptions(params), ...rewrittenFilters, ...rewrittenSelect },
       this.edgeApiHost
     );
     return this.apiClient(
@@ -857,27 +980,31 @@ var UncachedContentClient = class extends ContentClient {
 };
 
 // src/DataSourceClient.ts
-import { ApiClient as ApiClient4 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient5 } from "@uniformdev/context/api";
 var dataSourceUrl = "/api/v1/data-source";
 var dataSourcesUrl = "/api/v1/data-sources";
-var DataSourceClient = class extends ApiClient4 {
+var DataSourceClient = class extends ApiClient5 {
   constructor(options) {
     super(options);
   }
-  /** Fetches all DataSources for a project */
+  /** Fetches a single DataSource by id (with decrypted secrets). */
   async get(options) {
     const { projectId } = this.options;
     const fetchUri = this.createUrl(dataSourceUrl, { ...options, projectId });
     return await this.apiClient(fetchUri);
   }
-  /** Fetches all DataSources for a project */
-  async getList(options) {
+  /** Fetches the list of DataSources for a project (secrets masked). */
+  async list(options) {
     const { projectId } = this.options;
     const fetchUri = this.createUrl(dataSourcesUrl, { ...options, projectId });
     return await this.apiClient(fetchUri);
   }
+  /** @deprecated Use {@link list} instead. */
+  async getList(options) {
+    return this.list(options);
+  }
   /** Updates or creates (based on id) a DataSource */
-  async upsert(body) {
+  async save(body) {
     const fetchUri = this.createUrl(dataSourceUrl);
     await this.apiClient(fetchUri, {
       method: "PUT",
@@ -885,6 +1012,10 @@ var DataSourceClient = class extends ApiClient4 {
       expectNoContent: true
     });
   }
+  /** @deprecated Use {@link save} instead. */
+  async upsert(body) {
+    return this.save(body);
+  }
   /** Deletes a DataSource */
   async remove(body) {
     const fetchUri = this.createUrl(dataSourceUrl);
@@ -897,20 +1028,24 @@ var DataSourceClient = class extends ApiClient4 {
 };
 
 // src/DataTypeClient.ts
-import { ApiClient as ApiClient5 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient6 } from "@uniformdev/context/api";
 var _url;
-var _DataTypeClient = class _DataTypeClient extends ApiClient5 {
+var _DataTypeClient = class _DataTypeClient extends ApiClient6 {
   constructor(options) {
     super(options);
   }
-  /** Fetches all DataTypes for a project */
-  async get(options) {
+  /** Fetches a list of DataTypes for a project */
+  async list(options) {
     const { projectId } = this.options;
     const fetchUri = this.createUrl(__privateGet(_DataTypeClient, _url), { ...options, projectId });
     return await this.apiClient(fetchUri);
   }
+  /** @deprecated Use {@link list} instead. */
+  async get(options) {
+    return this.list(options);
+  }
   /** Updates or creates (based on id) a DataType */
-  async upsert(body) {
+  async save(body) {
     const fetchUri = this.createUrl(__privateGet(_DataTypeClient, _url));
     await this.apiClient(fetchUri, {
       method: "PUT",
@@ -918,6 +1053,10 @@ var _DataTypeClient = class _DataTypeClient extends ApiClient5 {
       expectNoContent: true
     });
   }
+  /** @deprecated Use {@link save} instead. */
+  async upsert(body) {
+    return this.save(body);
+  }
   /** Deletes a DataType */
   async remove(body) {
     const fetchUri = this.createUrl(__privateGet(_DataTypeClient, _url));
@@ -1053,61 +1192,6 @@ function getComponentPath(ancestorsAndSelf) {
   return `.${path.join(".")}`;
 }
 
-// src/utils/constants.ts
-var CANVAS_PERSONALIZE_TYPE = "$personalization";
-var CANVAS_TEST_TYPE = "$test";
-var CANVAS_LOCALIZATION_TYPE = "$localization";
-var CANVAS_SLOT_SECTION_TYPE = "$slotSection";
-var CANVAS_INTENT_TAG_PARAM = "intentTag";
-var CANVAS_LOCALE_TAG_PARAM = "locale";
-var CANVAS_BLOCK_PARAM_TYPE = "$block";
-var CANVAS_PERSONALIZE_SLOT = "pz";
-var CANVAS_TEST_SLOT = "test";
-var CANVAS_LOCALIZATION_SLOT = "localized";
-var CANVAS_SLOT_SECTION_SLOT = "$slotSectionItems";
-var CANVAS_SLOT_SECTION_NAME_PARAM = "name";
-var CANVAS_SLOT_SECTION_MIN_PARAM = "min";
-var CANVAS_SLOT_SECTION_MAX_PARAM = "max";
-var CANVAS_SLOT_SECTION_GROUP_TYPE_PARAM = "groupType";
-var CANVAS_SLOT_SECTION_SPECIFIC_PARAM = "specific";
-var CANVAS_DRAFT_STATE = 0;
-var CANVAS_PUBLISHED_STATE = 64;
-var CANVAS_EDITOR_STATE = 63;
-var CANVAS_PERSONALIZATION_PARAM = "$pzCrit";
-var CANVAS_PERSONALIZATION_EVENT_NAME_PARAM = "trackingEventName";
-var CANVAS_PERSONALIZATION_ALGORITHM_PARAM = "algorithm";
-var CANVAS_PERSONALIZATION_ALGORITHM_TYPE = "pzAlgorithm";
-var CANVAS_PERSONALIZATION_TAKE_PARAM = "count";
-var CANVAS_TEST_VARIANT_PARAM = "$tstVrnt";
-var CANVAS_ENRICHMENT_TAG_PARAM = "$enr";
-var CANVAS_INTERNAL_PARAM_PREFIX = "$internal_";
-var CANVAS_COMPONENT_DISPLAY_NAME_PARAM = `${CANVAS_INTERNAL_PARAM_PREFIX}displayName`;
-var CANVAS_HYPOTHESIS_PARAM = `${CANVAS_INTERNAL_PARAM_PREFIX}hypothesis`;
-var CANVAS_CONTEXTUAL_EDITING_PARAM = "$contextualEditing";
-var SECRET_QUERY_STRING_PARAM = "secret";
-var IN_CONTEXT_EDITOR_QUERY_STRING_PARAM = "is_incontext_editing_mode";
-var IN_CONTEXT_EDITOR_PLAYGROUND_QUERY_STRING_PARAM = "is_incontext_editing_playground";
-var IN_CONTEXT_EDITOR_FORCED_SETTINGS_QUERY_STRING_PARAM = "is_incontext_editing_forced_settings";
-var IN_CONTEXT_EDITOR_CONFIG_CHECK_QUERY_STRING_PARAM = "is_config_check";
-var IN_CONTEXT_EDITOR_COMPONENT_START_ROLE = "uniform-component-start";
-var IN_CONTEXT_EDITOR_COMPONENT_END_ROLE = "uniform-component-end";
-var IN_CONTEXT_EDITOR_EMBED_SCRIPT_ID = "uniform-canvas-preview-script";
-var IS_RENDERED_BY_UNIFORM_ATTRIBUTE = "data-is-rendered-by-uniform";
-var PLACEHOLDER_ID = "placeholder";
-var EMPTY_COMPOSITION = {
-  _id: "_empty_composition_id",
-  _name: "An empty composition used for contextual editing",
-  type: "_empty_composition_type"
-};
-var EDGE_MIN_CACHE_TTL = 10;
-var EDGE_MAX_CACHE_TTL = 24 * 60 * 60;
-var EDGE_DEFAULT_CACHE_TTL = 30;
-var EDGE_CACHE_DISABLED = -1;
-var ASSET_PARAMETER_TYPE = "asset";
-var ASSETS_SOURCE_UNIFORM = "uniform-assets";
-var ASSETS_SOURCE_CUSTOM_URL = "custom-url";
-var REFERENCE_DATA_TYPE_ID = "uniformContentInternalReference";
-
 // src/utils/guards.ts
 function isRootEntryReference(root) {
   return root.type === "root" && isEntryData(root.node);
@@ -2406,8 +2490,7 @@ function extractLocales({ component }) {
   return variations;
 }
 function localize(options) {
-  const nodes = options.nodes;
-  const locale = options.locale;
+  const { nodes, locale, keepLocalesFor } = options;
   if (!locale) {
     return;
   }
@@ -2415,7 +2498,7 @@ function localize(options) {
   walkNodeTree(nodes, (context) => {
     const { type, node, actions } = context;
     if (type !== "component") {
-      localizeProperties(node, locale, vizControlLocaleRule);
+      localizeProperties(node, locale, vizControlLocaleRule, keepLocalesFor);
       return;
     }
     const result = evaluateWalkTreeNodeVisibility({
@@ -2436,7 +2519,7 @@ function localize(options) {
       if (replaceComponent == null ? void 0 : replaceComponent.length) {
         replaceComponent.forEach((component) => {
           removeLocaleProperty(component);
-          localizeProperties(component, locale, vizControlLocaleRule);
+          localizeProperties(component, locale, vizControlLocaleRule, keepLocalesFor);
         });
         const [first, ...rest] = replaceComponent;
         actions.replace(first);
@@ -2447,7 +2530,7 @@ function localize(options) {
         actions.remove();
       }
     } else {
-      localizeProperties(node, locale, vizControlLocaleRule);
+      localizeProperties(node, locale, vizControlLocaleRule, keepLocalesFor);
     }
   });
 }
@@ -2466,7 +2549,7 @@ function removeLocaleProperty(component) {
     }
   }
 }
-function localizeProperties(node, locale, rules) {
+function localizeProperties(node, locale, rules, keepLocalesFor) {
   const properties = getPropertiesValue(node);
   if (!properties) {
     return void 0;
@@ -2485,10 +2568,16 @@ function localizeProperties(node, locale, rules) {
     if (currentLocaleConditionalValues !== void 0) {
       propertyValue.conditions = currentLocaleConditionalValues;
     }
-    delete propertyValue.locales;
-    delete propertyValue.localesConditions;
+    const preserveLocales = (keepLocalesFor == null ? void 0 : keepLocalesFor(propertyId)) === true;
+    if (!preserveLocales) {
+      delete propertyValue.locales;
+      delete propertyValue.localesConditions;
+    }
     if (propertyValue.value === void 0 && propertyValue.conditions === void 0) {
-      delete properties[propertyId];
+      const hasLocales = preserveLocales && (propertyValue.locales || propertyValue.localesConditions);
+      if (!hasLocales) {
+        delete properties[propertyId];
+      }
     }
   });
   evaluateWalkTreePropertyCriteria({
@@ -2556,24 +2645,28 @@ function walkPropertyValues(property, visitor) {
 }
 
 // src/EntityReleasesClient.ts
-import { ApiClient as ApiClient6 } from "@uniformdev/context/api";
-var releaseContentsUrl = "/api/v1/entity-releases";
-var EntityReleasesClient = class extends ApiClient6 {
+import { ApiClient as ApiClient7 } from "@uniformdev/context/api";
+var entityReleasesUrl = "/api/v1/entity-releases";
+var EntityReleasesClient = class extends ApiClient7 {
   constructor(options) {
     super(options);
   }
   /** Fetches entity across all releases (and base) */
-  async get(options) {
+  async list(options) {
     const { projectId } = this.options;
-    const fetchUri = this.createUrl(releaseContentsUrl, { ...options, projectId });
+    const fetchUri = this.createUrl(entityReleasesUrl, { ...options, projectId });
     return await this.apiClient(fetchUri);
   }
+  /** @deprecated Use {@link list} instead. */
+  async get(options) {
+    return this.list(options);
+  }
 };
 
 // src/IntegrationPropertyEditorsClient.ts
-import { ApiClient as ApiClient7 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient8 } from "@uniformdev/context/api";
 var _baseUrl;
-var _IntegrationPropertyEditorsClient = class _IntegrationPropertyEditorsClient extends ApiClient7 {
+var _IntegrationPropertyEditorsClient = class _IntegrationPropertyEditorsClient extends ApiClient8 {
   constructor(options) {
     super(options);
     this.teamId = options.teamId;
@@ -2616,17 +2709,21 @@ __privateAdd(_IntegrationPropertyEditorsClient, _baseUrl, "/api/v1/integration-p
 var IntegrationPropertyEditorsClient = _IntegrationPropertyEditorsClient;
 
 // src/LabelClient.ts
-import { ApiClient as ApiClient8 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient9 } from "@uniformdev/context/api";
 var LABELS_URL = "/api/v1/labels";
-var LabelClient = class extends ApiClient8 {
-  /** Fetches labels for the current project. */
-  async getLabels(options) {
+var LabelClient = class extends ApiClient9 {
+  /** Fetches a list of labels for the current project. */
+  async list(options) {
     const { projectId } = this.options;
     const fetchUri = this.createUrl(LABELS_URL, { ...options, projectId });
     return await this.apiClient(fetchUri);
   }
+  /** @deprecated Use {@link list} instead. */
+  async getLabels(options) {
+    return this.list(options);
+  }
   /** Updates or creates a label. */
-  async upsertLabel(body) {
+  async save(body) {
     const { projectId } = this.options;
     const fetchUri = this.createUrl(LABELS_URL);
     await this.apiClient(fetchUri, {
@@ -2635,8 +2732,12 @@ var LabelClient = class extends ApiClient8 {
       expectNoContent: true
     });
   }
+  /** @deprecated Use {@link save} instead. */
+  async upsertLabel(body) {
+    return this.save(body);
+  }
   /** Deletes a label by id. */
-  async removeLabel(options) {
+  async remove(options) {
     const { projectId } = this.options;
     const fetchUri = this.createUrl(LABELS_URL);
     await this.apiClient(fetchUri, {
@@ -2645,6 +2746,10 @@ var LabelClient = class extends ApiClient8 {
       expectNoContent: true
     });
   }
+  /** @deprecated Use {@link remove} instead. */
+  async removeLabel(options) {
+    return this.remove(options);
+  }
 };
 var UncachedLabelClient = class extends LabelClient {
   constructor(options) {
@@ -2653,20 +2758,24 @@ var UncachedLabelClient = class extends LabelClient {
 };
 
 // src/LocaleClient.ts
-import { ApiClient as ApiClient9 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient10 } from "@uniformdev/context/api";
 var localesUrl = "/api/v1/locales";
-var LocaleClient = class extends ApiClient9 {
+var LocaleClient = class extends ApiClient10 {
   constructor(options) {
     super(options);
   }
-  /** Fetches all locales for a project */
-  async get(options) {
+  /** Fetches a list of locales for a project */
+  async list(options) {
     const { projectId } = this.options;
     const fetchUri = this.createUrl(localesUrl, { ...options, projectId });
     return await this.apiClient(fetchUri);
   }
+  /** @deprecated Use {@link list} instead. */
+  async get(options) {
+    return this.list(options);
+  }
   /** Updates or creates (based on id) a locale */
-  async upsert(body) {
+  async save(body) {
     const fetchUri = this.createUrl(localesUrl);
     await this.apiClient(fetchUri, {
       method: "PUT",
@@ -2674,6 +2783,10 @@ var LocaleClient = class extends ApiClient9 {
       expectNoContent: true
     });
   }
+  /** @deprecated Use {@link save} instead. */
+  async upsert(body) {
+    return this.save(body);
+  }
   /** Deletes a locale */
   async remove(body) {
     const fetchUri = this.createUrl(localesUrl);
@@ -3057,10 +3170,10 @@ var createCanvasChannel = ({
 };
 
 // src/PreviewClient.ts
-import { ApiClient as ApiClient10 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient11 } from "@uniformdev/context/api";
 var previewUrlsUrl = "/api/v1/preview-urls";
 var previewViewportsUrl = "/api/v1/preview-viewports";
-var PreviewClient = class extends ApiClient10 {
+var PreviewClient = class extends ApiClient11 {
   constructor(options) {
     super(options);
   }
@@ -3123,9 +3236,9 @@ var PreviewClient = class extends ApiClient10 {
 };
 
 // src/ProjectClient.ts
-import { ApiClient as ApiClient11 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient12 } from "@uniformdev/context/api";
 var _url2, _projectsUrl;
-var _ProjectClient = class _ProjectClient extends ApiClient11 {
+var _ProjectClient = class _ProjectClient extends ApiClient12 {
   constructor(options) {
     super({ ...options, bypassCache: true });
   }
@@ -3139,20 +3252,28 @@ var _ProjectClient = class _ProjectClient extends ApiClient11 {
    * When teamId is provided, returns a single team with its projects.
    * When omitted, returns all accessible teams and their projects.
    */
-  async getProjects(options) {
+  async list(options) {
     const fetchUri = this.createUrl(__privateGet(_ProjectClient, _projectsUrl), options ? { ...options } : {});
     return await this.apiClient(fetchUri);
   }
+  /** @deprecated Use {@link list} instead. */
+  async getProjects(options) {
+    return this.list(options);
+  }
   /** Updates or creates (based on id) a Project */
-  async upsert(body) {
+  async save(body) {
     const fetchUri = this.createUrl(__privateGet(_ProjectClient, _url2));
     return await this.apiClient(fetchUri, {
       method: "PUT",
       body: JSON.stringify({ ...body })
     });
   }
+  /** @deprecated Use {@link save} instead. */
+  async upsert(body) {
+    return this.save(body);
+  }
   /** Deletes a Project */
-  async delete(body) {
+  async remove(body) {
     const fetchUri = this.createUrl(__privateGet(_ProjectClient, _url2));
     await this.apiClient(fetchUri, {
       method: "DELETE",
@@ -3160,6 +3281,10 @@ var _ProjectClient = class _ProjectClient extends ApiClient11 {
       expectNoContent: true
     });
   }
+  /** @deprecated Use {@link remove} instead. */
+  async delete(body) {
+    return this.remove(body);
+  }
 };
 _url2 = new WeakMap();
 _projectsUrl = new WeakMap();
@@ -3167,10 +3292,177 @@ __privateAdd(_ProjectClient, _url2, "/api/v1/project");
 __privateAdd(_ProjectClient, _projectsUrl, "/api/v1/projects");
 var ProjectClient = _ProjectClient;
 
+// src/projection/matchesProjectionPattern.ts
+var DISALLOWED_PATTERN_CHARS = /[,&=?#[\]\s]/;
+var REGEX_METACHAR = /[\\^$.|?*+()[\]{}]/g;
+function isValidProjectionPattern(pattern) {
+  if (typeof pattern !== "string" || pattern.length === 0) {
+    return false;
+  }
+  if (DISALLOWED_PATTERN_CHARS.test(pattern)) {
+    return false;
+  }
+  return true;
+}
+function compilePattern(pattern) {
+  let regexSource = "^";
+  for (const ch of pattern) {
+    if (ch === "*") {
+      regexSource += ".*";
+    } else {
+      regexSource += ch.replace(REGEX_METACHAR, "\\$&");
+    }
+  }
+  regexSource += "$";
+  return new RegExp(regexSource);
+}
+var PATTERN_CACHE_MAX = 1024;
+var patternRegexCache = /* @__PURE__ */ new Map();
+function matchesProjectionPattern(pattern, value) {
+  let re = patternRegexCache.get(pattern);
+  if (re === void 0) {
+    if (!isValidProjectionPattern(pattern)) {
+      throw new Error(`Invalid projection pattern: ${JSON.stringify(pattern)}`);
+    }
+    re = compilePattern(pattern);
+    if (patternRegexCache.size >= PATTERN_CACHE_MAX) {
+      const oldest = patternRegexCache.keys().next().value;
+      if (oldest !== void 0) patternRegexCache.delete(oldest);
+    }
+    patternRegexCache.set(pattern, re);
+  }
+  return re.test(value);
+}
+
+// src/projection/queryToProjection.ts
+var TOP_LEVEL_OPERATOR_KEY = /^(fields|fieldTypes|slots)\[([A-Za-z]+)\]$/;
+var SLOTS_NAMED_KEY = /^slots\.([A-Za-z0-9_-]+)\[([A-Za-z]+)\]$/;
+function toStringValue2(value) {
+  if (Array.isArray(value)) {
+    return value.join(",");
+  }
+  return value;
+}
+function parseCsv(value) {
+  const str = toStringValue2(value);
+  if (!str) {
+    return [];
+  }
+  return str.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function parseDepth(value, key) {
+  const str = toStringValue2(value);
+  if (str === void 0 || str === "") {
+    throw new Error(`Invalid select projection: '${key}' requires a non-negative integer value`);
+  }
+  if (!/^\d+$/.test(str)) {
+    throw new Error(
+      `Invalid select projection: '${key}' must be a non-negative integer (got ${JSON.stringify(str)})`
+    );
+  }
+  return Number(str);
+}
+function extractSelectKeys(source) {
+  if (source instanceof URLSearchParams) {
+    let out2;
+    for (const [key, value] of source.entries()) {
+      if (!key.startsWith(SELECT_QUERY_PREFIX)) continue;
+      out2 != null ? out2 : out2 = {};
+      out2[key] = out2[key] === void 0 ? value : `${out2[key]},${value}`;
+    }
+    return out2;
+  }
+  let out;
+  for (const key in source) {
+    if (!key.startsWith(SELECT_QUERY_PREFIX)) continue;
+    out != null ? out : out = {};
+    out[key] = source[key];
+  }
+  return out;
+}
+function queryToProjection(source) {
+  var _a, _b, _c, _d, _e;
+  if (!source) {
+    return void 0;
+  }
+  const query = extractSelectKeys(source);
+  if (!query) {
+    return void 0;
+  }
+  const spec = {};
+  for (const [rawKey, value] of Object.entries(query)) {
+    const key = rawKey.slice(SELECT_QUERY_PREFIX.length);
+    const namedMatch = SLOTS_NAMED_KEY.exec(key);
+    if (namedMatch) {
+      const [, slotName, operator2] = namedMatch;
+      if (operator2 !== "depth") {
+        throw new Error(
+          `Invalid select projection: unsupported operator '${operator2}' for slots.${slotName}`
+        );
+      }
+      const slots = (_a = spec.slots) != null ? _a : spec.slots = {};
+      const named = (_b = slots.named) != null ? _b : slots.named = {};
+      named[slotName] = { ...named[slotName], depth: parseDepth(value, rawKey) };
+      continue;
+    }
+    const topMatch = TOP_LEVEL_OPERATOR_KEY.exec(key);
+    if (!topMatch) {
+      throw new Error(`Invalid select projection key: ${JSON.stringify(rawKey)}`);
+    }
+    const [, bucket, operator] = topMatch;
+    if (bucket === "fields") {
+      const fields = (_c = spec.fields) != null ? _c : spec.fields = {};
+      switch (operator) {
+        case "only":
+          fields.only = parseCsv(value);
+          break;
+        case "except":
+          fields.except = parseCsv(value);
+          break;
+        case "locales":
+          fields.locales = parseCsv(value);
+          break;
+        default:
+          throw new Error(`Invalid select projection: unsupported operator 'fields[${operator}]'`);
+      }
+    } else if (bucket === "fieldTypes") {
+      const fieldTypes = (_d = spec.fieldTypes) != null ? _d : spec.fieldTypes = {};
+      switch (operator) {
+        case "only":
+          fieldTypes.only = parseCsv(value);
+          break;
+        case "except":
+          fieldTypes.except = parseCsv(value);
+          break;
+        default:
+          throw new Error(`Invalid select projection: unsupported operator 'fieldTypes[${operator}]'`);
+      }
+    } else if (bucket === "slots") {
+      const slots = (_e = spec.slots) != null ? _e : spec.slots = {};
+      switch (operator) {
+        case "only":
+          slots.only = parseCsv(value);
+          break;
+        case "except":
+          slots.except = parseCsv(value);
+          break;
+        case "depth":
+          slots.depth = parseDepth(value, rawKey);
+          break;
+        default:
+          throw new Error(`Invalid select projection: unsupported operator 'slots[${operator}]'`);
+      }
+    } else {
+      throw new Error(`Invalid select projection key: ${JSON.stringify(rawKey)}`);
+    }
+  }
+  return spec;
+}
+
 // src/PromptClient.ts
-import { ApiClient as ApiClient12 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient13 } from "@uniformdev/context/api";
 var PromptsUrl = "/api/v1/prompts";
-var PromptClient = class extends ApiClient12 {
+var PromptClient = class extends ApiClient13 {
   constructor(options) {
     super(options);
   }
@@ -3201,34 +3493,42 @@ var PromptClient = class extends ApiClient12 {
 };
 
 // src/RelationshipClient.ts
-import { ApiClient as ApiClient13 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient14 } from "@uniformdev/context/api";
 var RELATIONSHIPS_URL = "/api/v1/relationships";
-var RelationshipClient = class extends ApiClient13 {
+var RelationshipClient = class extends ApiClient14 {
   constructor(options) {
     super(options);
-    this.get = async (options) => {
+    this.list = async (options) => {
       const { projectId } = this.options;
       const url = this.createUrl(RELATIONSHIPS_URL, { ...options, projectId });
       return this.apiClient(url);
     };
+    /** @deprecated Use {@link list} instead. */
+    this.get = async (options) => {
+      return this.list(options);
+    };
   }
 };
 
 // src/ReleaseClient.ts
-import { ApiClient as ApiClient14 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient15 } from "@uniformdev/context/api";
 var releasesUrl = "/api/v1/releases";
-var ReleaseClient = class extends ApiClient14 {
+var ReleaseClient = class extends ApiClient15 {
   constructor(options) {
     super(options);
   }
-  /** Fetches all releases for a project */
-  async get(options) {
+  /** Fetches a list of releases for a project */
+  async list(options) {
     const { projectId } = this.options;
     const fetchUri = this.createUrl(releasesUrl, { ...options, projectId });
     return await this.apiClient(fetchUri);
   }
+  /** @deprecated Use {@link list} instead. */
+  async get(options) {
+    return this.list(options);
+  }
   /** Updates or creates (based on id) a release */
-  async upsert(body) {
+  async save(body) {
     const fetchUri = this.createUrl(releasesUrl);
     await this.apiClient(fetchUri, {
       method: "PUT",
@@ -3236,6 +3536,10 @@ var ReleaseClient = class extends ApiClient14 {
       expectNoContent: true
     });
   }
+  /** @deprecated Use {@link save} instead. */
+  async upsert(body) {
+    return this.save(body);
+  }
   /** Deletes a release */
   async remove(body) {
     const fetchUri = this.createUrl(releasesUrl);
@@ -3257,21 +3561,25 @@ var ReleaseClient = class extends ApiClient14 {
 };
 
 // src/ReleaseContentsClient.ts
-import { ApiClient as ApiClient15 } from "@uniformdev/context/api";
-var releaseContentsUrl2 = "/api/v1/release-contents";
-var ReleaseContentsClient = class extends ApiClient15 {
+import { ApiClient as ApiClient16 } from "@uniformdev/context/api";
+var releaseContentsUrl = "/api/v1/release-contents";
+var ReleaseContentsClient = class extends ApiClient16 {
   constructor(options) {
     super(options);
   }
-  /** Fetches all entities added to a release */
-  async get(options) {
+  /** Fetches a list of entities added to a release */
+  async list(options) {
     const { projectId } = this.options;
-    const fetchUri = this.createUrl(releaseContentsUrl2, { ...options, projectId });
+    const fetchUri = this.createUrl(releaseContentsUrl, { ...options, projectId });
     return await this.apiClient(fetchUri);
   }
+  /** @deprecated Use {@link list} instead. */
+  async get(options) {
+    return this.list(options);
+  }
   /** Removes a release content from a release */
   async remove(body) {
-    const fetchUri = this.createUrl(releaseContentsUrl2);
+    const fetchUri = this.createUrl(releaseContentsUrl);
     await this.apiClient(fetchUri, {
       method: "DELETE",
       body: JSON.stringify({ ...body, projectId: this.options.projectId }),
@@ -3281,9 +3589,9 @@ var ReleaseContentsClient = class extends ApiClient15 {
 };
 
 // src/RouteClient.ts
-import { ApiClient as ApiClient16 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient17 } from "@uniformdev/context/api";
 var ROUTE_URL = "/api/v1/route";
-var RouteClient = class extends ApiClient16 {
+var RouteClient = class extends ApiClient17 {
   constructor(options) {
     var _a;
     if (!options.limitPolicy) {
@@ -3292,15 +3600,27 @@ var RouteClient = class extends ApiClient16 {
     super(options);
     this.edgeApiHost = (_a = options.edgeApiHost) != null ? _a : "https://uniform.global";
   }
-  /** Fetches lists of Canvas compositions, optionally by type */
-  async getRoute(options) {
+  /**
+   * Resolves a route to a composition, redirect, or not-found result.
+   *
+   * An optional `select` projection applies to the resolved composition when
+   * the route matches one; redirect / notFound responses pass through
+   * untouched.
+   */
+  async get(options) {
     const { projectId } = this.options;
-    const fetchUri = this.createUrl(ROUTE_URL, { ...options, projectId }, this.edgeApiHost);
+    const { select, ...rest } = options != null ? options : {};
+    const rewrittenSelect = projectionToQuery(select);
+    const fetchUri = this.createUrl(ROUTE_URL, { ...rest, projectId, ...rewrittenSelect }, this.edgeApiHost);
     return await this.apiClient(
       fetchUri,
       this.options.disableSWR ? { headers: { "x-disable-swr": "true" } } : void 0
     );
   }
+  /** @deprecated use {@link RouteClient.get} instead (renamed). */
+  async getRoute(options) {
+    return this.get(options);
+  }
 };
 
 // src/types/locales.ts
@@ -3655,26 +3975,30 @@ function handleRichTextNodeBinding(object, options) {
 }
 
 // src/index.ts
-import { ApiClientError as ApiClientError2 } from "@uniformdev/context/api";
+import { ApiClientError as ApiClientError5 } from "@uniformdev/context/api";
 
 // src/.version.ts
-var version = "20.68.0";
+var version = "20.71.0";
 
 // src/WorkflowClient.ts
-import { ApiClient as ApiClient17 } from "@uniformdev/context/api";
+import { ApiClient as ApiClient18 } from "@uniformdev/context/api";
 var workflowsUrl = "/api/v1/workflows";
-var WorkflowClient = class extends ApiClient17 {
+var WorkflowClient = class extends ApiClient18 {
   constructor(options) {
     super(options);
   }
-  /** Fetches workflows for a project */
-  async get(options) {
+  /** Fetches a list of workflows for a project */
+  async list(options) {
     const { projectId } = this.options;
     const fetchUri = this.createUrl(workflowsUrl, { ...options, projectId });
     return await this.apiClient(fetchUri);
   }
+  /** @deprecated Use {@link list} instead. */
+  async get(options) {
+    return this.list(options);
+  }
   /** Updates or creates a workflow definition */
-  async upsert(body) {
+  async save(body) {
     const fetchUri = this.createUrl(workflowsUrl);
     await this.apiClient(fetchUri, {
       method: "PUT",
@@ -3682,6 +4006,10 @@ var WorkflowClient = class extends ApiClient17 {
       expectNoContent: true
     });
   }
+  /** @deprecated Use {@link save} instead. */
+  async upsert(body) {
+    return this.save(body);
+  }
   /** Deletes a workflow definition */
   async remove(body) {
     const fetchUri = this.createUrl(workflowsUrl);
@@ -3694,7 +4022,7 @@ var WorkflowClient = class extends ApiClient17 {
 };
 
 // src/index.ts
-var CanvasClientError = ApiClientError2;
+var CanvasClientError = ApiClientError5;
 export {
   ASSETS_SOURCE_CUSTOM_URL,
   ASSETS_SOURCE_UNIFORM,
@@ -3705,7 +4033,7 @@ export {
   ATTRIBUTE_PARAMETER_TYPE,
   ATTRIBUTE_PARAMETER_VALUE,
   ATTRIBUTE_PLACEHOLDER,
-  ApiClientError2 as ApiClientError,
+  ApiClientError5 as ApiClientError,
   BatchEntry,
   BlockFormatError,
   CANVAS_BLOCK_PARAM_TYPE,
@@ -3747,7 +4075,11 @@ export {
   CanvasClientError,
   CategoryClient,
   ChildEnhancerBuilder,
+  ComponentDefinitionClient,
+  CompositionDeliveryClient,
+  CompositionManagementClient,
   ContentClient,
+  ContentTypeClient,
   DataSourceClient,
   DataTypeClient,
   EDGE_CACHE_DISABLED,
@@ -3757,6 +4089,8 @@ export {
   EMPTY_COMPOSITION,
   EnhancerBuilder,
   EntityReleasesClient,
+  EntryDeliveryClient,
+  EntryManagementClient,
   IN_CONTEXT_EDITOR_COMPONENT_END_ROLE,
   IN_CONTEXT_EDITOR_COMPONENT_START_ROLE,
   IN_CONTEXT_EDITOR_CONFIG_CHECK_QUERY_STRING_PARAM,
@@ -3779,6 +4113,7 @@ export {
   ReleaseContentsClient,
   RouteClient,
   SECRET_QUERY_STRING_PARAM,
+  SELECT_QUERY_PREFIX,
   UncachedCanvasClient,
   UncachedCategoryClient,
   UncachedContentClient,
@@ -3860,10 +4195,13 @@ export {
   localize,
   mapSlotToPersonalizedVariations,
   mapSlotToTestVariations,
+  matchesProjectionPattern,
   mergeAssetConfigWithDefaults,
   nullLimitPolicy,
   parseComponentPlaceholderId,
   parseVariableExpression,
+  projectionToQuery,
+  queryToProjection,
   version,
   walkNodeTree,
   walkPropertyValues