@uniformdev/canvas 20.48.1-alpha.28 → 20.48.1-alpha.48.sha-989c5a3792

package/dist/index.js

@@ -8,9 +8,6 @@ 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 __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -36,358 +33,9 @@ var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot
 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"(exports2, module2) {
-    "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;
-        }
-      }
-    };
-    module2.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"(exports2, module2) {
-    "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;
-    };
-    module2.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"(exports2, module2) {
-    "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);
-      }
-    }
-    module2.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"(exports2) {
-    "use strict";
-    var RetryOperation = require_retry_operation();
-    exports2.operation = function(options) {
-      var timeouts = exports2.timeouts(options);
-      return new RetryOperation(timeouts, {
-        forever: options && (options.forever || options.retries === Infinity),
-        unref: options && options.unref,
-        maxRetryTime: options && options.maxRetryTime
-      });
-    };
-    exports2.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;
-    };
-    exports2.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;
-    };
-    exports2.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 = exports2.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"(exports2, module2) {
-    "use strict";
-    module2.exports = require_retry();
-  }
-});
-
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   ASSETS_SOURCE_CUSTOM_URL: () => ASSETS_SOURCE_CUSTOM_URL,
   ASSETS_SOURCE_UNIFORM: () => ASSETS_SOURCE_UNIFORM,
   ASSET_PARAMETER_TYPE: () => ASSET_PARAMETER_TYPE,
@@ -397,7 +45,7 @@ __export(src_exports, {
   ATTRIBUTE_PARAMETER_TYPE: () => ATTRIBUTE_PARAMETER_TYPE,
   ATTRIBUTE_PARAMETER_VALUE: () => ATTRIBUTE_PARAMETER_VALUE,
   ATTRIBUTE_PLACEHOLDER: () => ATTRIBUTE_PLACEHOLDER,
-  ApiClientError: () => import_api18.ApiClientError,
+  ApiClientError: () => import_api27.ApiClientError,
   BatchEntry: () => BatchEntry,
   BlockFormatError: () => BlockFormatError,
   CANVAS_BLOCK_PARAM_TYPE: () => CANVAS_BLOCK_PARAM_TYPE,
@@ -439,7 +87,11 @@ __export(src_exports, {
   CanvasClientError: () => CanvasClientError,
   CategoryClient: () => CategoryClient,
   ChildEnhancerBuilder: () => ChildEnhancerBuilder,
+  ComponentDefinitionClient: () => ComponentDefinitionClient,
+  CompositionDeliveryClient: () => CompositionDeliveryClient,
+  CompositionManagementClient: () => CompositionManagementClient,
   ContentClient: () => ContentClient,
+  ContentTypeClient: () => ContentTypeClient,
   DataSourceClient: () => DataSourceClient,
   DataTypeClient: () => DataTypeClient,
   EDGE_CACHE_DISABLED: () => EDGE_CACHE_DISABLED,
@@ -449,6 +101,8 @@ __export(src_exports, {
   EMPTY_COMPOSITION: () => EMPTY_COMPOSITION,
   EnhancerBuilder: () => EnhancerBuilder,
   EntityReleasesClient: () => EntityReleasesClient,
+  EntryDeliveryClient: () => EntryDeliveryClient,
+  EntryManagementClient: () => EntryManagementClient,
   IN_CONTEXT_EDITOR_COMPONENT_END_ROLE: () => IN_CONTEXT_EDITOR_COMPONENT_END_ROLE,
   IN_CONTEXT_EDITOR_COMPONENT_START_ROLE: () => IN_CONTEXT_EDITOR_COMPONENT_START_ROLE,
   IN_CONTEXT_EDITOR_CONFIG_CHECK_QUERY_STRING_PARAM: () => IN_CONTEXT_EDITOR_CONFIG_CHECK_QUERY_STRING_PARAM,
@@ -459,19 +113,23 @@ __export(src_exports, {
   IS_RENDERED_BY_UNIFORM_ATTRIBUTE: () => IS_RENDERED_BY_UNIFORM_ATTRIBUTE,
   IntegrationPropertyEditorsClient: () => IntegrationPropertyEditorsClient,
   LOCALE_DYNAMIC_INPUT_NAME: () => LOCALE_DYNAMIC_INPUT_NAME,
+  LabelClient: () => LabelClient,
   LocaleClient: () => LocaleClient,
   PLACEHOLDER_ID: () => PLACEHOLDER_ID,
   PreviewClient: () => PreviewClient,
   ProjectClient: () => ProjectClient,
   PromptClient: () => PromptClient,
+  REFERENCE_DATA_TYPE_ID: () => REFERENCE_DATA_TYPE_ID,
   RelationshipClient: () => RelationshipClient,
   ReleaseClient: () => ReleaseClient,
   ReleaseContentsClient: () => ReleaseContentsClient,
   RouteClient: () => RouteClient,
   SECRET_QUERY_STRING_PARAM: () => SECRET_QUERY_STRING_PARAM,
+  SELECT_QUERY_PREFIX: () => SELECT_QUERY_PREFIX,
   UncachedCanvasClient: () => UncachedCanvasClient,
   UncachedCategoryClient: () => UncachedCategoryClient,
   UncachedContentClient: () => UncachedContentClient,
+  UncachedLabelClient: () => UncachedLabelClient,
   UniqueBatchEntries: () => UniqueBatchEntries,
   WorkflowClient: () => WorkflowClient,
   autoFixParameterGroups: () => autoFixParameterGroups,
@@ -518,6 +176,7 @@ __export(src_exports, {
   isAllowedReferrer: () => isAllowedReferrer,
   isAssetParamValue: () => isAssetParamValue,
   isAssetParamValueItem: () => isAssetParamValueItem,
+  isAwaitingReadyMessage: () => isAwaitingReadyMessage,
   isComponentActionMessage: () => isComponentActionMessage,
   isComponentPlaceholderId: () => isComponentPlaceholderId,
   isContextStorageUpdatedMessage: () => isContextStorageUpdatedMessage,
@@ -533,6 +192,7 @@ __export(src_exports, {
   isRootEntryReference: () => isRootEntryReference,
   isSelectComponentMessage: () => isSelectComponentMessage,
   isSelectParameterMessage: () => isSelectParameterMessage,
+  isSessionPendingMessage: () => isSessionPendingMessage,
   isSuggestComponentMessage: () => isSuggestComponentMessage,
   isSystemComponentDefinition: () => isSystemComponentDefinition,
   isTriggerCompositionActionMessage: () => isTriggerCompositionActionMessage,
@@ -547,240 +207,757 @@ __export(src_exports, {
   localize: () => localize,
   mapSlotToPersonalizedVariations: () => mapSlotToPersonalizedVariations,
   mapSlotToTestVariations: () => mapSlotToTestVariations,
+  matchesProjectionPattern: () => matchesProjectionPattern,
   mergeAssetConfigWithDefaults: () => mergeAssetConfigWithDefaults,
   nullLimitPolicy: () => nullLimitPolicy,
   parseComponentPlaceholderId: () => parseComponentPlaceholderId,
   parseVariableExpression: () => parseVariableExpression,
+  projectionToQuery: () => projectionToQuery,
+  queryToProjection: () => queryToProjection,
   version: () => version,
   walkNodeTree: () => walkNodeTree,
   walkPropertyValues: () => walkPropertyValues
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
-// src/CanvasClient.ts
+// src/CategoryClient.ts
 var import_api2 = require("@uniformdev/context/api");
 
 // src/enhancement/createLimitPolicy.ts
 var import_api = require("@uniformdev/context/api");
-var import_p_limit = __toESM(require_p_limit());
-
-// ../../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;
+var import_p_limit = __toESM(require("p-limit"));
+var import_p_retry = __toESM(require("p-retry"));
+var import_p_throttle = __toESM(require("p-throttle"));
+function createLimitPolicy({
+  throttle = { interval: 1e3, limit: 10 },
+  retry = { retries: 1, factor: 1.66 },
+  limit = 10
+}) {
+  const throttler = throttle ? (0, import_p_throttle.default)(throttle) : null;
+  const limiter = limit ? (0, import_p_limit.default)(limit) : null;
+  return function limitPolicy(func) {
+    let currentFunc = async () => await func();
+    if (throttler) {
+      const throttleFunc = currentFunc;
+      currentFunc = throttler(throttleFunc);
+    }
+    if (limiter) {
+      const limitFunc = currentFunc;
+      currentFunc = () => limiter(limitFunc);
+    }
+    if (retry) {
+      const retryFunc = currentFunc;
+      currentFunc = () => (0, import_p_retry.default)(retryFunc, {
+        ...retry,
+        onFailedAttempt: async (error) => {
+          if (retry.onFailedAttempt) {
+            await retry.onFailedAttempt(error);
+          }
+          if (error instanceof import_api.ApiClientError && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
+            throw error;
+          }
+        }
+      });
+    }
+    return currentFunc();
+  };
+}
+var nullLimitPolicy = async (func) => await func();
+
+// src/CategoryClient.ts
+var CATEGORIES_URL = "/api/v1/categories";
+var CategoryClient = class extends import_api2.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
+var import_api4 = require("@uniformdev/context/api");
+
+// src/clients/ContentClientBase.ts
+var import_api3 = require("@uniformdev/context/api");
+var CANONICAL_FORMAT = "canonical";
+var ContentClientBase = class extends import_api3.ApiClient {
+  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 import_api4.ApiClientError("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
+var import_api5 = require("@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 (fields.blockDepth === "preserveAll" || typeof fields.blockDepth === "number") {
+      out[`${p}fields[blockDepth]`] = String(fields.blockDepth);
+    }
+  }
+  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,
+        ...(0, import_api5.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
+var import_api6 = require("@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,
+      ...(0, import_api6.rewriteFiltersForApi)(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
+var import_api7 = require("@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 import_api7.ApiClientError("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;
     }
-    this.name = "AbortError";
-    this.message = message;
+    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
+    });
   }
 };
-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
+
+// src/clients/EntryDeliveryClient.ts
+var import_api9 = require("@uniformdev/context/api");
+
+// src/clients/entryHelpers.ts
+var import_api8 = require("@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 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
-      });
-    }
-  });
+  }
+  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 import_api8.ApiClientError("Entry not found", "GET", url.toString(), 404, "Not Found");
+  }
+  return entry;
 }
 
-// ../../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";
+// src/clients/EntryDeliveryClient.ts
+var ENTRIES_URL = "/api/v1/entries";
+var EntryDeliveryClient = class extends DeliveryClientBase {
+  constructor(options) {
+    super(options);
   }
-};
-function pThrottle({ limit, interval, strict }) {
-  if (!Number.isFinite(limit)) {
-    throw new TypeError("Expected `limit` to be a finite number");
+  /** 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);
   }
-  if (!Number.isFinite(interval)) {
-    throw new TypeError("Expected `interval` to be a finite number");
+  /** Fetches a list of entries, optionally filtered. */
+  list(args = {}) {
+    var _a;
+    const { diagnostics, filters, select, ...rest } = args;
+    const url = this.createUrl(
+      ENTRIES_URL,
+      {
+        ...rest,
+        ...(0, import_api9.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);
   }
-  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
-function createLimitPolicy({
-  throttle = { interval: 1e3, limit: 10 },
-  retry: retry2 = { retries: 1, factor: 1.66 },
-  limit = 10
-}) {
-  const throttler = throttle ? pThrottle(throttle) : null;
-  const limiter = limit ? (0, import_p_limit.default)(limit) : null;
-  return function limitPolicy(func) {
-    let currentFunc = async () => await func();
-    if (throttler) {
-      const throttleFunc = currentFunc;
-      currentFunc = throttler(throttleFunc);
-    }
-    if (limiter) {
-      const limitFunc = currentFunc;
-      currentFunc = () => limiter(limitFunc);
-    }
-    if (retry2) {
-      const retryFunc = currentFunc;
-      currentFunc = () => pRetry(retryFunc, {
-        ...retry2,
-        onFailedAttempt: async (error) => {
-          if (retry2.onFailedAttempt) {
-            await retry2.onFailedAttempt(error);
-          }
-          if (error instanceof import_api.ApiClientError && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
-            throw error;
-          }
-        }
-      });
+// src/clients/EntryManagementClient.ts
+var import_api10 = require("@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,
+      ...(0, import_api10.rewriteFiltersForApi)(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;
     }
-    return currentFunc();
-  };
-}
-var nullLimitPolicy = async (func) => await func();
-
-// src/utils/rewriteFilters.ts
-var isPlainObject = (obj) => typeof obj === "object" && obj !== null && !Array.isArray(obj);
-function rewriteFilters(filters) {
-  return Object.entries(filters != null ? filters : {}).reduce(
-    (acc, [key, value]) => {
-      const lhs = `filters.${key}` + (isPlainObject(value) ? `[${Object.keys(value)[0]}]` : "");
-      const rhs = isPlainObject(value) ? Object.values(value)[0] : value;
-      return {
-        ...acc,
-        [lhs]: Array.isArray(rhs) ? rhs.map((v) => `${v}`.trim()).join(",") : `${rhs}`.trim()
-      };
-    },
-    {}
-  );
-}
+    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/CanvasClient.ts
-var CANVAS_URL = "/api/v1/canvas";
-var CanvasClient = class extends import_api2.ApiClient {
+// src/clients/deprecated/CanvasClient.ts
+var import_api11 = require("@uniformdev/context/api");
+var CANVAS_URL2 = "/api/v1/canvas";
+var CanvasClient = class extends import_api11.ApiClient {
   constructor(options) {
     var _a;
     if (!options.limitPolicy) {
@@ -793,17 +970,24 @@ var CanvasClient = class extends import_api2.ApiClient {
   /** Fetches lists of Canvas compositions, optionally by type */
   async getCompositionList(params = {}) {
     const { projectId } = this.options;
-    const { resolveData, filters, ...originParams } = params;
-    const rewrittenFilters = rewriteFilters(filters);
+    const { resolveData, filters, select, ...originParams } = params;
+    const rewrittenFilters = (0, import_api11.rewriteFiltersForApi)(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);
@@ -838,7 +1022,7 @@ var CanvasClient = class extends import_api2.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,
@@ -850,7 +1034,7 @@ var CanvasClient = class extends import_api2.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;
@@ -865,7 +1049,7 @@ var CanvasClient = class extends import_api2.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",
@@ -904,53 +1088,10 @@ var UncachedCanvasClient = class extends CanvasClient {
   }
 };
 
-// src/CategoryClient.ts
-var import_api3 = require("@uniformdev/context/api");
-var CATEGORIES_URL = "/api/v1/categories";
-var CategoryClient = class extends import_api3.ApiClient {
-  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
-var import_api4 = require("@uniformdev/context/api");
+// src/clients/deprecated/ContentClient.ts
+var import_api12 = require("@uniformdev/context/api");
 var _contentTypesUrl, _entriesUrl;
-var _ContentClient = class _ContentClient extends import_api4.ApiClient {
+var _ContentClient = class _ContentClient extends import_api12.ApiClient {
   constructor(options) {
     var _a;
     super(options);
@@ -963,15 +1104,21 @@ var _ContentClient = class _ContentClient extends import_api4.ApiClient {
   }
   getEntries(options) {
     const { projectId } = this.options;
-    const { skipDataResolution, filters, ...params } = options;
-    const rewrittenFilters = rewriteFilters(filters);
+    const { skipDataResolution, filters, select, ...params } = options;
+    const rewrittenFilters = (0, import_api12.rewriteFiltersForApi)(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(
@@ -1051,27 +1198,31 @@ var UncachedContentClient = class extends ContentClient {
 };
 
 // src/DataSourceClient.ts
-var import_api5 = require("@uniformdev/context/api");
+var import_api13 = require("@uniformdev/context/api");
 var dataSourceUrl = "/api/v1/data-source";
 var dataSourcesUrl = "/api/v1/data-sources";
-var DataSourceClient = class extends import_api5.ApiClient {
+var DataSourceClient = class extends import_api13.ApiClient {
   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",
@@ -1079,6 +1230,10 @@ var DataSourceClient = class extends import_api5.ApiClient {
       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);
@@ -1091,20 +1246,24 @@ var DataSourceClient = class extends import_api5.ApiClient {
 };
 
 // src/DataTypeClient.ts
-var import_api6 = require("@uniformdev/context/api");
+var import_api14 = require("@uniformdev/context/api");
 var _url;
-var _DataTypeClient = class _DataTypeClient extends import_api6.ApiClient {
+var _DataTypeClient = class _DataTypeClient extends import_api14.ApiClient {
   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",
@@ -1112,6 +1271,10 @@ var _DataTypeClient = class _DataTypeClient extends import_api6.ApiClient {
       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));
@@ -1144,7 +1307,7 @@ var BatchEntry = class {
     this._reject(reason);
     this._isCompleted = true;
   }
-  /** @return Whether the batch entry has been completed (resolved or rejected). */
+  /** @returns Whether the batch entry has been completed (resolved or rejected). */
   get isCompleted() {
     return this._isCompleted;
   }
@@ -1247,60 +1410,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";
-
 // src/utils/guards.ts
 function isRootEntryReference(root) {
   return root.type === "root" && isEntryData(root.node);
@@ -1367,10 +1476,12 @@ function flattenSingleNodeValues(data, options = {}) {
   ) : properties;
 }
 
-// src/utils/variables/parseVariableExpression.ts
-var escapeCharacter = "\\";
+// src/utils/variables/variableSyntax.ts
 var variablePrefix = "${";
 var variableSuffix = "}";
+
+// src/utils/variables/parseVariableExpression.ts
+var escapeCharacter = "\\";
 function parseVariableExpression(serialized, onToken) {
   if (typeof serialized !== "string") {
     throw new TypeError("Variable expression must be a string");
@@ -1378,9 +1489,9 @@ function parseVariableExpression(serialized, onToken) {
   let bufferStartIndex = 0;
   let bufferEndIndex = 0;
   let tokenCount = 0;
-  const handleToken = (token, type) => {
+  const handleToken = (token, type, offset) => {
     tokenCount++;
-    return onToken == null ? void 0 : onToken(token, type);
+    return onToken == null ? void 0 : onToken(token, type, offset);
   };
   let state = "text";
   for (let index = 0; index < serialized.length; index++) {
@@ -1391,20 +1502,26 @@ function parseVariableExpression(serialized, onToken) {
     if (char === variablePrefix[0] && serialized[index + 1] === variablePrefix[1]) {
       if (serialized[index - 1] === escapeCharacter) {
         bufferEndIndex -= escapeCharacter.length;
-        if (handleToken(serialized.substring(bufferStartIndex, bufferEndIndex), "text") === false) {
+        if (handleToken(serialized.substring(bufferStartIndex, bufferEndIndex), "text", bufferStartIndex) === false) {
           return tokenCount;
         }
         bufferStartIndex = index;
         bufferEndIndex = index + 1;
         continue;
       }
-      state = "variable";
-      if (bufferEndIndex > bufferStartIndex) {
-        if (handleToken(serialized.substring(bufferStartIndex, bufferEndIndex), "text") === false) {
+      if (state === "variable") {
+        const textStart = bufferStartIndex - variablePrefix.length;
+        if (handleToken(serialized.substring(textStart, bufferEndIndex), "text", textStart) === false) {
+          return tokenCount;
+        }
+        bufferStartIndex = bufferEndIndex;
+      } else if (bufferEndIndex > bufferStartIndex) {
+        if (handleToken(serialized.substring(bufferStartIndex, bufferEndIndex), "text", bufferStartIndex) === false) {
           return tokenCount;
         }
         bufferStartIndex = bufferEndIndex;
       }
+      state = "variable";
       index += variablePrefix.length - 1;
       bufferStartIndex += variablePrefix.length;
       continue;
@@ -1417,7 +1534,7 @@ function parseVariableExpression(serialized, onToken) {
       state = "text";
       if (bufferEndIndex > bufferStartIndex) {
         const unescapedVariableName = serialized.substring(bufferStartIndex, bufferEndIndex).replace(/\\([${}])/g, "$1");
-        if (handleToken(unescapedVariableName, "variable") === false) {
+        if (handleToken(unescapedVariableName, "variable", bufferStartIndex) === false) {
           return tokenCount;
         }
         bufferStartIndex = bufferEndIndex + variableSuffix.length;
@@ -1426,12 +1543,12 @@ function parseVariableExpression(serialized, onToken) {
     }
     bufferEndIndex++;
   }
-  if (bufferEndIndex > bufferStartIndex) {
-    if (state === "variable") {
-      state = "text";
-      bufferStartIndex -= variablePrefix.length;
-    }
-    handleToken(serialized.substring(bufferStartIndex), state);
+  if (state === "variable") {
+    state = "text";
+    bufferStartIndex -= variablePrefix.length;
+  }
+  if (bufferStartIndex < serialized.length) {
+    handleToken(serialized.substring(bufferStartIndex), state, bufferStartIndex);
   }
   return tokenCount;
 }
@@ -1452,7 +1569,7 @@ function hasReferencedVariables(value) {
 
 // src/enhancement/walkNodeTree.ts
 function walkNodeTree(node, visitor, options) {
-  var _a, _b;
+  var _a, _b, _c;
   const componentQueue = [
     {
       ancestorsAndSelf: Array.isArray(node) ? node : [{ node, type: "root" }],
@@ -1460,12 +1577,14 @@ function walkNodeTree(node, visitor, options) {
     }
   ];
   const childContexts = /* @__PURE__ */ new Map();
+  const order = (_a = options == null ? void 0 : options.order) != null ? _a : "dfs";
+  const takeNext = () => order === "bfs" ? componentQueue.shift() : componentQueue.pop();
   do {
-    const currentQueueEntry = componentQueue.pop();
+    const currentQueueEntry = takeNext();
     if (!currentQueueEntry) continue;
     const currentComponent = currentQueueEntry.ancestorsAndSelf[0];
     let visitDescendants = true;
-    let descendantContext = (_a = childContexts.get(currentComponent.node)) != null ? _a : currentQueueEntry.context;
+    let descendantContext = (_b = childContexts.get(currentComponent.node)) != null ? _b : currentQueueEntry.context;
     let visitorInfo;
     if (currentComponent.type === "root" && isRootEntryReference(currentComponent) || currentComponent.type === "block") {
       visitorInfo = {
@@ -1567,7 +1686,8 @@ function walkNodeTree(node, visitor, options) {
               "_dataResources",
               "_overridability",
               "_overrides",
-              "_patternDataResources"
+              "_patternDataResources",
+              "_patternOptedInQueryStrings"
             ];
             propertiesToCheck.forEach((property) => {
               if (!replacementComponent[property]) {
@@ -1652,39 +1772,11 @@ function walkNodeTree(node, visitor, options) {
       continue;
     }
     const slots = "slots" in currentComponent.node && currentComponent.node.slots;
-    if (slots) {
-      const slotKeys = Object.keys(slots);
-      for (let slotIndex = slotKeys.length - 1; slotIndex >= 0; slotIndex--) {
-        const slotKey = slotKeys[slotIndex];
-        const components = slots[slotKey];
-        for (let componentIndex = components.length - 1; componentIndex >= 0; componentIndex--) {
-          const enqueueingComponent = components[componentIndex];
-          const parentSlotIndexFn = () => {
-            const result = currentComponent.node.slots[slotKey].findIndex(
-              (x) => x === enqueueingComponent
-            );
-            return result;
-          };
-          componentQueue.push({
-            ancestorsAndSelf: [
-              {
-                type: "slot",
-                node: enqueueingComponent,
-                parentSlot: slotKey,
-                parentSlotIndexFn
-              },
-              ...currentQueueEntry.ancestorsAndSelf
-            ],
-            context: descendantContext
-          });
-        }
-      }
-    }
+    const childEntries = [];
     const properties = getPropertiesValue(currentComponent.node);
     if (properties) {
       const propertyEntries = Object.entries(properties);
-      for (let propIndex = propertyEntries.length - 1; propIndex >= 0; propIndex--) {
-        const [propKey, propObject] = propertyEntries[propIndex];
+      for (const [propKey, propObject] of propertyEntries) {
         if (!isNestedNodeType(propObject.type)) {
           continue;
         }
@@ -1704,13 +1796,12 @@ function walkNodeTree(node, visitor, options) {
             continue;
           }
         }
-        const blocks = (_b = propObject.value) != null ? _b : [];
-        for (let blockIndex = blocks.length - 1; blockIndex >= 0; blockIndex--) {
-          const enqueueingBlock = blocks[blockIndex];
+        const blocks = (_c = propObject.value) != null ? _c : [];
+        for (const enqueueingBlock of blocks) {
           const blockIndexFn = () => {
             return getBlockValue(currentComponent.node, propKey).findIndex((x) => x === enqueueingBlock);
           };
-          componentQueue.push({
+          childEntries.push({
             ancestorsAndSelf: [
               {
                 type: "block",
@@ -1725,6 +1816,36 @@ function walkNodeTree(node, visitor, options) {
         }
       }
     }
+    if (slots) {
+      const slotKeys = Object.keys(slots);
+      for (const slotKey of slotKeys) {
+        const components = slots[slotKey];
+        for (const enqueueingComponent of components) {
+          const parentSlotIndexFn = () => {
+            const result = currentComponent.node.slots[slotKey].findIndex(
+              (x) => x === enqueueingComponent
+            );
+            return result;
+          };
+          childEntries.push({
+            ancestorsAndSelf: [
+              {
+                type: "slot",
+                node: enqueueingComponent,
+                parentSlot: slotKey,
+                parentSlotIndexFn
+              },
+              ...currentQueueEntry.ancestorsAndSelf
+            ],
+            context: descendantContext
+          });
+        }
+      }
+    }
+    if (order === "dfs") {
+      childEntries.reverse();
+    }
+    componentQueue.push(...childEntries);
   } while (componentQueue.length > 0);
 }
 function isNestedNodeType(type) {
@@ -2150,7 +2271,7 @@ function getLocaleMatch(index, locale, greedy) {
   }
   const match = index[locale];
   if (match === void 0 && greedy) {
-    return Object.values(index)[0];
+    return Object.values(index).find((value) => value !== void 0);
   }
   return match;
 }
@@ -2158,6 +2279,9 @@ function getLocaleMatch(index, locale, greedy) {
 // src/enhancement/visibility/evaluateVisibilityCriteriaGroup.ts
 function evaluateVisibilityCriteriaGroup(options) {
   const { criteriaGroup, simplifyCriteria } = options;
+  if (criteriaGroup.clauses.length === 0) {
+    return true;
+  }
   const earlyExitResult = criteriaGroup.op === "&" || !criteriaGroup.op ? false : true;
   let hasIndeterminateClauses = false;
   for (let index = criteriaGroup.clauses.length - 1; index >= 0; index--) {
@@ -2166,6 +2290,9 @@ function evaluateVisibilityCriteriaGroup(options) {
     if (criteriaResult === null) {
       hasIndeterminateClauses = true;
     } else if (criteriaResult === earlyExitResult) {
+      if (simplifyCriteria && earlyExitResult) {
+        criteriaGroup.clauses.splice(0);
+      }
       return earlyExitResult;
     } else if (criteriaResult !== null && simplifyCriteria) {
       criteriaGroup.clauses.splice(index, 1);
@@ -2353,7 +2480,11 @@ function evaluateWalkTreePropertyCriteria({
         delete properties[propertyName];
       }
     } else {
-      const { currentValue, remainingConditionalValues } = evaluatePropertyCriteria({
+      const { currentValue, remainingConditionalValues } = property.conditions === void 0 ? (
+        // most properties have no conditions: this is what evaluatePropertyCriteria returns for them,
+        // without the cost of calling it for every property
+        { currentValue: property.value, remainingConditionalValues: void 0 }
+      ) : evaluatePropertyCriteria({
         baseValue: property.value,
         conditionalValues: property.conditions,
         rules,
@@ -2413,11 +2544,34 @@ var stringOperatorEvaluators = {
   endswith: endsWithEvaluator,
   empty: emptyEvaluator
 };
+var numericOperatorEvaluators = {
+  gt: (left, right) => left > right,
+  lt: (left, right) => left < right
+};
+function evaluateNumericOperator(criteria, matchValue) {
+  const { op, value } = criteria;
+  const evaluator = numericOperatorEvaluators[op];
+  if (!evaluator) {
+    return null;
+  }
+  if (typeof matchValue === "string" && matchValue.trim() === "" || typeof value === "string" && value.trim() === "") {
+    return false;
+  }
+  const leftNum = Number(matchValue);
+  const rightNum = Number(value);
+  if (isNaN(leftNum) || isNaN(rightNum)) {
+    return false;
+  }
+  return evaluator(leftNum, rightNum);
+}
 function evaluateStringMatch(criteria, matchValue, allow) {
   const { op, value } = criteria;
   if (allow && !allow.has(op)) {
     return null;
   }
+  if (op in numericOperatorEvaluators) {
+    return evaluateNumericOperator(criteria, matchValue);
+  }
   let opMatch = op;
   const negation = op.startsWith("!");
   if (negation) {
@@ -2466,17 +2620,49 @@ var dynamicTokenVisibilityOperators = /* @__PURE__ */ new Set([
   "endswith",
   "!endswith",
   "empty",
-  "!empty"
+  "!empty",
+  "gt",
+  "lt"
 ]);
 var CANVAS_VIZ_DYNAMIC_TOKEN_RULE = "$dt";
+function toStringValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return "";
+}
+function toStringCriteriaValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((v) => toStringValue(v));
+  }
+  return toStringValue(value);
+}
+function isUnbound(value) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (typeof value === "string") {
+    return hasReferencedVariables(value) > 0;
+  }
+  return false;
+}
 function createDynamicTokenVisibilityRule() {
   return {
     [CANVAS_VIZ_DYNAMIC_TOKEN_RULE]: (criterion) => {
-      var _a;
-      if (typeof criterion.source !== "string" || hasReferencedVariables(criterion.source)) {
+      const { source, value } = criterion;
+      if (isUnbound(source)) {
         return null;
       }
-      return evaluateStringMatch(criterion, (_a = criterion.source) != null ? _a : "", dynamicTokenVisibilityOperators);
+      const stringSource = toStringValue(source);
+      const stringValue = toStringCriteriaValue(value);
+      const stringCriterion = {
+        ...criterion,
+        value: stringValue
+      };
+      return evaluateStringMatch(stringCriterion, stringSource, dynamicTokenVisibilityOperators);
     }
   };
 }
@@ -2535,8 +2721,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;
   }
@@ -2544,7 +2729,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({
@@ -2565,7 +2750,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);
@@ -2576,7 +2761,7 @@ function localize(options) {
         actions.remove();
       }
     } else {
-      localizeProperties(node, locale, vizControlLocaleRule);
+      localizeProperties(node, locale, vizControlLocaleRule, keepLocalesFor);
     }
   });
 }
@@ -2595,7 +2780,7 @@ function removeLocaleProperty(component) {
     }
   }
 }
-function localizeProperties(node, locale, rules) {
+function localizeProperties(node, locale, rules, keepLocalesFor) {
   const properties = getPropertiesValue(node);
   if (!properties) {
     return void 0;
@@ -2614,10 +2799,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({
@@ -2685,24 +2876,28 @@ function walkPropertyValues(property, visitor) {
 }
 
 // src/EntityReleasesClient.ts
-var import_api7 = require("@uniformdev/context/api");
-var releaseContentsUrl = "/api/v1/entity-releases";
-var EntityReleasesClient = class extends import_api7.ApiClient {
+var import_api15 = require("@uniformdev/context/api");
+var entityReleasesUrl = "/api/v1/entity-releases";
+var EntityReleasesClient = class extends import_api15.ApiClient {
   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
-var import_api8 = require("@uniformdev/context/api");
+var import_api16 = require("@uniformdev/context/api");
 var _baseUrl;
-var _IntegrationPropertyEditorsClient = class _IntegrationPropertyEditorsClient extends import_api8.ApiClient {
+var _IntegrationPropertyEditorsClient = class _IntegrationPropertyEditorsClient extends import_api16.ApiClient {
   constructor(options) {
     super(options);
     this.teamId = options.teamId;
@@ -2744,21 +2939,74 @@ _baseUrl = new WeakMap();
 __privateAdd(_IntegrationPropertyEditorsClient, _baseUrl, "/api/v1/integration-property-editors");
 var IntegrationPropertyEditorsClient = _IntegrationPropertyEditorsClient;
 
+// src/LabelClient.ts
+var import_api17 = require("@uniformdev/context/api");
+var LABELS_URL = "/api/v1/labels";
+var LabelClient = class extends import_api17.ApiClient {
+  /** 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 save(body) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(LABELS_URL);
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId }),
+      expectNoContent: true
+    });
+  }
+  /** @deprecated Use {@link save} instead. */
+  async upsertLabel(body) {
+    return this.save(body);
+  }
+  /** Deletes a label by id. */
+  async remove(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(LABELS_URL);
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...options, projectId }),
+      expectNoContent: true
+    });
+  }
+  /** @deprecated Use {@link remove} instead. */
+  async removeLabel(options) {
+    return this.remove(options);
+  }
+};
+var UncachedLabelClient = class extends LabelClient {
+  constructor(options) {
+    super({ ...options, bypassCache: true });
+  }
+};
+
 // src/LocaleClient.ts
-var import_api9 = require("@uniformdev/context/api");
+var import_api18 = require("@uniformdev/context/api");
 var localesUrl = "/api/v1/locales";
-var LocaleClient = class extends import_api9.ApiClient {
+var LocaleClient = class extends import_api18.ApiClient {
   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",
@@ -2766,6 +3014,10 @@ var LocaleClient = class extends import_api9.ApiClient {
       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);
@@ -2802,6 +3054,12 @@ var isSelectComponentMessage = (message) => {
 var isReadyMessage = (message) => {
   return message.type === "ready";
 };
+var isSessionPendingMessage = (message) => {
+  return message.type === "session-pending";
+};
+var isAwaitingReadyMessage = (message) => {
+  return message.type === "awaiting-ready";
+};
 var isComponentActionMessage = (message) => {
   return message.type === "trigger-component-action";
 };
@@ -2904,6 +3162,14 @@ var createCanvasChannel = ({
     };
     postMessage(message);
   };
+  const sessionPending = () => {
+    const message = { type: "session-pending" };
+    postMessage(message);
+  };
+  const awaitingReady = () => {
+    const message = { type: "awaiting-ready" };
+    postMessage(message);
+  };
   const on = (types, handler) => {
     const handlerId = ++handlerCounter;
     handlers[handlerId] = {
@@ -3103,6 +3369,8 @@ var createCanvasChannel = ({
   return {
     broadcastTo: broadcastToItems,
     ready,
+    sessionPending,
+    awaitingReady,
     destroy,
     addBroadcastTarget,
     triggerComponentAction,
@@ -3133,10 +3401,10 @@ var createCanvasChannel = ({
 };
 
 // src/PreviewClient.ts
-var import_api10 = require("@uniformdev/context/api");
+var import_api19 = require("@uniformdev/context/api");
 var previewUrlsUrl = "/api/v1/preview-urls";
 var previewViewportsUrl = "/api/v1/preview-viewports";
-var PreviewClient = class extends import_api10.ApiClient {
+var PreviewClient = class extends import_api19.ApiClient {
   constructor(options) {
     super(options);
   }
@@ -3199,9 +3467,9 @@ var PreviewClient = class extends import_api10.ApiClient {
 };
 
 // src/ProjectClient.ts
-var import_api11 = require("@uniformdev/context/api");
-var _url2;
-var _ProjectClient = class _ProjectClient extends import_api11.ApiClient {
+var import_api20 = require("@uniformdev/context/api");
+var _url2, _projectsUrl;
+var _ProjectClient = class _ProjectClient extends import_api20.ApiClient {
   constructor(options) {
     super({ ...options, bypassCache: true });
   }
@@ -3210,16 +3478,33 @@ var _ProjectClient = class _ProjectClient extends import_api11.ApiClient {
     const fetchUri = this.createUrl(__privateGet(_ProjectClient, _url2), { ...options });
     return await this.apiClient(fetchUri);
   }
+  /**
+   * Fetches projects grouped by team.
+   * When teamId is provided, returns a single team with its projects.
+   * When omitted, returns all accessible teams and their projects.
+   */
+  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",
@@ -3227,15 +3512,203 @@ var _ProjectClient = class _ProjectClient extends import_api11.ApiClient {
       expectNoContent: true
     });
   }
+  /** @deprecated Use {@link remove} instead. */
+  async delete(body) {
+    return this.remove(body);
+  }
 };
 _url2 = new WeakMap();
+_projectsUrl = new WeakMap();
 __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 parseBlockDepth(value, key) {
+  const str = toStringValue2(value);
+  if (str === "preserveAll") {
+    return "preserveAll";
+  }
+  if (str === void 0 || str === "" || !/^\d+$/.test(str)) {
+    throw new Error(
+      `Invalid select projection: '${key}' must be a non-negative integer or 'preserveAll' (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;
+        case "blockDepth":
+          fields.blockDepth = parseBlockDepth(value, rawKey);
+          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
-var import_api12 = require("@uniformdev/context/api");
+var import_api21 = require("@uniformdev/context/api");
 var PromptsUrl = "/api/v1/prompts";
-var PromptClient = class extends import_api12.ApiClient {
+var PromptClient = class extends import_api21.ApiClient {
   constructor(options) {
     super(options);
   }
@@ -3266,34 +3739,42 @@ var PromptClient = class extends import_api12.ApiClient {
 };
 
 // src/RelationshipClient.ts
-var import_api13 = require("@uniformdev/context/api");
+var import_api22 = require("@uniformdev/context/api");
 var RELATIONSHIPS_URL = "/api/v1/relationships";
-var RelationshipClient = class extends import_api13.ApiClient {
+var RelationshipClient = class extends import_api22.ApiClient {
   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
-var import_api14 = require("@uniformdev/context/api");
+var import_api23 = require("@uniformdev/context/api");
 var releasesUrl = "/api/v1/releases";
-var ReleaseClient = class extends import_api14.ApiClient {
+var ReleaseClient = class extends import_api23.ApiClient {
   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",
@@ -3301,6 +3782,10 @@ var ReleaseClient = class extends import_api14.ApiClient {
       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);
@@ -3322,21 +3807,25 @@ var ReleaseClient = class extends import_api14.ApiClient {
 };
 
 // src/ReleaseContentsClient.ts
-var import_api15 = require("@uniformdev/context/api");
-var releaseContentsUrl2 = "/api/v1/release-contents";
-var ReleaseContentsClient = class extends import_api15.ApiClient {
+var import_api24 = require("@uniformdev/context/api");
+var releaseContentsUrl = "/api/v1/release-contents";
+var ReleaseContentsClient = class extends import_api24.ApiClient {
   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 }),
@@ -3346,9 +3835,9 @@ var ReleaseContentsClient = class extends import_api15.ApiClient {
 };
 
 // src/RouteClient.ts
-var import_api16 = require("@uniformdev/context/api");
+var import_api25 = require("@uniformdev/context/api");
 var ROUTE_URL = "/api/v1/route";
-var RouteClient = class extends import_api16.ApiClient {
+var RouteClient = class extends import_api25.ApiClient {
   constructor(options) {
     var _a;
     if (!options.limitPolicy) {
@@ -3357,15 +3846,27 @@ var RouteClient = class extends import_api16.ApiClient {
     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
@@ -3473,6 +3974,7 @@ function convertEntryToPutEntry(entry) {
     releaseId: entry.releaseId,
     workflowId: entry.workflowId,
     workflowStageId: entry.workflowStageId,
+    instanceWorkflowId: entry.instanceWorkflowId,
     editionId: entry.editionId,
     editionName: entry.editionName,
     editionPriority: entry.editionPriority
@@ -3523,8 +4025,13 @@ var getParameterAttributes = ({
 };
 
 // src/utils/isAllowedReferrer.ts
+var ALLOWED_REFERRER_ORIGIN = /^https:\/\/([\w-]+\.)*(uniform\.(app|wtf)|uniformcode\.ai)$|^https?:\/\/localhost:\d{4}$/;
 var isAllowedReferrer = (referrer) => {
-  return Boolean(referrer == null ? void 0 : referrer.match(/(^https:\/\/|\.)(uniform.app|uniform.wtf|localhost:\d{4})\//));
+  try {
+    return ALLOWED_REFERRER_ORIGIN.test(new URL(referrer != null ? referrer : "").origin);
+  } catch (e) {
+    return false;
+  }
 };
 
 // src/utils/isSystemComponentDefinition.ts
@@ -3608,6 +4115,9 @@ function bindVariables({
   errorPrefix = "Variable",
   handleBinding
 }) {
+  if (!value.includes(variablePrefix)) {
+    return { result: value, boundCount: 0, errors: void 0 };
+  }
   let boundCount = 0;
   let tokenCount = 0;
   const errors = [];
@@ -3638,13 +4148,15 @@ function bindVariables({
 }
 
 // src/utils/variables/bindVariablesToObject.ts
-var import_immer = require("immer");
 function bindVariablesToObject(options) {
-  return bindVariablesToObjectRecursive(options);
+  const { value } = options;
+  const bindableObjects = typeof value === "object" && value !== null ? findBindableObjects(value) : void 0;
+  return bindVariablesToObjectRecursive({ ...options, bindableObjects });
 }
 function bindVariablesToObjectRecursive({
   value,
   recursivePath,
+  bindableObjects,
   ...bindVariablesOptions
 }) {
   let boundCount = 0;
@@ -3659,50 +4171,93 @@ function bindVariablesToObjectRecursive({
   if (richTextNodeResult !== void 0) {
     return richTextNodeResult;
   }
-  const produceToUse = !(0, import_immer.isDraft)(value) ? import_immer.produce : (produceValue, producer) => {
-    producer(produceValue);
-    return produceValue;
+  if (bindableObjects && !bindableObjects.has(value)) {
+    return { boundCount: 0, result: value };
+  }
+  let copy;
+  const assign = (property, boundValue) => {
+    copy != null ? copy : copy = Array.isArray(value) ? value.slice() : Object.assign(Object.create(Object.getPrototypeOf(value)), value);
+    copy[property] = boundValue;
   };
-  const result = produceToUse(value, (draft) => {
-    Object.entries(draft).forEach(([property, oldValue]) => {
-      const currentObjectPath = recursivePath ? `${recursivePath}.${property}` : property;
-      if (typeof oldValue === "string") {
-        const bindResult = bindVariables({ ...bindVariablesOptions, value: oldValue });
-        if (oldValue !== bindResult.result || bindResult.errors) {
-          boundCount += bindResult.boundCount;
-          draft[property] = bindResult.result;
-          if (bindResult.errors) {
-            errors.push(
-              ...bindResult.errors.map((e) => {
-                if (typeof e === "string") {
-                  return `${currentObjectPath}: ${e}`;
-                }
-                e.message = `${currentObjectPath}: ${e.message}`;
-                return e;
-              })
-            );
-          }
-        }
+  Object.entries(value).forEach(([property, oldValue]) => {
+    const currentObjectPath = recursivePath ? `${recursivePath}.${property}` : property;
+    if (typeof oldValue === "string") {
+      if (!oldValue.includes(variablePrefix)) {
         return;
       }
-      const childBind = bindVariablesToObjectRecursive({
-        ...bindVariablesOptions,
-        value: oldValue,
-        recursivePath: currentObjectPath
-      });
-      if (childBind.boundCount || childBind.errors) {
-        boundCount += childBind.boundCount;
-        draft[property] = childBind.result;
-        if (childBind.errors) {
-          errors.push(...childBind.errors);
+      const bindResult = bindVariables({ ...bindVariablesOptions, value: oldValue });
+      if (oldValue !== bindResult.result || bindResult.errors) {
+        boundCount += bindResult.boundCount;
+        assign(property, bindResult.result);
+        if (bindResult.errors) {
+          errors.push(
+            ...bindResult.errors.map((e) => {
+              if (typeof e === "string") {
+                return `${currentObjectPath}: ${e}`;
+              }
+              e.message = `${currentObjectPath}: ${e.message}`;
+              return e;
+            })
+          );
         }
       }
+      return;
+    }
+    const childBind = bindVariablesToObjectRecursive({
+      ...bindVariablesOptions,
+      value: oldValue,
+      recursivePath: currentObjectPath,
+      bindableObjects
     });
+    if (childBind.boundCount || childBind.errors) {
+      boundCount += childBind.boundCount;
+      assign(property, childBind.result);
+      if (childBind.errors) {
+        errors.push(...childBind.errors);
+      }
+    }
   });
+  const result = copy != null ? copy : value;
   return { boundCount, result, errors: errors.length > 0 ? errors : void 0 };
 }
+function findBindableObjects(root) {
+  const bindable = /* @__PURE__ */ new Set();
+  const visit = (value) => {
+    if (typeof value === "string") {
+      return value.includes(variablePrefix);
+    }
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    if (bindable.has(value)) {
+      return true;
+    }
+    let found = isRichTextVariableNode(value);
+    if (!found) {
+      if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+          found = visit(value[i]) || found;
+        }
+      } else {
+        const keys = Object.keys(value);
+        for (let i = 0; i < keys.length; i++) {
+          found = visit(value[keys[i]]) || found;
+        }
+      }
+    }
+    if (found) {
+      bindable.add(value);
+    }
+    return found;
+  };
+  visit(root);
+  return bindable;
+}
+function isRichTextVariableNode(object) {
+  return "type" in object && object.type === "variable" && "reference" in object && typeof object.reference === "string" && "version" in object && object.version === 1;
+}
 function handleRichTextNodeBinding(object, options) {
-  if ("type" in object && object.type === "variable" && "reference" in object && typeof object.reference === "string" && "version" in object && object.version === 1) {
+  if (isRichTextVariableNode(object)) {
     const value = createVariableReference(object.reference);
     const bindResult = bindVariables({ ...options, value });
     const bindResultAsTextNode = {
@@ -3720,26 +4275,30 @@ function handleRichTextNodeBinding(object, options) {
 }
 
 // src/index.ts
-var import_api18 = require("@uniformdev/context/api");
+var import_api27 = require("@uniformdev/context/api");
 
 // src/.version.ts
-var version = "20.48.0";
+var version = "20.87.0";
 
 // src/WorkflowClient.ts
-var import_api17 = require("@uniformdev/context/api");
+var import_api26 = require("@uniformdev/context/api");
 var workflowsUrl = "/api/v1/workflows";
-var WorkflowClient = class extends import_api17.ApiClient {
+var WorkflowClient = class extends import_api26.ApiClient {
   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",
@@ -3747,6 +4306,10 @@ var WorkflowClient = class extends import_api17.ApiClient {
       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);
@@ -3759,7 +4322,7 @@ var WorkflowClient = class extends import_api17.ApiClient {
 };
 
 // src/index.ts
-var CanvasClientError = import_api18.ApiClientError;
+var CanvasClientError = import_api27.ApiClientError;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ASSETS_SOURCE_CUSTOM_URL,
@@ -3813,7 +4376,11 @@ var CanvasClientError = import_api18.ApiClientError;
   CanvasClientError,
   CategoryClient,
   ChildEnhancerBuilder,
+  ComponentDefinitionClient,
+  CompositionDeliveryClient,
+  CompositionManagementClient,
   ContentClient,
+  ContentTypeClient,
   DataSourceClient,
   DataTypeClient,
   EDGE_CACHE_DISABLED,
@@ -3823,6 +4390,8 @@ var CanvasClientError = import_api18.ApiClientError;
   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,
@@ -3833,19 +4402,23 @@ var CanvasClientError = import_api18.ApiClientError;
   IS_RENDERED_BY_UNIFORM_ATTRIBUTE,
   IntegrationPropertyEditorsClient,
   LOCALE_DYNAMIC_INPUT_NAME,
+  LabelClient,
   LocaleClient,
   PLACEHOLDER_ID,
   PreviewClient,
   ProjectClient,
   PromptClient,
+  REFERENCE_DATA_TYPE_ID,
   RelationshipClient,
   ReleaseClient,
   ReleaseContentsClient,
   RouteClient,
   SECRET_QUERY_STRING_PARAM,
+  SELECT_QUERY_PREFIX,
   UncachedCanvasClient,
   UncachedCategoryClient,
   UncachedContentClient,
+  UncachedLabelClient,
   UniqueBatchEntries,
   WorkflowClient,
   autoFixParameterGroups,
@@ -3892,6 +4465,7 @@ var CanvasClientError = import_api18.ApiClientError;
   isAllowedReferrer,
   isAssetParamValue,
   isAssetParamValueItem,
+  isAwaitingReadyMessage,
   isComponentActionMessage,
   isComponentPlaceholderId,
   isContextStorageUpdatedMessage,
@@ -3907,6 +4481,7 @@ var CanvasClientError = import_api18.ApiClientError;
   isRootEntryReference,
   isSelectComponentMessage,
   isSelectParameterMessage,
+  isSessionPendingMessage,
   isSuggestComponentMessage,
   isSystemComponentDefinition,
   isTriggerCompositionActionMessage,
@@ -3921,10 +4496,13 @@ var CanvasClientError = import_api18.ApiClientError;
   localize,
   mapSlotToPersonalizedVariations,
   mapSlotToTestVariations,
+  matchesProjectionPattern,
   mergeAssetConfigWithDefaults,
   nullLimitPolicy,
   parseComponentPlaceholderId,
   parseVariableExpression,
+  projectionToQuery,
+  queryToProjection,
   version,
   walkNodeTree,
   walkPropertyValues