@uniformdev/next-app-router 20.7.1-alpha.118

package/dist/index.esm.js

@@ -0,0 +1,3935 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js
+var require_yocto_queue = __commonJS({
+  "../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js"(exports, module) {
+    "use strict";
+    var Node = class {
+      /// value;
+      /// next;
+      constructor(value) {
+        this.value = value;
+        this.next = void 0;
+      }
+    };
+    var Queue = class {
+      // TODO: Use private class fields when targeting Node.js 12.
+      // #_head;
+      // #_tail;
+      // #_size;
+      constructor() {
+        this.clear();
+      }
+      enqueue(value) {
+        const node = new Node(value);
+        if (this._head) {
+          this._tail.next = node;
+          this._tail = node;
+        } else {
+          this._head = node;
+          this._tail = node;
+        }
+        this._size++;
+      }
+      dequeue() {
+        const current = this._head;
+        if (!current) {
+          return;
+        }
+        this._head = this._head.next;
+        this._size--;
+        return current.value;
+      }
+      clear() {
+        this._head = void 0;
+        this._tail = void 0;
+        this._size = 0;
+      }
+      get size() {
+        return this._size;
+      }
+      *[Symbol.iterator]() {
+        let current = this._head;
+        while (current) {
+          yield current.value;
+          current = current.next;
+        }
+      }
+    };
+    module.exports = Queue;
+  }
+});
+
+// ../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js
+var require_p_limit = __commonJS({
+  "../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js"(exports, module) {
+    "use strict";
+    var Queue = require_yocto_queue();
+    var pLimit2 = (concurrency) => {
+      if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+        throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+      }
+      const queue = new Queue();
+      let activeCount = 0;
+      const next = () => {
+        activeCount--;
+        if (queue.size > 0) {
+          queue.dequeue()();
+        }
+      };
+      const run = async (fn, resolve, ...args) => {
+        activeCount++;
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+          await result;
+        } catch (e) {
+        }
+        next();
+      };
+      const enqueue = (fn, resolve, ...args) => {
+        queue.enqueue(run.bind(null, fn, resolve, ...args));
+        (async () => {
+          await Promise.resolve();
+          if (activeCount < concurrency && queue.size > 0) {
+            queue.dequeue()();
+          }
+        })();
+      };
+      const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, ...args);
+      });
+      Object.defineProperties(generator, {
+        activeCount: {
+          get: () => activeCount
+        },
+        pendingCount: {
+          get: () => queue.size
+        },
+        clearQueue: {
+          value: () => {
+            queue.clear();
+          }
+        }
+      });
+      return generator;
+    };
+    module.exports = pLimit2;
+  }
+});
+
+// src/index.ts
+import "server-only";
+
+// src/clients/canvas.ts
+import "server-only";
+
+// ../context/dist/api/api.mjs
+var import_p_limit = __toESM(require_p_limit(), 1);
+var __defProp2 = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var defaultLimitPolicy = (0, import_p_limit.default)(6);
+var ApiClientError = class _ApiClientError extends Error {
+  constructor(errorMessage, fetchMethod, fetchUri, statusCode, statusText, requestId) {
+    super(
+      `${errorMessage}
+ ${statusCode}${statusText ? " " + statusText : ""} (${fetchMethod} ${fetchUri}${requestId ? ` Request ID: ${requestId}` : ""})`
+    );
+    this.errorMessage = errorMessage;
+    this.fetchMethod = fetchMethod;
+    this.fetchUri = fetchUri;
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+    this.requestId = requestId;
+    Object.setPrototypeOf(this, _ApiClientError.prototype);
+  }
+};
+var ApiClient = class _ApiClient {
+  constructor(options) {
+    __publicField(this, "options");
+    var _a, _b, _c, _d, _e;
+    if (!options.apiKey && !options.bearerToken) {
+      throw new Error("You must provide an API key or a bearer token");
+    }
+    let leFetch = options.fetch;
+    if (!leFetch) {
+      if (typeof window !== "undefined") {
+        leFetch = window.fetch.bind(window);
+      } else if (typeof fetch !== "undefined") {
+        leFetch = fetch;
+      } else {
+        throw new Error("You must provide or polyfill a fetch implementation when not in a browser");
+      }
+    }
+    this.options = {
+      ...options,
+      fetch: leFetch,
+      apiHost: this.ensureApiHost(options.apiHost),
+      apiKey: (_a = options.apiKey) != null ? _a : null,
+      projectId: (_b = options.projectId) != null ? _b : null,
+      bearerToken: (_c = options.bearerToken) != null ? _c : null,
+      limitPolicy: (_d = options.limitPolicy) != null ? _d : defaultLimitPolicy,
+      bypassCache: (_e = options.bypassCache) != null ? _e : false
+    };
+  }
+  async apiClient(fetchUri, options) {
+    return (await this.apiClientWithResponse(fetchUri, options)).body;
+  }
+  async apiClientWithResponse(fetchUri, options) {
+    return this.options.limitPolicy(async () => {
+      var _a;
+      const coreHeaders = this.options.apiKey ? {
+        "x-api-key": this.options.apiKey
+      } : {
+        Authorization: `Bearer ${this.options.bearerToken}`
+      };
+      if (this.options.bypassCache) {
+        coreHeaders["x-bypass-cache"] = "true";
+      }
+      const { fetch: fetch2, signal } = this.options;
+      const callApi = () => fetch2(fetchUri.toString(), {
+        ...options,
+        signal,
+        headers: {
+          ...options == null ? void 0 : options.headers,
+          ...coreHeaders
+        }
+      });
+      const apiResponse = await handleRateLimits(callApi);
+      if (!apiResponse.ok) {
+        let message = "";
+        try {
+          const responseText = await apiResponse.text();
+          try {
+            const parsed = JSON.parse(responseText);
+            if (parsed.errorMessage) {
+              message = Array.isArray(parsed.errorMessage) ? parsed.errorMessage.join(", ") : parsed.errorMessage;
+            } else {
+              message = responseText;
+            }
+          } catch (e) {
+            message = responseText;
+          }
+        } catch (e) {
+          message = `General error`;
+        }
+        throw new ApiClientError(
+          message,
+          (_a = options == null ? void 0 : options.method) != null ? _a : "GET",
+          fetchUri.toString(),
+          apiResponse.status,
+          apiResponse.statusText,
+          _ApiClient.getRequestId(apiResponse)
+        );
+      }
+      if (options == null ? void 0 : options.expectNoContent) {
+        return { response: apiResponse, body: null };
+      }
+      return {
+        response: apiResponse,
+        body: await apiResponse.json()
+      };
+    });
+  }
+  createUrl(path, queryParams, hostOverride) {
+    const url = new URL(`${hostOverride != null ? hostOverride : this.options.apiHost}${path}`);
+    Object.entries(queryParams != null ? queryParams : {}).forEach(([key, value]) => {
+      var _a;
+      if (typeof value !== "undefined" && value !== null) {
+        url.searchParams.append(key, Array.isArray(value) ? value.join(",") : (_a = value == null ? void 0 : value.toString()) != null ? _a : "");
+      }
+    });
+    return url;
+  }
+  ensureApiHost(apiHost) {
+    if (!apiHost) return "https://uniform.app";
+    if (!(apiHost == null ? void 0 : apiHost.startsWith("http"))) {
+      throw new Error('Your apiHost must start with "http"');
+    }
+    if (apiHost.indexOf("/", 8) > -1) {
+      throw new Error("Your apiHost must not contain a path element after the domain");
+    }
+    if (apiHost.indexOf("?") > -1) {
+      throw new Error("Your apiHost must not contain a query string");
+    }
+    if (apiHost == null ? void 0 : apiHost.endsWith("/")) {
+      apiHost = apiHost.substring(0, apiHost.length - 1);
+    }
+    return apiHost;
+  }
+  static getRequestId(response) {
+    const apigRequestId = response.headers.get("apigw-requestid");
+    if (apigRequestId) {
+      return apigRequestId;
+    }
+    return void 0;
+  }
+};
+async function handleRateLimits(callApi) {
+  var _a;
+  const backoffRetries = 5;
+  let backoffRetriesLeft = backoffRetries;
+  let response;
+  while (backoffRetriesLeft > 0) {
+    response = await callApi();
+    if (response.status !== 429) {
+      break;
+    }
+    let resetWait = 0;
+    try {
+      const responseClone = response.clone();
+      const dateHeader = responseClone.headers.get("date");
+      const serverTime = dateHeader ? new Date(dateHeader).getTime() : void 0;
+      const body = await responseClone.json();
+      const resetTime = (_a = body == null ? void 0 : body.info) == null ? void 0 : _a.reset;
+      if (typeof serverTime === "number" && typeof resetTime === "number") {
+        resetWait = Math.max(0, Math.min(Math.round(1.1 * (resetTime - serverTime)), 1e4));
+      }
+    } catch (e) {
+    }
+    const base = Math.pow(2, backoffRetries - backoffRetriesLeft) * 333;
+    const backoffWait = base + Math.round(Math.random() * (base / 2)) * (Math.random() > 0.5 ? 1 : -1);
+    await new Promise((resolve) => setTimeout(resolve, resetWait + backoffWait));
+    backoffRetriesLeft -= 1;
+  }
+  return response;
+}
+var _url;
+var _AggregateClient = class _AggregateClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches all aggregates for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_AggregateClient2, _url), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) an Aggregate */
+  async upsert(body) {
+    const fetchUri = this.createUrl(__privateGet(_AggregateClient2, _url));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes an Aggregate */
+  async remove(body) {
+    const fetchUri = this.createUrl(__privateGet(_AggregateClient2, _url));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url = /* @__PURE__ */ new WeakMap();
+__privateAdd(_AggregateClient, _url, "/api/v2/aggregate");
+var _url2;
+var _DimensionClient = class _DimensionClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches the known score dimensions for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_DimensionClient2, _url2), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+};
+_url2 = /* @__PURE__ */ new WeakMap();
+__privateAdd(_DimensionClient, _url2, "/api/v2/dimension");
+var _url3;
+var _valueUrl;
+var _EnrichmentClient = class _EnrichmentClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches all enrichments and values for a project, grouped by category */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_EnrichmentClient2, _url3), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) an enrichment category */
+  async upsertCategory(body) {
+    const fetchUri = this.createUrl(__privateGet(_EnrichmentClient2, _url3));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes an enrichment category */
+  async removeCategory(body) {
+    const fetchUri = this.createUrl(__privateGet(_EnrichmentClient2, _url3));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Updates or creates (based on id) an enrichment value within an enrichment category */
+  async upsertValue(body) {
+    const fetchUri = this.createUrl(__privateGet(_EnrichmentClient2, _valueUrl));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes an enrichment value within an enrichment category. The category is left alone. */
+  async removeValue(body) {
+    const fetchUri = this.createUrl(__privateGet(_EnrichmentClient2, _valueUrl));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url3 = /* @__PURE__ */ new WeakMap();
+_valueUrl = /* @__PURE__ */ new WeakMap();
+__privateAdd(_EnrichmentClient, _url3, "/api/v1/enrichments");
+__privateAdd(_EnrichmentClient, _valueUrl, "/api/v1/enrichment-values");
+var _url4;
+var _ManifestClient = class _ManifestClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches the Context manifest for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_ManifestClient2, _url4), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Publishes the Context manifest for a project */
+  async publish() {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl("/api/v1/publish", { siteId: projectId });
+    await this.apiClient(fetchUri, {
+      method: "POST",
+      expectNoContent: true
+    });
+  }
+};
+_url4 = /* @__PURE__ */ new WeakMap();
+__privateAdd(_ManifestClient, _url4, "/api/v2/manifest");
+var ManifestClient = _ManifestClient;
+var _url5;
+var _QuirkClient = class _QuirkClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches all Quirks for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_QuirkClient2, _url5), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) a Quirk */
+  async upsert(body) {
+    const fetchUri = this.createUrl(__privateGet(_QuirkClient2, _url5));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes a Quirk */
+  async remove(body) {
+    const fetchUri = this.createUrl(__privateGet(_QuirkClient2, _url5));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url5 = /* @__PURE__ */ new WeakMap();
+__privateAdd(_QuirkClient, _url5, "/api/v2/quirk");
+var _url6;
+var _SignalClient = class _SignalClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches all Signals for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_SignalClient2, _url6), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) a Signal */
+  async upsert(body) {
+    const fetchUri = this.createUrl(__privateGet(_SignalClient2, _url6));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes a Signal */
+  async remove(body) {
+    const fetchUri = this.createUrl(__privateGet(_SignalClient2, _url6));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url6 = /* @__PURE__ */ new WeakMap();
+__privateAdd(_SignalClient, _url6, "/api/v2/signal");
+var _url7;
+var _TestClient = class _TestClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches all Tests for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet(_TestClient2, _url7), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) a Test */
+  async upsert(body) {
+    const fetchUri = this.createUrl(__privateGet(_TestClient2, _url7));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes a Test */
+  async remove(body) {
+    const fetchUri = this.createUrl(__privateGet(_TestClient2, _url7));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url7 = /* @__PURE__ */ new WeakMap();
+__privateAdd(_TestClient, _url7, "/api/v2/test");
+
+// ../canvas/dist/index.mjs
+var __create2 = Object.create;
+var __defProp3 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf2 = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __typeError2 = (msg) => {
+  throw TypeError(msg);
+};
+var __commonJS2 = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames2(from))
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __accessCheck2 = (obj, member, msg) => member.has(obj) || __typeError2("Cannot " + msg);
+var __privateGet2 = (obj, member, getter) => (__accessCheck2(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd2 = (obj, member, value) => member.has(obj) ? __typeError2("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var require_yocto_queue2 = __commonJS2({
+  "../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js"(exports, module) {
+    "use strict";
+    var Node = class {
+      /// value;
+      /// next;
+      constructor(value) {
+        this.value = value;
+        this.next = void 0;
+      }
+    };
+    var Queue = class {
+      // TODO: Use private class fields when targeting Node.js 12.
+      // #_head;
+      // #_tail;
+      // #_size;
+      constructor() {
+        this.clear();
+      }
+      enqueue(value) {
+        const node = new Node(value);
+        if (this._head) {
+          this._tail.next = node;
+          this._tail = node;
+        } else {
+          this._head = node;
+          this._tail = node;
+        }
+        this._size++;
+      }
+      dequeue() {
+        const current = this._head;
+        if (!current) {
+          return;
+        }
+        this._head = this._head.next;
+        this._size--;
+        return current.value;
+      }
+      clear() {
+        this._head = void 0;
+        this._tail = void 0;
+        this._size = 0;
+      }
+      get size() {
+        return this._size;
+      }
+      *[Symbol.iterator]() {
+        let current = this._head;
+        while (current) {
+          yield current.value;
+          current = current.next;
+        }
+      }
+    };
+    module.exports = Queue;
+  }
+});
+var require_p_limit2 = __commonJS2({
+  "../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js"(exports, module) {
+    "use strict";
+    var Queue = require_yocto_queue2();
+    var pLimit2 = (concurrency) => {
+      if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+        throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+      }
+      const queue = new Queue();
+      let activeCount = 0;
+      const next = () => {
+        activeCount--;
+        if (queue.size > 0) {
+          queue.dequeue()();
+        }
+      };
+      const run = async (fn, resolve, ...args) => {
+        activeCount++;
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+          await result;
+        } catch (e) {
+        }
+        next();
+      };
+      const enqueue = (fn, resolve, ...args) => {
+        queue.enqueue(run.bind(null, fn, resolve, ...args));
+        (async () => {
+          await Promise.resolve();
+          if (activeCount < concurrency && queue.size > 0) {
+            queue.dequeue()();
+          }
+        })();
+      };
+      const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, ...args);
+      });
+      Object.defineProperties(generator, {
+        activeCount: {
+          get: () => activeCount
+        },
+        pendingCount: {
+          get: () => queue.size
+        },
+        clearQueue: {
+          value: () => {
+            queue.clear();
+          }
+        }
+      });
+      return generator;
+    };
+    module.exports = pLimit2;
+  }
+});
+var require_retry_operation = __commonJS2({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports, module) {
+    "use strict";
+    function RetryOperation(timeouts, options) {
+      if (typeof options === "boolean") {
+        options = { forever: options };
+      }
+      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+      this._timeouts = timeouts;
+      this._options = options || {};
+      this._maxRetryTime = options && options.maxRetryTime || Infinity;
+      this._fn = null;
+      this._errors = [];
+      this._attempts = 1;
+      this._operationTimeout = null;
+      this._operationTimeoutCb = null;
+      this._timeout = null;
+      this._operationStart = null;
+      this._timer = null;
+      if (this._options.forever) {
+        this._cachedTimeouts = this._timeouts.slice(0);
+      }
+    }
+    module.exports = RetryOperation;
+    RetryOperation.prototype.reset = function() {
+      this._attempts = 1;
+      this._timeouts = this._originalTimeouts.slice(0);
+    };
+    RetryOperation.prototype.stop = function() {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (this._timer) {
+        clearTimeout(this._timer);
+      }
+      this._timeouts = [];
+      this._cachedTimeouts = null;
+    };
+    RetryOperation.prototype.retry = function(err) {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (!err) {
+        return false;
+      }
+      var currentTime = (/* @__PURE__ */ new Date()).getTime();
+      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.push(err);
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+      }
+      this._errors.push(err);
+      var timeout = this._timeouts.shift();
+      if (timeout === void 0) {
+        if (this._cachedTimeouts) {
+          this._errors.splice(0, this._errors.length - 1);
+          timeout = this._cachedTimeouts.slice(-1);
+        } else {
+          return false;
+        }
+      }
+      var self = this;
+      this._timer = setTimeout(function() {
+        self._attempts++;
+        if (self._operationTimeoutCb) {
+          self._timeout = setTimeout(function() {
+            self._operationTimeoutCb(self._attempts);
+          }, self._operationTimeout);
+          if (self._options.unref) {
+            self._timeout.unref();
+          }
+        }
+        self._fn(self._attempts);
+      }, timeout);
+      if (this._options.unref) {
+        this._timer.unref();
+      }
+      return true;
+    };
+    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+      this._fn = fn;
+      if (timeoutOps) {
+        if (timeoutOps.timeout) {
+          this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+          this._operationTimeoutCb = timeoutOps.cb;
+        }
+      }
+      var self = this;
+      if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function() {
+          self._operationTimeoutCb();
+        }, self._operationTimeout);
+      }
+      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+      this._fn(this._attempts);
+    };
+    RetryOperation.prototype.try = function(fn) {
+      console.log("Using RetryOperation.try() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = function(fn) {
+      console.log("Using RetryOperation.start() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = RetryOperation.prototype.try;
+    RetryOperation.prototype.errors = function() {
+      return this._errors;
+    };
+    RetryOperation.prototype.attempts = function() {
+      return this._attempts;
+    };
+    RetryOperation.prototype.mainError = function() {
+      if (this._errors.length === 0) {
+        return null;
+      }
+      var counts = {};
+      var mainError = null;
+      var mainErrorCount = 0;
+      for (var i = 0; i < this._errors.length; i++) {
+        var error = this._errors[i];
+        var message = error.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+          mainError = error;
+          mainErrorCount = count;
+        }
+      }
+      return mainError;
+    };
+  }
+});
+var require_retry = __commonJS2({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js"(exports) {
+    "use strict";
+    var RetryOperation = require_retry_operation();
+    exports.operation = function(options) {
+      var timeouts = exports.timeouts(options);
+      return new RetryOperation(timeouts, {
+        forever: options && (options.forever || options.retries === Infinity),
+        unref: options && options.unref,
+        maxRetryTime: options && options.maxRetryTime
+      });
+    };
+    exports.timeouts = function(options) {
+      if (options instanceof Array) {
+        return [].concat(options);
+      }
+      var opts = {
+        retries: 10,
+        factor: 2,
+        minTimeout: 1 * 1e3,
+        maxTimeout: Infinity,
+        randomize: false
+      };
+      for (var key in options) {
+        opts[key] = options[key];
+      }
+      if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+      }
+      var timeouts = [];
+      for (var i = 0; i < opts.retries; i++) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      if (options && options.forever && !timeouts.length) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      timeouts.sort(function(a, b) {
+        return a - b;
+      });
+      return timeouts;
+    };
+    exports.createTimeout = function(attempt, opts) {
+      var random = opts.randomize ? Math.random() + 1 : 1;
+      var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+      timeout = Math.min(timeout, opts.maxTimeout);
+      return timeout;
+    };
+    exports.wrap = function(obj, options, methods) {
+      if (options instanceof Array) {
+        methods = options;
+        options = null;
+      }
+      if (!methods) {
+        methods = [];
+        for (var key in obj) {
+          if (typeof obj[key] === "function") {
+            methods.push(key);
+          }
+        }
+      }
+      for (var i = 0; i < methods.length; i++) {
+        var method = methods[i];
+        var original = obj[method];
+        obj[method] = function retryWrapper(original2) {
+          var op = exports.operation(options);
+          var args = Array.prototype.slice.call(arguments, 1);
+          var callback = args.pop();
+          args.push(function(err) {
+            if (op.retry(err)) {
+              return;
+            }
+            if (err) {
+              arguments[0] = op.mainError();
+            }
+            callback.apply(this, arguments);
+          });
+          op.attempt(function() {
+            original2.apply(obj, args);
+          });
+        }.bind(obj, original);
+        obj[method].options = options;
+      }
+    };
+  }
+});
+var require_retry2 = __commonJS2({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_retry();
+  }
+});
+var import_p_limit2 = __toESM2(require_p_limit2());
+var import_retry = __toESM2(require_retry2(), 1);
+var networkErrorMsgs = /* @__PURE__ */ new Set([
+  "Failed to fetch",
+  // Chrome
+  "NetworkError when attempting to fetch resource.",
+  // Firefox
+  "The Internet connection appears to be offline.",
+  // Safari
+  "Network request failed",
+  // `cross-fetch`
+  "fetch failed"
+  // Undici (Node.js)
+]);
+var AbortError = class extends Error {
+  constructor(message) {
+    super();
+    if (message instanceof Error) {
+      this.originalError = message;
+      ({ message } = message);
+    } else {
+      this.originalError = new Error(message);
+      this.originalError.stack = this.stack;
+    }
+    this.name = "AbortError";
+    this.message = message;
+  }
+};
+var decorateErrorWithCounts = (error, attemptNumber, options) => {
+  const retriesLeft = options.retries - (attemptNumber - 1);
+  error.attemptNumber = attemptNumber;
+  error.retriesLeft = retriesLeft;
+  return error;
+};
+var isNetworkError = (errorMessage) => networkErrorMsgs.has(errorMessage);
+var getDOMException = (errorMessage) => globalThis.DOMException === void 0 ? new Error(errorMessage) : new DOMException(errorMessage);
+async function pRetry(input, options) {
+  return new Promise((resolve, reject) => {
+    options = {
+      onFailedAttempt() {
+      },
+      retries: 10,
+      ...options
+    };
+    const operation = import_retry.default.operation(options);
+    operation.attempt(async (attemptNumber) => {
+      try {
+        resolve(await input(attemptNumber));
+      } catch (error) {
+        if (!(error instanceof Error)) {
+          reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
+          return;
+        }
+        if (error instanceof AbortError) {
+          operation.stop();
+          reject(error.originalError);
+        } else if (error instanceof TypeError && !isNetworkError(error.message)) {
+          operation.stop();
+          reject(error);
+        } else {
+          decorateErrorWithCounts(error, attemptNumber, options);
+          try {
+            await options.onFailedAttempt(error);
+          } catch (error2) {
+            reject(error2);
+            return;
+          }
+          if (!operation.retry(error)) {
+            reject(operation.mainError());
+          }
+        }
+      }
+    });
+    if (options.signal && !options.signal.aborted) {
+      options.signal.addEventListener("abort", () => {
+        operation.stop();
+        const reason = options.signal.reason === void 0 ? getDOMException("The operation was aborted.") : options.signal.reason;
+        reject(reason instanceof Error ? reason : getDOMException(reason));
+      }, {
+        once: true
+      });
+    }
+  });
+}
+var AbortError2 = class extends Error {
+  constructor() {
+    super("Throttled function aborted");
+    this.name = "AbortError";
+  }
+};
+function pThrottle({ limit, interval, strict }) {
+  if (!Number.isFinite(limit)) {
+    throw new TypeError("Expected `limit` to be a finite number");
+  }
+  if (!Number.isFinite(interval)) {
+    throw new TypeError("Expected `interval` to be a finite number");
+  }
+  const queue = /* @__PURE__ */ new Map();
+  let currentTick = 0;
+  let activeCount = 0;
+  function windowedDelay() {
+    const now = Date.now();
+    if (now - currentTick > interval) {
+      activeCount = 1;
+      currentTick = now;
+      return 0;
+    }
+    if (activeCount < limit) {
+      activeCount++;
+    } else {
+      currentTick += interval;
+      activeCount = 1;
+    }
+    return currentTick - now;
+  }
+  const strictTicks = [];
+  function strictDelay() {
+    const now = Date.now();
+    if (strictTicks.length < limit) {
+      strictTicks.push(now);
+      return 0;
+    }
+    const earliestTime = strictTicks.shift() + interval;
+    if (now >= earliestTime) {
+      strictTicks.push(now);
+      return 0;
+    }
+    strictTicks.push(earliestTime);
+    return earliestTime - now;
+  }
+  const getDelay = strict ? strictDelay : windowedDelay;
+  return (function_) => {
+    const throttled = function(...args) {
+      if (!throttled.isEnabled) {
+        return (async () => function_.apply(this, args))();
+      }
+      let timeout;
+      return new Promise((resolve, reject) => {
+        const execute = () => {
+          resolve(function_.apply(this, args));
+          queue.delete(timeout);
+        };
+        timeout = setTimeout(execute, getDelay());
+        queue.set(timeout, reject);
+      });
+    };
+    throttled.abort = () => {
+      for (const timeout of queue.keys()) {
+        clearTimeout(timeout);
+        queue.get(timeout)(new AbortError2());
+      }
+      queue.clear();
+      strictTicks.splice(0, strictTicks.length);
+    };
+    throttled.isEnabled = true;
+    return throttled;
+  };
+}
+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_limit2.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 ApiClientError && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
+            throw error;
+          }
+        }
+      });
+    }
+    return currentFunc();
+  };
+}
+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()
+      };
+    },
+    {}
+  );
+}
+var CANVAS_URL = "/api/v1/canvas";
+var CanvasClient = class extends ApiClient {
+  constructor(options) {
+    var _a;
+    if (!options.limitPolicy) {
+      options.limitPolicy = createLimitPolicy({});
+    }
+    super(options);
+    this.edgeApiHost = (_a = options.edgeApiHost) != null ? _a : "https://uniform.global";
+    this.edgeApiRequestInit = options.disableSWR ? { headers: { "x-disable-swr": "true" } } : void 0;
+  }
+  /** Fetches lists of Canvas compositions, optionally by type */
+  async getCompositionList(params = {}) {
+    const { projectId } = this.options;
+    const { resolveData, filters, ...originParams } = params;
+    const rewrittenFilters = rewriteFilters(filters);
+    if (!resolveData) {
+      const fetchUri = this.createUrl(CANVAS_URL, { ...originParams, projectId, ...rewrittenFilters });
+      return this.apiClient(fetchUri);
+    }
+    const edgeParams = {
+      ...originParams,
+      projectId,
+      diagnostics: typeof params.diagnostics === "boolean" ? params.diagnostics : params.diagnostics === "no-data" ? "no-data" : void 0,
+      ...rewrittenFilters
+    };
+    const edgeUrl = this.createUrl("/api/v1/compositions", edgeParams, this.edgeApiHost);
+    return this.apiClient(edgeUrl, this.edgeApiRequestInit);
+  }
+  getCompositionByNodePath(options) {
+    return this.getOneComposition(options);
+  }
+  getCompositionByNodeId(options) {
+    return this.getOneComposition(options);
+  }
+  getCompositionBySlug(options) {
+    return this.getOneComposition(options);
+  }
+  getCompositionById(options) {
+    return this.getOneComposition(options);
+  }
+  getCompositionDefaults(options) {
+    return this.getOneComposition(options);
+  }
+  /** Fetches historical versions of a composition or pattern */
+  async getCompositionHistory(options) {
+    const historyUrl = this.createUrl("/api/v1/canvas-history", {
+      ...options,
+      projectId: this.options.projectId
+    });
+    return this.apiClient(historyUrl);
+  }
+  getOneComposition({
+    skipDataResolution,
+    diagnostics,
+    ...params
+  }) {
+    const { projectId } = this.options;
+    if (skipDataResolution) {
+      return this.apiClient(this.createUrl(CANVAS_URL, { ...params, projectId }));
+    }
+    const edgeParams = {
+      ...params,
+      projectId,
+      diagnostics: typeof diagnostics === "boolean" ? diagnostics : diagnostics === "no-data" ? "no-data" : void 0
+    };
+    const edgeUrl = this.createUrl("/api/v1/composition", edgeParams, this.edgeApiHost);
+    return this.apiClient(edgeUrl, this.edgeApiRequestInit);
+  }
+  /** Updates or creates a Canvas component definition */
+  async updateComposition(body, options) {
+    const fetchUri = this.createUrl(CANVAS_URL);
+    const headers = {};
+    if (options == null ? void 0 : options.ifUnmodifiedSince) {
+      headers["x-if-unmodified-since"] = options.ifUnmodifiedSince;
+    }
+    const { response } = await this.apiClientWithResponse(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true,
+      headers
+    });
+    return { modified: response.headers.get("x-modified-at") };
+  }
+  /** Deletes a Canvas component definition */
+  async removeComposition(body) {
+    const fetchUri = this.createUrl(CANVAS_URL);
+    const { projectId } = this.options;
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Fetches all Canvas component definitions */
+  async getComponentDefinitions(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl("/api/v1/canvas-definitions", { ...options, projectId });
+    return this.apiClient(fetchUri);
+  }
+  /** Updates or creates a Canvas component definition */
+  async updateComponentDefinition(body) {
+    const fetchUri = this.createUrl("/api/v1/canvas-definitions");
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes a Canvas component definition */
+  async removeComponentDefinition(body) {
+    const fetchUri = this.createUrl("/api/v1/canvas-definitions");
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+var _contentTypesUrl;
+var _entriesUrl;
+var _ContentClient = class _ContentClient2 extends ApiClient {
+  constructor(options) {
+    var _a;
+    super(options);
+    this.edgeApiHost = (_a = options.edgeApiHost) != null ? _a : "https://uniform.global";
+  }
+  getContentTypes(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet2(_ContentClient2, _contentTypesUrl), { ...options, projectId });
+    return this.apiClient(fetchUri);
+  }
+  getEntries(options) {
+    const { projectId } = this.options;
+    const { skipDataResolution, filters, ...params } = options;
+    const rewrittenFilters = rewriteFilters(filters);
+    if (skipDataResolution) {
+      const url = this.createUrl(__privateGet2(_ContentClient2, _entriesUrl), { ...params, ...rewrittenFilters, projectId });
+      return this.apiClient(url);
+    }
+    const edgeUrl = this.createUrl(
+      __privateGet2(_ContentClient2, _entriesUrl),
+      { ...this.getEdgeOptions(params), ...rewrittenFilters },
+      this.edgeApiHost
+    );
+    return this.apiClient(
+      edgeUrl,
+      this.options.disableSWR ? { headers: { "x-disable-swr": "true" } } : void 0
+    );
+  }
+  /** Fetches historical versions of an entry */
+  async getEntryHistory(options) {
+    const historyUrl = this.createUrl("/api/v1/entries-history", {
+      ...options,
+      projectId: this.options.projectId
+    });
+    return this.apiClient(historyUrl);
+  }
+  async upsertContentType(body, opts = {}) {
+    const fetchUri = this.createUrl(__privateGet2(_ContentClient2, _contentTypesUrl));
+    if (typeof body.contentType.slugSettings === "object" && body.contentType.slugSettings !== null && Object.keys(body.contentType.slugSettings).length === 0) {
+      delete body.contentType.slugSettings;
+    }
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true,
+      headers: opts.autogenerateDataTypes ? { "x-uniform-autogenerate-data-types": "true" } : {}
+    });
+  }
+  async upsertEntry(body, options) {
+    const fetchUri = this.createUrl(__privateGet2(_ContentClient2, _entriesUrl));
+    const headers = {};
+    if (options == null ? void 0 : options.ifUnmodifiedSince) {
+      headers["x-if-unmodified-since"] = options.ifUnmodifiedSince;
+    }
+    const { response } = await this.apiClientWithResponse(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true,
+      headers
+    });
+    return { modified: response.headers.get("x-modified-at") };
+  }
+  async deleteContentType(body) {
+    const fetchUri = this.createUrl(__privateGet2(_ContentClient2, _contentTypesUrl));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  async deleteEntry(body) {
+    const fetchUri = this.createUrl(__privateGet2(_ContentClient2, _entriesUrl));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  getEdgeOptions(options) {
+    const { projectId } = this.options;
+    const { skipDataResolution, ...params } = options;
+    return {
+      projectId,
+      ...params,
+      diagnostics: typeof options.diagnostics === "boolean" ? options.diagnostics : options.diagnostics === "no-data" ? "no-data" : void 0
+    };
+  }
+};
+_contentTypesUrl = /* @__PURE__ */ new WeakMap();
+_entriesUrl = /* @__PURE__ */ new WeakMap();
+__privateAdd2(_ContentClient, _contentTypesUrl, "/api/v1/content-types");
+__privateAdd2(_ContentClient, _entriesUrl, "/api/v1/entries");
+var _url8;
+var _DataTypeClient = class _DataTypeClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+  }
+  /** Fetches all DataTypes for a project */
+  async get(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(__privateGet2(_DataTypeClient2, _url8), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) a DataType */
+  async upsert(body) {
+    const fetchUri = this.createUrl(__privateGet2(_DataTypeClient2, _url8));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+  /** Deletes a DataType */
+  async remove(body) {
+    const fetchUri = this.createUrl(__privateGet2(_DataTypeClient2, _url8));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url8 = /* @__PURE__ */ new WeakMap();
+__privateAdd2(_DataTypeClient, _url8, "/api/v1/data-types");
+function getComponentPath(ancestorsAndSelf) {
+  const path = [];
+  for (let i = ancestorsAndSelf.length - 1; i >= 0; i--) {
+    const currentLocation = ancestorsAndSelf[i];
+    const parentLocation = ancestorsAndSelf[i + 1];
+    if ("type" in currentLocation && currentLocation.type !== "slot") {
+      if (currentLocation.type === "block") {
+        const { fieldName, blockIndexFn } = currentLocation;
+        const blockIndex = blockIndexFn();
+        if (fieldName && blockIndex !== void 0) {
+          const noun = parentLocation && "type" in parentLocation && parentLocation.type === "block" ? "fields" : "parameters";
+          path.push(`${noun}.${fieldName}.value[${blockIndex}]`);
+        }
+      } else {
+      }
+      continue;
+    }
+    const parentSlotIndex = currentLocation.parentSlotIndexFn();
+    const { parentSlot } = currentLocation;
+    if (parentSlot && parentSlotIndex !== void 0) {
+      path.push(`${parentSlot}[${parentSlotIndex}]`);
+    }
+  }
+  return `.${path.join(".")}`;
+}
+var CANVAS_PERSONALIZE_TYPE = "$personalization";
+var CANVAS_TEST_TYPE = "$test";
+var CANVAS_BLOCK_PARAM_TYPE = "$block";
+var CANVAS_PERSONALIZE_SLOT = "pz";
+var CANVAS_TEST_SLOT = "test";
+var CANVAS_DRAFT_STATE = 0;
+var CANVAS_PUBLISHED_STATE = 64;
+var CANVAS_EDITOR_STATE = 63;
+var CANVAS_PERSONALIZATION_PARAM = "$pzCrit";
+var CANVAS_TEST_VARIANT_PARAM = "$tstVrnt";
+var CANVAS_ENRICHMENT_TAG_PARAM = "$enr";
+var CANVAS_CONTEXTUAL_EDITING_PARAM = "$contextualEditing";
+var IN_CONTEXT_EDITOR_QUERY_STRING_PARAM = "is_incontext_editing_mode";
+var PLACEHOLDER_ID = "placeholder";
+var EDGE_MAX_CACHE_TTL = 24 * 60 * 60;
+function isRootEntryReference(root) {
+  return root.type === "root" && isEntryData(root.node);
+}
+function isEntryData(entryData) {
+  return Boolean(entryData && typeof entryData === "object" && "fields" in entryData);
+}
+function getPropertiesValue(entity) {
+  return "parameters" in entity && entity.parameters ? entity.parameters : "fields" in entity && entity.fields ? entity.fields : void 0;
+}
+var escapeCharacter = "\\";
+var variablePrefix = "${";
+var variableSuffix = "}";
+function parseVariableExpression(serialized, onToken) {
+  if (typeof serialized !== "string") {
+    throw new TypeError("Variable expression must be a string");
+  }
+  let bufferStartIndex = 0;
+  let bufferEndIndex = 0;
+  let tokenCount = 0;
+  const handleToken = (token, type) => {
+    tokenCount++;
+    return onToken == null ? void 0 : onToken(token, type);
+  };
+  let state = "text";
+  for (let index = 0; index < serialized.length; index++) {
+    const char = serialized[index];
+    if (bufferStartIndex > bufferEndIndex) {
+      bufferEndIndex = bufferStartIndex;
+    }
+    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) {
+          return tokenCount;
+        }
+        bufferStartIndex = index;
+        bufferEndIndex = index + 1;
+        continue;
+      }
+      state = "variable";
+      if (bufferEndIndex > bufferStartIndex) {
+        if (handleToken(serialized.substring(bufferStartIndex, bufferEndIndex), "text") === false) {
+          return tokenCount;
+        }
+        bufferStartIndex = bufferEndIndex;
+      }
+      index += variablePrefix.length - 1;
+      bufferStartIndex += variablePrefix.length;
+      continue;
+    }
+    if (char === variableSuffix && state === "variable") {
+      if (serialized[index - 1] === escapeCharacter) {
+        bufferEndIndex++;
+        continue;
+      }
+      state = "text";
+      if (bufferEndIndex > bufferStartIndex) {
+        const unescapedVariableName = serialized.substring(bufferStartIndex, bufferEndIndex).replace(/\\([${}])/g, "$1");
+        if (handleToken(unescapedVariableName, "variable") === false) {
+          return tokenCount;
+        }
+        bufferStartIndex = bufferEndIndex + variableSuffix.length;
+      }
+      continue;
+    }
+    bufferEndIndex++;
+  }
+  if (bufferEndIndex > bufferStartIndex) {
+    if (state === "variable") {
+      state = "text";
+      bufferStartIndex -= variablePrefix.length;
+    }
+    handleToken(serialized.substring(bufferStartIndex), state);
+  }
+  return tokenCount;
+}
+function hasReferencedVariables(value) {
+  if (value === void 0) {
+    return 0;
+  }
+  let variableTokenCount = 0;
+  parseVariableExpression(value, (_, tokenType) => {
+    if (tokenType === "variable") {
+      variableTokenCount++;
+    }
+  });
+  return variableTokenCount;
+}
+function walkNodeTree(node, visitor, options) {
+  var _a, _b;
+  const componentQueue = [
+    {
+      ancestorsAndSelf: Array.isArray(node) ? node : [{ node, type: "root" }],
+      context: options == null ? void 0 : options.initialContext
+    }
+  ];
+  const childContexts = /* @__PURE__ */ new Map();
+  do {
+    const currentQueueEntry = componentQueue.pop();
+    if (!currentQueueEntry) continue;
+    const currentComponent = currentQueueEntry.ancestorsAndSelf[0];
+    let visitDescendants = true;
+    let descendantContext = (_a = childContexts.get(currentComponent.node)) != null ? _a : currentQueueEntry.context;
+    let visitorInfo;
+    if (currentComponent.type === "root" && isRootEntryReference(currentComponent) || currentComponent.type === "block") {
+      visitorInfo = {
+        type: "entry",
+        node: currentComponent.node,
+        ancestorsAndSelf: currentQueueEntry.ancestorsAndSelf,
+        actions: {
+          replace: (replacementNode) => {
+            Object.assign(currentComponent.node, replacementNode);
+            const propertiesToCheck = ["fields", "_dataResources", "_author"];
+            propertiesToCheck.forEach((property) => {
+              if (!replacementNode[property]) {
+                delete currentComponent.node[property];
+              }
+            });
+          },
+          remove: () => {
+            const currentComponentLocation = currentQueueEntry.ancestorsAndSelf[0];
+            const parentComponent = currentQueueEntry.ancestorsAndSelf[1];
+            if (currentComponentLocation.type === "block") {
+              const { fieldName, blockIndexFn } = currentComponentLocation;
+              const blockIndex = blockIndexFn();
+              const blockValue = getBlockValue(parentComponent.node, fieldName);
+              blockValue.splice(blockIndex, 1);
+              if (blockValue.length === 0) {
+                const properties2 = getPropertiesValue(parentComponent.node);
+                delete properties2[fieldName];
+              }
+            } else {
+              throw new Error("Unknown node type");
+            }
+            visitDescendants = false;
+          },
+          insertAfter: (nodes) => {
+            const currentNodeInfo = currentQueueEntry.ancestorsAndSelf[0];
+            if (currentNodeInfo.type !== "block") {
+              throw new Error("Unknown type");
+            }
+            const { fieldName, blockIndexFn } = currentNodeInfo;
+            const blockIndex = blockIndexFn();
+            const parentComponent = currentQueueEntry.ancestorsAndSelf[1];
+            const nodesToInsert = Array.isArray(nodes) ? nodes : [nodes];
+            if (fieldName && typeof blockIndex !== "undefined") {
+              getPropertiesValue(parentComponent.node)[fieldName].value.splice(
+                blockIndex + 1,
+                0,
+                ...nodesToInsert
+              );
+              componentQueue.unshift(
+                ...nodesToInsert.map((enqueueingComponent) => {
+                  const blockIndexFn2 = () => {
+                    const parentArray = getPropertiesValue(parentComponent.node)[fieldName].value;
+                    return parentArray.findIndex((x) => x === enqueueingComponent);
+                  };
+                  return {
+                    ancestorsAndSelf: [
+                      {
+                        type: "block",
+                        node: enqueueingComponent,
+                        fieldName,
+                        blockIndexFn: blockIndexFn2
+                      },
+                      // slice removes 'self' since we are inserting a peer of self
+                      ...currentQueueEntry.ancestorsAndSelf.slice(1)
+                    ],
+                    context: descendantContext
+                  };
+                })
+              );
+            }
+          },
+          stopProcessingDescendants() {
+            visitDescendants = false;
+          },
+          setDescendantsContext(context) {
+            descendantContext = context;
+          },
+          setChildContext(child, context) {
+            childContexts.set(child, context);
+          }
+        },
+        context: descendantContext
+      };
+    } else {
+      visitorInfo = {
+        type: "component",
+        node: currentComponent.node,
+        ancestorsAndSelf: currentQueueEntry.ancestorsAndSelf,
+        actions: {
+          replace: (replacementComponent) => {
+            Object.assign(currentComponent.node, replacementComponent);
+            const propertiesToCheck = [
+              "parameters",
+              "variant",
+              "slots",
+              "data",
+              "_pattern",
+              "_patternError",
+              "_dataResources",
+              "_overridability",
+              "_overrides",
+              "_patternDataResources"
+            ];
+            propertiesToCheck.forEach((property) => {
+              if (!replacementComponent[property]) {
+                delete currentComponent.node[property];
+              }
+            });
+          },
+          remove: () => {
+            const currentComponentLocation = currentQueueEntry.ancestorsAndSelf[0];
+            const parentComponent = currentQueueEntry.ancestorsAndSelf[1];
+            if (currentComponentLocation.type === "root") {
+              throw new Error("Unable to delete root node.");
+            }
+            if (currentComponentLocation.type === "slot") {
+              const { parentSlot, parentSlotIndexFn } = currentComponentLocation;
+              const parentSlotIndex = parentSlotIndexFn();
+              parentComponent.node.slots[parentSlot].splice(parentSlotIndex, 1);
+            } else {
+              throw new Error("Unknown node type");
+            }
+            visitDescendants = false;
+          },
+          insertAfter: (nodes) => {
+            const nodesToInsert = Array.isArray(nodes) ? nodes : [nodes];
+            const currentNodeInfo = currentQueueEntry.ancestorsAndSelf[0];
+            if (currentNodeInfo.type === "root") {
+              throw new Error("Unable to insert after root node.");
+            }
+            if (currentNodeInfo.type === "slot") {
+              const { parentSlot, parentSlotIndexFn } = currentNodeInfo;
+              const parentSlotIndex = parentSlotIndexFn();
+              const parentComponent = currentQueueEntry.ancestorsAndSelf[1];
+              if (parentSlot && typeof parentSlotIndex !== "undefined") {
+                parentComponent.node.slots[parentSlot].splice(
+                  parentSlotIndex + 1,
+                  0,
+                  ...nodesToInsert
+                );
+                componentQueue.unshift(
+                  ...nodesToInsert.map((enqueueingComponent) => {
+                    const parentSlotIndexFn2 = () => {
+                      return parentComponent.node.slots[parentSlot].findIndex(
+                        (x) => x === enqueueingComponent
+                      );
+                    };
+                    return {
+                      type: "slot",
+                      ancestorsAndSelf: [
+                        {
+                          type: "slot",
+                          node: enqueueingComponent,
+                          parentSlot,
+                          parentSlotIndexFn: parentSlotIndexFn2
+                        },
+                        // slice removes 'self' since we are inserting a peer of self
+                        ...currentQueueEntry.ancestorsAndSelf.slice(1)
+                      ],
+                      context: descendantContext
+                    };
+                  })
+                );
+              }
+            } else {
+              throw new Error("Unknown type");
+            }
+          },
+          stopProcessingDescendants() {
+            visitDescendants = false;
+          },
+          setDescendantsContext(context) {
+            descendantContext = context;
+          },
+          setChildContext(child, context) {
+            childContexts.set(child, context);
+          }
+        },
+        context: descendantContext
+      };
+    }
+    visitor(visitorInfo);
+    if (!visitDescendants) {
+      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 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];
+        if (!isNestedNodeType(propObject.type)) {
+          continue;
+        }
+        if (typeof propObject.value === "string" && hasReferencedVariables(propObject.value) > 0) {
+          continue;
+        }
+        if (!Array.isArray(propObject.value)) {
+          const error = new BlockFormatError(
+            `${getComponentPath(currentQueueEntry.ancestorsAndSelf)}`,
+            propKey,
+            propObject.value
+          );
+          if (options == null ? void 0 : options.throwForInvalidBlockValues) {
+            throw error;
+          } else {
+            console.warn(`Skipped invalid block value: ${error.message}}`);
+            continue;
+          }
+        }
+        const blocks = (_b = propObject.value) != null ? _b : [];
+        for (let blockIndex = blocks.length - 1; blockIndex >= 0; blockIndex--) {
+          const enqueueingBlock = blocks[blockIndex];
+          const blockIndexFn = () => {
+            return getBlockValue(currentComponent.node, propKey).findIndex((x) => x === enqueueingBlock);
+          };
+          componentQueue.push({
+            ancestorsAndSelf: [
+              {
+                type: "block",
+                node: enqueueingBlock,
+                fieldName: propKey,
+                blockIndexFn
+              },
+              ...currentQueueEntry.ancestorsAndSelf
+            ],
+            context: descendantContext
+          });
+        }
+      }
+    }
+  } while (componentQueue.length > 0);
+}
+function isNestedNodeType(type) {
+  return type === CANVAS_BLOCK_PARAM_TYPE;
+}
+function getBlockValue(component, parameterName) {
+  var _a;
+  const parameter = (_a = getPropertiesValue(component)) == null ? void 0 : _a[parameterName];
+  if ((parameter == null ? void 0 : parameter.value) && parameter.type === CANVAS_BLOCK_PARAM_TYPE && Array.isArray(parameter.value)) {
+    return parameter.value;
+  }
+  return [];
+}
+var BlockFormatError = class _BlockFormatError extends Error {
+  constructor(componentPath, propertyId, blockValue) {
+    super(
+      `${componentPath} has an invalid block property value on ${propertyId}. Block values must be arrays of blocks (BlockValue type), but received ${blockValue === null ? "null" : typeof blockValue}`
+    );
+    this.componentPath = componentPath;
+    this.propertyId = propertyId;
+    this.blockValue = blockValue;
+    Object.setPrototypeOf(this, _BlockFormatError.prototype);
+  }
+};
+function createVariableReference(variableName) {
+  return `\${${variableName.replace(/([${}])/g, "\\$1")}}`;
+}
+var CANVAS_VIZ_CONTROL_PARAM = "$viz";
+var _baseUrl;
+var _IntegrationPropertyEditorsClient = class _IntegrationPropertyEditorsClient2 extends ApiClient {
+  constructor(options) {
+    super(options);
+    this.teamId = options.teamId;
+  }
+  /**
+   * Gets a list of property type and hook names for the current team, including public integrations' hooks.
+   */
+  get(options) {
+    const fetchUri = this.createUrl(__privateGet2(_IntegrationPropertyEditorsClient2, _baseUrl), {
+      ...options,
+      teamId: this.teamId
+    });
+    return this.apiClient(fetchUri);
+  }
+  /**
+   * Creates or updates a custom AI property editor on a Mesh app.
+   */
+  async deploy(body) {
+    const fetchUri = this.createUrl(__privateGet2(_IntegrationPropertyEditorsClient2, _baseUrl));
+    await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body, teamId: this.teamId }),
+      expectNoContent: true
+    });
+  }
+  /**
+   * Removes a custom AI property editor from a Mesh app.
+   */
+  async delete(body) {
+    const fetchUri = this.createUrl(__privateGet2(_IntegrationPropertyEditorsClient2, _baseUrl));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, teamId: this.teamId }),
+      expectNoContent: true
+    });
+  }
+};
+_baseUrl = /* @__PURE__ */ new WeakMap();
+__privateAdd2(_IntegrationPropertyEditorsClient, _baseUrl, "/api/v1/integration-property-editors");
+var _url22;
+var _ProjectClient = class _ProjectClient2 extends ApiClient {
+  constructor(options) {
+    super({ ...options, bypassCache: true });
+  }
+  /** Fetches single Project */
+  async get(options) {
+    const fetchUri = this.createUrl(__privateGet2(_ProjectClient2, _url22), { ...options });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) a Project */
+  async upsert(body) {
+    const fetchUri = this.createUrl(__privateGet2(_ProjectClient2, _url22));
+    return await this.apiClient(fetchUri, {
+      method: "PUT",
+      body: JSON.stringify({ ...body })
+    });
+  }
+  /** Deletes a Project */
+  async delete(body) {
+    const fetchUri = this.createUrl(__privateGet2(_ProjectClient2, _url22));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body }),
+      expectNoContent: true
+    });
+  }
+};
+_url22 = /* @__PURE__ */ new WeakMap();
+__privateAdd2(_ProjectClient, _url22, "/api/v1/project");
+var ROUTE_URL = "/api/v1/route";
+var RouteClient = class extends ApiClient {
+  constructor(options) {
+    var _a;
+    if (!options.limitPolicy) {
+      options.limitPolicy = createLimitPolicy({});
+    }
+    super(options);
+    this.edgeApiHost = (_a = options.edgeApiHost) != null ? _a : "https://uniform.global";
+  }
+  /** Fetches lists of Canvas compositions, optionally by type */
+  async getRoute(options) {
+    const { projectId } = this.options;
+    const fetchUri = this.createUrl(ROUTE_URL, { ...options, projectId }, this.edgeApiHost);
+    return await this.apiClient(
+      fetchUri,
+      this.options.disableSWR ? { headers: { "x-disable-swr": "true" } } : void 0
+    );
+  }
+};
+function mapSlotToPersonalizedVariations(slot) {
+  if (!slot) return [];
+  return slot.map((v, i) => {
+    var _a, _b;
+    const contextTag = (_b = (_a = v.parameters) == null ? void 0 : _a[CANVAS_PERSONALIZATION_PARAM]) == null ? void 0 : _b.value;
+    const id = (contextTag == null ? void 0 : contextTag.name) || `pz-${i}-${v.type}`;
+    return {
+      ...v,
+      id,
+      pz: contextTag
+    };
+  });
+}
+function mapSlotToTestVariations(slot) {
+  if (!slot) return [];
+  return slot.map((v, i) => {
+    var _a, _b, _c;
+    const contextTag = (_b = (_a = v.parameters) == null ? void 0 : _a[CANVAS_TEST_VARIANT_PARAM]) == null ? void 0 : _b.value;
+    const id = (_c = contextTag == null ? void 0 : contextTag.id) != null ? _c : "testId" in v ? v.testId : `ab-${i}-${v.type}`;
+    return {
+      ...v,
+      id,
+      testDistribution: contextTag == null ? void 0 : contextTag.testDistribution,
+      control: contextTag == null ? void 0 : contextTag.control
+    };
+  });
+}
+var isComponentPlaceholderId = (id) => {
+  if (id === PLACEHOLDER_ID) {
+    return true;
+  }
+  if (typeof id !== "string") {
+    return false;
+  }
+  return id == null ? void 0 : id.startsWith(PLACEHOLDER_ID);
+};
+
+// src/utils/env.ts
+var env = {
+  getProjectId: () => {
+    return process.env.UNIFORM_PROJECT_ID;
+  },
+  getApiKey: () => {
+    return process.env.UNIFORM_API_KEY;
+  },
+  getApiHost: () => {
+    return process.env.UNIFORM_API_HOST || process.env.UNIFORM_CLI_BASE_URL;
+  },
+  getEdgeApiHost: () => {
+    return process.env.UNIFORM_EDGE_API_HOST || process.env.UNIFORM_CLI_BASE_EDGE_URL;
+  }
+};
+
+// src/utils/tag.ts
+var buildPathTag = (path) => {
+  const actualPath = path.startsWith("/") ? path : `/${path}`;
+  return `path:${actualPath}`.toLowerCase();
+};
+var buildCompositionTag = (compositionId) => {
+  return `composition:${compositionId}`.toLowerCase();
+};
+
+// src/config/helpers.ts
+import serverConfig from "uniform.server.config";
+var getServerConfig = () => {
+  return serverConfig;
+};
+
+// src/utils/draft.ts
+var isDraftModeEnabled = ({
+  draftModeEnabled
+}) => {
+  return draftModeEnabled;
+};
+var isIncontextEditingEnabled = ({ searchParams }) => {
+  const containsKey = searchParams.has(IN_CONTEXT_EDITOR_QUERY_STRING_PARAM);
+  return containsKey;
+};
+var isDevelopmentEnvironment = () => {
+  return process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+};
+
+// src/clients/cache.ts
+var isSpecificCacheMode = (options) => {
+  return "cache" in options;
+};
+var isStateCacheMode = (options) => {
+  return "state" in options;
+};
+var isDetectCacheMode = (options) => {
+  return "searchParams" in options && "draftModeEnabled" in options;
+};
+var resolveManifestCache = (options) => {
+  return resolveCache({
+    options,
+    defaultCache: getServerConfig().manifestCache
+  });
+};
+var resolveCanvasCache = (options) => {
+  return resolveCache({
+    options,
+    defaultCache: getServerConfig().canvasCache
+  });
+};
+var resolveProjectMapCache = (options) => {
+  return resolveCache({
+    options,
+    defaultCache: getServerConfig().projectMapCache
+  });
+};
+var resolveCache = ({
+  options,
+  defaultCache
+}) => {
+  let cache2 = defaultCache;
+  if (options) {
+    if (isSpecificCacheMode(options)) {
+      cache2 = options.cache;
+    } else if (isStateCacheMode(options)) {
+      if (options.state === CANVAS_DRAFT_STATE || options.state === CANVAS_EDITOR_STATE) {
+        cache2 = {
+          type: "no-cache",
+          bypassCache: true
+        };
+      }
+    } else if (isDetectCacheMode(options)) {
+      const { disabled } = shouldCacheBeDisabled(options);
+      if (disabled) {
+        cache2 = {
+          type: "no-cache",
+          bypassCache: true
+        };
+      }
+    }
+  }
+  return cache2 || {
+    type: "force-cache"
+  };
+};
+var shouldCacheBeDisabled = (options) => {
+  if (isDraftModeEnabled(options)) {
+    return { disabled: true, reason: "DRAFT" };
+  }
+  if (isIncontextEditingEnabled(options)) {
+    return { disabled: true, reason: "INCONTEXT" };
+  }
+  if (isDevelopmentEnvironment()) {
+    return { disabled: true, reason: "DEV" };
+  }
+  return {
+    disabled: false,
+    reason: void 0
+  };
+};
+var determineFetchCacheOptions = (mode) => {
+  let cache2 = void 0;
+  let revalidate = void 0;
+  if (mode.type === "revalidate") {
+    cache2 = void 0;
+    revalidate = mode.interval;
+  } else {
+    cache2 = mode.type;
+  }
+  return {
+    cache: cache2,
+    revalidate
+  };
+};
+
+// src/clients/retry.ts
+function createThrottler(limit, interval) {
+  let available = limit;
+  let refillScheduled = false;
+  const waiting = [];
+  function scheduleRefill() {
+    if (refillScheduled) return;
+    refillScheduled = true;
+    setTimeout(() => {
+      refillScheduled = false;
+      available = limit;
+      while (available > 0 && waiting.length > 0) {
+        available--;
+        const next = waiting.shift();
+        next();
+      }
+      if (waiting.length > 0) {
+        scheduleRefill();
+      }
+    }, interval);
+  }
+  return async function throttle(fn) {
+    if (available > 0) {
+      available--;
+      if (!refillScheduled) {
+        scheduleRefill();
+      }
+      return fn();
+    }
+    return new Promise((resolve, reject) => {
+      waiting.push(() => {
+        fn().then(resolve, reject);
+      });
+      scheduleRefill();
+    });
+  };
+}
+function createLimiter(concurrency) {
+  let active = 0;
+  const queue = [];
+  return async function limit(fn) {
+    return new Promise((resolve, reject) => {
+      const run = async () => {
+        active++;
+        try {
+          const result = await fn();
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        } finally {
+          active--;
+          if (queue.length > 0) {
+            const next = queue.shift();
+            next();
+          }
+        }
+      };
+      if (active < concurrency) {
+        run();
+      } else {
+        queue.push(run);
+      }
+    });
+  };
+}
+async function retry(fn, options) {
+  let lastError;
+  let delay = 1e3;
+  for (let attempt = 1; attempt <= options.retries + 1; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      const attemptError = Object.assign(error, { attemptNumber: attempt });
+      if (options.onFailedAttempt) {
+        await options.onFailedAttempt(attemptError);
+      }
+      if (attempt > options.retries) {
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      delay *= options.factor;
+    }
+  }
+  throw lastError;
+}
+function createLimitPolicy2({
+  throttle = { interval: 1e3, limit: 10 },
+  retry: retryOptions = { retries: 1, factor: 1.66 },
+  limit = 10
+}) {
+  const throttler = throttle ? createThrottler(throttle.limit, throttle.interval) : null;
+  const limiter = limit ? createLimiter(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 (retryOptions) {
+      const retryFunc = currentFunc;
+      currentFunc = () => retry(retryFunc, {
+        ...retryOptions,
+        onFailedAttempt: async (error) => {
+          if (retryOptions.onFailedAttempt) {
+            await retryOptions.onFailedAttempt(error);
+          }
+          if (error instanceof ApiClientError && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
+            throw error;
+          }
+        }
+      });
+    }
+    return currentFunc();
+  };
+}
+
+// src/clients/canvas.ts
+var getCanvasClient = (options) => {
+  const cache2 = resolveCanvasCache(options);
+  return new CanvasClient({
+    projectId: env.getProjectId(),
+    apiHost: env.getApiHost(),
+    apiKey: env.getApiKey(),
+    edgeApiHost: env.getEdgeApiHost(),
+    disableSWR: typeof cache2.disableSWR !== "undefined" ? cache2.disableSWR : true,
+    limitPolicy: createLimitPolicy2({
+      limit: 6
+    }),
+    fetch: (req, init) => {
+      let requestedUrl;
+      if (typeof req === "string") {
+        requestedUrl = new URL(req);
+      } else if (req instanceof URL) {
+        requestedUrl = req;
+      } else {
+        requestedUrl = new URL(req.url);
+      }
+      const tags = [];
+      if (requestedUrl) {
+        const compositionIdKey = "compositionId";
+        const compositionIdsKey = "compositionIDs";
+        const compositionId = requestedUrl.searchParams.get(compositionIdKey);
+        const compositionIds = requestedUrl.searchParams.get(compositionIdsKey);
+        if (compositionId) {
+          tags.push(buildCompositionTag(compositionId));
+        }
+        if (compositionIds) {
+          const ids = compositionIds.split(",");
+          for (let i = 0; i < ids.length; i++) {
+            tags.push(buildCompositionTag(ids[i]));
+          }
+        }
+      }
+      const { cache: fetchCache, revalidate } = determineFetchCacheOptions(cache2);
+      return fetch(req, {
+        ...init,
+        cache: fetchCache,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "x-bypass-cache": typeof cache2.bypassCache !== "undefined" ? cache2.bypassCache.toString() : "false"
+        },
+        next: {
+          revalidate,
+          tags: tags.length ? tags : void 0
+        }
+      });
+    }
+  });
+};
+
+// src/clients/manifest.ts
+import "server-only";
+
+// src/clients/tags.ts
+var generateRouteCacheTags = ({ path, old }) => {
+  const tags = old ? ["route-old"] : ["route"];
+  if (path) {
+    const pathWithoutQuery = path.split("?")[0];
+    const pieces = pathWithoutQuery.split("/");
+    for (let i = 0; i < pieces.length; i++) {
+      const segmentPieces = pieces.slice(0, i + 1);
+      const segment = segmentPieces.join("/");
+      tags.push(buildPathTag(segment));
+    }
+  }
+  return tags;
+};
+var generateManifestCacheTags = () => {
+  return ["manifest"];
+};
+
+// src/clients/manifest.ts
+var getManifestClient = (options) => {
+  const cache2 = resolveManifestCache(options);
+  const manifestClient = new ManifestClient({
+    apiHost: env.getApiHost(),
+    apiKey: env.getApiKey(),
+    projectId: env.getProjectId(),
+    limitPolicy: createLimitPolicy2({
+      limit: 6
+    }),
+    fetch: (req, init) => {
+      const { cache: fetchCache, revalidate } = determineFetchCacheOptions(cache2);
+      return fetch(req, {
+        ...init,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "x-bypass-cache": typeof cache2.bypassCache !== "undefined" ? cache2.bypassCache.toString() : "false"
+        },
+        cache: fetchCache,
+        next: {
+          revalidate,
+          tags: generateManifestCacheTags()
+        }
+      });
+    }
+  });
+  return manifestClient;
+};
+var getManifest = async (options) => {
+  let preview = false;
+  if (options && isStateCacheMode(options)) {
+    preview = options.state === CANVAS_DRAFT_STATE || options.state === CANVAS_EDITOR_STATE;
+  }
+  const manifestClient = getManifestClient(options);
+  return manifestClient.get({
+    preview
+  });
+};
+
+// src/clients/projectMap.ts
+import "server-only";
+
+// ../project-map/dist/index.mjs
+var __typeError3 = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck3 = (obj, member, msg) => member.has(obj) || __typeError3("Cannot " + msg);
+var __privateGet3 = (obj, member, getter) => (__accessCheck3(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd3 = (obj, member, value) => member.has(obj) ? __typeError3("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck3(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck3(obj, member, "access private method"), method);
+var ProjectMapClient = class extends ApiClient {
+  constructor(options) {
+    super(options);
+    this.getProjectMapDefinitions = async () => {
+      const { projectId } = this.options;
+      const fetchUri = this.createUrl("/api/v1/project-map", { projectId });
+      return await this.apiClient(fetchUri);
+    };
+    this.getProjectMapDefinition = async (options2) => {
+      const { projectId } = this.options;
+      const fetchUri = this.createUrl("/api/v1/project-map", {
+        ...options2,
+        projectId
+      });
+      return await this.apiClient(fetchUri);
+    };
+    this.upsertProjectMap = async (options2) => {
+      const { projectId } = this.options;
+      const fetchUri = this.createUrl("/api/v1/project-map");
+      const result = await this.apiClient(fetchUri, {
+        method: "PUT",
+        body: JSON.stringify({ ...options2, projectId })
+      });
+      return result.projectMapId;
+    };
+    this.deleteProjectMap = async (options2) => {
+      const { projectId } = this.options;
+      const fetchUri = this.createUrl("/api/v1/project-map");
+      await this.apiClient(fetchUri, {
+        method: "DELETE",
+        body: JSON.stringify({ ...options2, projectId }),
+        expectNoContent: true
+      });
+    };
+    this.upsertProjectMapNodes = async (options2) => {
+      const { projectId } = this.options;
+      const fetchUri = this.createUrl("/api/v1/project-map-nodes");
+      await this.apiClient(fetchUri, {
+        method: "PUT",
+        body: JSON.stringify({
+          ...options2,
+          projectId,
+          nodes: options2.nodes.map((n) => {
+            return {
+              ...n,
+              node: { ...this.cleanProjectMapNode(n.node) }
+            };
+          })
+        }),
+        expectNoContent: true
+      });
+    };
+    this.deleteProjectMapNode = async (options2) => {
+      const { projectId } = this.options;
+      const fetchUri = this.createUrl("/api/v1/project-map-nodes");
+      await this.apiClient(fetchUri, {
+        method: "DELETE",
+        body: JSON.stringify({
+          ...options2,
+          projectId
+        }),
+        expectNoContent: true
+      });
+    };
+    this.getSubtree = async (options2) => {
+      var _a;
+      const fetchOptions = this.setFetchOptions(options2);
+      fetchOptions["tree"] = "true";
+      const fetchUri = this.createUrl("/api/v1/project-map-nodes", fetchOptions);
+      const result = await this.apiClient(fetchUri);
+      const root = {
+        ...result.tree
+      };
+      const nodes = [root];
+      while (nodes && nodes.length > 0) {
+        const currentNode = nodes.pop();
+        let lastChild = void 0;
+        (_a = currentNode == null ? void 0 : currentNode.children) == null ? void 0 : _a.forEach((child) => {
+          child.parent = cutReferences(currentNode);
+          child.previousSibling = cutReferences(lastChild);
+          if (lastChild) {
+            lastChild.nextSibling = cutReferences(child);
+          }
+          lastChild = child;
+          nodes.push(child);
+        });
+      }
+      return root;
+    };
+    this.getNodes = async (options2) => {
+      const fetchOptions = this.setFetchOptions(options2);
+      const fetchUri = this.createUrl("/api/v1/project-map-nodes", fetchOptions);
+      return await this.apiClient(fetchUri);
+    };
+  }
+  setFetchOptions(options) {
+    const { projectId } = this.options;
+    const fetchOptions = {
+      projectId
+    };
+    Object.entries(options).forEach(([key, value]) => {
+      if (value === void 0) {
+        return;
+      }
+      if (typeof value === "boolean") {
+        if (!value) {
+          return;
+        }
+        fetchOptions[key] = "true";
+        return;
+      }
+      if (typeof value === "number") {
+        fetchOptions[key] = value.toString(10);
+        return;
+      }
+      fetchOptions[key] = value;
+    });
+    return fetchOptions;
+  }
+  cleanProjectMapNode(node) {
+    var _a, _b, _c;
+    return {
+      id: ((_c = (_b = (_a = node.id) == null ? void 0 : _a.match(/^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i)) == null ? void 0 : _b.length) != null ? _c : 0) == 1 ? node.id : void 0,
+      path: node.path,
+      name: node.name,
+      type: node.type,
+      order: node.order,
+      data: node.data,
+      compositionId: node.compositionId,
+      description: node.description,
+      locales: node.locales
+    };
+  }
+};
+var cutReferences = (node) => node ? {
+  ...node,
+  parent: void 0,
+  children: void 0
+} : void 0;
+var _routeInfo;
+var _Route_static;
+var parseRouteOrPath_fn;
+var isDynamicRouteSegment_fn;
+var _Route = class _Route2 {
+  constructor(route) {
+    this.route = route;
+    __privateAdd3(this, _routeInfo);
+    var _a;
+    __privateSet(this, _routeInfo, __privateMethod(_a = _Route2, _Route_static, parseRouteOrPath_fn).call(_a, this.route));
+  }
+  get dynamicSegmentCount() {
+    return __privateGet3(this, _routeInfo).segments.reduce(
+      (count, segment) => {
+        var _a;
+        return __privateMethod(_a = _Route2, _Route_static, isDynamicRouteSegment_fn).call(_a, segment) ? count + 1 : count;
+      },
+      0
+    );
+  }
+  /** Tests if an incoming path matches this route */
+  matches(path) {
+    var _a, _b;
+    const { segments: pathSegments, queryParams: pathQuery } = __privateMethod(_a = _Route2, _Route_static, parseRouteOrPath_fn).call(_a, path);
+    const { segments: routeSegments } = __privateGet3(this, _routeInfo);
+    if (pathSegments.length !== routeSegments.length) {
+      return { match: false };
+    }
+    const possibleMatch = {
+      match: true,
+      dynamicSegmentCount: 0,
+      pathParams: {},
+      queryParams: {}
+    };
+    for (let i = 0; i < routeSegments.length; i++) {
+      const routeSegment = routeSegments[i];
+      const pathSegment = pathSegments[i];
+      if (__privateMethod(_b = _Route2, _Route_static, isDynamicRouteSegment_fn).call(_b, routeSegment)) {
+        const key = routeSegment.slice(1);
+        possibleMatch.pathParams[key] = pathSegment;
+        possibleMatch.dynamicSegmentCount++;
+      } else if (routeSegment !== pathSegment) {
+        return { match: false };
+      }
+    }
+    for (const [key, value] of __privateGet3(this, _routeInfo).queryParams) {
+      possibleMatch.queryParams[key] = pathQuery.has(key) ? pathQuery.get(key) : value;
+    }
+    return possibleMatch;
+  }
+  /**
+   * Creates an expanded path value for this route given dynamic input values and allowed query string values
+   */
+  expand(options) {
+    const { dynamicInputValues = {}, allowedQueryParams = [], doNotEscapeVariables = false } = options != null ? options : {};
+    const path = __privateGet3(this, _routeInfo).segments.map((segment) => {
+      const dynamicSegmentName = _Route2.getDynamicRouteSegmentName(segment);
+      if (!dynamicSegmentName) {
+        return segment;
+      }
+      const dynamicSegmentValue = dynamicInputValues[dynamicSegmentName];
+      if (!dynamicSegmentValue) {
+        return segment;
+      }
+      return encodeRouteComponent(dynamicSegmentValue, doNotEscapeVariables);
+    }).join("/");
+    const queries = allowedQueryParams.filter((qs) => {
+      const type = typeof dynamicInputValues[qs];
+      return type === "string" || type === "number" || type === "boolean";
+    }).map(
+      (qs) => `${encodeRouteComponent(qs, doNotEscapeVariables)}=${encodeRouteComponent(
+        dynamicInputValues[qs],
+        doNotEscapeVariables
+      )}`
+    );
+    const query = queries.length ? `?${queries.join("&")}` : "";
+    return `/${path}${query}`;
+  }
+  static getDynamicRouteSegmentName(segment) {
+    var _a;
+    if (!__privateMethod(_a = _Route2, _Route_static, isDynamicRouteSegment_fn).call(_a, segment)) {
+      return void 0;
+    }
+    return segment.slice(_Route2.dynamicSegmentPrefix.length);
+  }
+};
+_routeInfo = /* @__PURE__ */ new WeakMap();
+_Route_static = /* @__PURE__ */ new WeakSet();
+parseRouteOrPath_fn = function(path) {
+  if (!path.startsWith("/") || path === "") {
+    throw new Error(`Path must start with a slash: ${path}`);
+  }
+  const [pathname, queryString] = path.split("?");
+  const pathSegments = pathname.substring(1).split("/");
+  if (pathSegments[pathSegments.length - 1] === "") {
+    pathSegments.pop();
+  }
+  const queryParams = new URLSearchParams(queryString);
+  return { segments: pathSegments, queryParams };
+};
+isDynamicRouteSegment_fn = function(segment) {
+  if (!segment) {
+    return false;
+  }
+  return segment.startsWith(_Route.dynamicSegmentPrefix);
+};
+__privateAdd3(_Route, _Route_static);
+_Route.dynamicSegmentPrefix = ":";
+function encodeRouteComponent(value, doNotEscapeVariables) {
+  if (!doNotEscapeVariables) {
+    return encodeURIComponent(value);
+  }
+  const result = [];
+  parseVariableExpression(value.toString(10), (token, type) => {
+    if (type === "variable") {
+      result.push(createVariableReference(token));
+    } else {
+      result.push(encodeURIComponent(token));
+    }
+  });
+  return result.join("");
+}
+
+// src/clients/projectMap.ts
+var getProjectMapClient = (options) => {
+  const cache2 = resolveProjectMapCache(options);
+  const manifestClient = new ProjectMapClient({
+    apiHost: env.getApiHost(),
+    apiKey: env.getApiKey(),
+    projectId: env.getProjectId(),
+    limitPolicy: createLimitPolicy2({
+      limit: 6
+    }),
+    fetch: (req, init) => {
+      const { cache: fetchCache, revalidate } = determineFetchCacheOptions(cache2);
+      return fetch(req, {
+        ...init,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "x-bypass-cache": typeof cache2.bypassCache !== "undefined" ? cache2.bypassCache.toString() : "false"
+        },
+        cache: fetchCache,
+        next: {
+          revalidate
+        }
+      });
+    }
+  });
+  return manifestClient;
+};
+
+// src/clients/route.ts
+import "server-only";
+var getRouteCacheTags = (requestedUrl) => {
+  const tags = ["route"];
+  if (requestedUrl) {
+    const pathKey = "path";
+    const path = requestedUrl.searchParams.get(pathKey);
+    if (path) {
+      return generateRouteCacheTags({ path });
+    }
+  }
+  return tags;
+};
+var getRouteClient = (options) => {
+  const cache2 = resolveCanvasCache(options);
+  const client = new RouteClient({
+    projectId: env.getProjectId(),
+    apiKey: env.getApiKey(),
+    edgeApiHost: env.getEdgeApiHost(),
+    disableSWR: typeof cache2.disableSWR !== "undefined" ? cache2.disableSWR : true,
+    limitPolicy: createLimitPolicy2({
+      limit: 6
+    }),
+    fetch: (req, init) => {
+      let requestedUrl;
+      if (typeof req === "string") {
+        requestedUrl = new URL(req);
+      } else if (req instanceof URL) {
+        requestedUrl = req;
+      } else {
+        requestedUrl = new URL(req.url);
+      }
+      const tags = getRouteCacheTags(requestedUrl);
+      const { cache: fetchCache, revalidate } = determineFetchCacheOptions(cache2);
+      return fetch(req, {
+        ...init,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "x-bypass-cache": typeof cache2.bypassCache !== "undefined" ? cache2.bypassCache.toString() : "false"
+        },
+        cache: fetchCache,
+        next: {
+          revalidate,
+          tags: tags.length ? tags : void 0
+        }
+      });
+    }
+  });
+  return client;
+};
+
+// src/components/UniformComposition.tsx
+import { PureContextualEditingComponentWrapper } from "@uniformdev/canvas-react/core";
+import { ContextUpdateTransfer, Personalize, UniformScript } from "@uniformdev/next-app-router-client";
+import {
+  resolveRuleFromPageState
+} from "@uniformdev/next-app-router-shared";
+import { notFound } from "next/navigation";
+import React5, { createElement as createElement2, Fragment as Fragment3, Suspense as Suspense2 } from "react";
+
+// src/data/extract/extractTest.ts
+import { extractTestName } from "@uniformdev/next-app-router-shared";
+var extractTest = ({ component }) => {
+  var _a;
+  const testName = extractTestName({ component });
+  const slot = ((_a = component.slots) == null ? void 0 : _a[CANVAS_TEST_SLOT]) || [];
+  const componentVariations = mapSlotToTestVariations(slot).map((variation, index) => {
+    const slotComponent = slot[index];
+    if (!slotComponent) {
+      throw new Error(`Slot component not found for index ${index}`);
+    }
+    return {
+      ...variation,
+      index,
+      componentId: slotComponent._id
+    };
+  });
+  return {
+    name: testName,
+    variations: componentVariations
+  };
+};
+
+// src/components/ComponentProps.ts
+import {
+  resolveComponentFromPageState
+} from "@uniformdev/next-app-router-shared";
+var createComponentProps = ({
+  component,
+  parent,
+  isRoot,
+  slotName,
+  slotIndex,
+  slots,
+  pageState,
+  composition,
+  compositionContext
+}) => {
+  var _a, _b;
+  const parameters = (_a = component.parameters) != null ? _a : {};
+  const componentProps = {
+    parameters: Object.keys(parameters).reduce((acc, cur) => {
+      acc[cur] = {
+        parameterId: cur,
+        ...parameters[cur]
+      };
+      return acc;
+    }, {}),
+    component: {
+      _id: component._id,
+      _parentId: (_b = parent == null ? void 0 : parent._id) != null ? _b : null,
+      slotName,
+      slotIndex: isRoot ? void 0 : slotIndex
+    },
+    type: component.type,
+    variant: component.variant,
+    slots,
+    context: {
+      isContextualEditing: pageState.compositionState === CANVAS_EDITOR_STATE,
+      _id: composition._id,
+      state: pageState.compositionState,
+      type: composition.type,
+      pageState,
+      matchedRoute: compositionContext.matchedRoute,
+      dynamicInputs: compositionContext.dynamicInputs
+    }
+  };
+  return componentProps;
+};
+var createPersonalizeComponentProps = ({
+  common,
+  componentId,
+  pageState
+}) => {
+  var _a;
+  const component = resolveComponentFromPageState({
+    pageState,
+    componentId
+  });
+  return {
+    ...common,
+    indexes: (_a = component == null ? void 0 : component.indexes) != null ? _a : []
+  };
+};
+var createTestComponentProps = ({
+  common,
+  componentId,
+  pageState,
+  test
+}) => {
+  var _a;
+  const component = resolveComponentFromPageState({
+    pageState,
+    componentId
+  });
+  const [testIndex] = (_a = component == null ? void 0 : component.indexes) != null ? _a : [];
+  return {
+    ...common,
+    index: testIndex != null ? testIndex : 0,
+    test
+  };
+};
+
+// src/components/helpers/applyEditableParameters.ts
+var applyEditableParameters = ({
+  composition,
+  state
+}) => {
+  if (state === CANVAS_EDITOR_STATE) {
+    walkNodeTree(composition, (node) => {
+      var _a, _b;
+      if (node.type === "component" && node.node.parameters) {
+        const contextualEditing = node.node.parameters[CANVAS_CONTEXTUAL_EDITING_PARAM];
+        const editableFields = (_b = (_a = contextualEditing == null ? void 0 : contextualEditing.value) == null ? void 0 : _a.editableParameters) != null ? _b : [];
+        Object.keys(node.node.parameters).forEach((key) => {
+          const parameter = node.node.parameters[key];
+          if (parameter.type === "text") {
+            const contextualParameter = parameter;
+            contextualParameter._contextualEditing = {
+              isEditable: editableFields.includes(key)
+            };
+          }
+        });
+      }
+    });
+  }
+};
+
+// src/components/Test.tsx
+import { createElement, Fragment } from "react";
+
+// src/components/ContextTestTransfer.tsx
+import { ClientContextTestTransfer } from "@uniformdev/next-app-router-client";
+import React from "react";
+var ContextTestTransfer = ({ event }) => {
+  return /* @__PURE__ */ React.createElement(ClientContextTestTransfer, { event });
+};
+
+// src/components/Test.tsx
+var Test = ({ index, slots, test, component, context: compositionContext }) => {
+  var _a, _b, _c, _d, _e, _f;
+  const indexToShow = typeof index === "number" ? (_b = (_a = slots == null ? void 0 : slots[CANVAS_TEST_SLOT]) == null ? void 0 : _a.items[index]) != null ? _b : null : null;
+  const event = {
+    name: test.name,
+    // todo: add Control Group support
+    control: (_d = (_c = test.variations[index]) == null ? void 0 : _c.control) != null ? _d : false,
+    variantAssigned: true,
+    variantId: (_f = (_e = test.variations[index]) == null ? void 0 : _e.id) != null ? _f : "NO_VARIANTS",
+    compositionMetadata: {
+      compositionId: compositionContext._id,
+      matchedRoute: compositionContext.matchedRoute,
+      dynamicInputs: compositionContext.dynamicInputs
+    }
+  };
+  const eventElement = createElement(ContextTestTransfer, {
+    event,
+    key: `${component.slotName}-${component.slotIndex}-server-transfer`
+  });
+  return createElement(Fragment, void 0, [indexToShow == null ? void 0 : indexToShow.component, eventElement]);
+};
+
+// src/components/UniformCompositionWrapper.tsx
+import { deserializeEvaluationResult } from "@uniformdev/next-app-router-shared";
+import React2, { Fragment as Fragment2, Suspense } from "react";
+var UniformCompositionWrapper = ({
+  code,
+  children
+}) => {
+  const data = deserializeEvaluationResult({ input: code });
+  const WrapperComponent = data.compositionState === CANVAS_EDITOR_STATE || data.compositionState === CANVAS_DRAFT_STATE ? Suspense : Fragment2;
+  return /* @__PURE__ */ React2.createElement(WrapperComponent, null, children);
+};
+
+// src/components/UniformContext.tsx
+import { DefaultUniformClientContext } from "@uniformdev/next-app-router-client";
+import React3 from "react";
+var UniformContext = async ({ clientContextComponent, result }) => {
+  var _a, _b, _c, _d;
+  const manifest = await getManifest({
+    state: CANVAS_PUBLISHED_STATE
+  });
+  const { route } = result != null ? result : {};
+  const compositionMetadata = route ? {
+    compositionId: route.compositionApiResponse.composition._id,
+    dynamicInputs: route.dynamicInputs,
+    matchedRoute: route.matchedRoute
+  } : void 0;
+  const ContextComponent = clientContextComponent || DefaultUniformClientContext;
+  const serverConfig2 = getServerConfig();
+  const disableDevTools = ((_a = serverConfig2.context) == null ? void 0 : _a.disableDevTools) || false;
+  const defaultConsent = (_c = (_b = result == null ? void 0 : result.pageState.defaultConsent) != null ? _b : serverConfig2.defaultConsent) != null ? _c : false;
+  const experimentalQuirkSerialization = ((_d = serverConfig2.experimental) == null ? void 0 : _d.quirkSerialization) || false;
+  return /* @__PURE__ */ React3.createElement(React3.Fragment, null, /* @__PURE__ */ React3.createElement(
+    ContextComponent,
+    {
+      manifest,
+      disableDevTools,
+      defaultConsent,
+      experimentalQuirkSerialization,
+      compositionMetadata
+    }
+  ));
+};
+
+// src/components/VisibilityRulesWrapper.tsx
+import { VisibilityRulesWrapperClient } from "@uniformdev/next-app-router-client";
+import React4 from "react";
+var VisibilityRulesWrapper = ({
+  parameter,
+  initialIsVisible,
+  children
+}) => {
+  return /* @__PURE__ */ React4.createElement(VisibilityRulesWrapperClient, { parameter, initialIsVisible }, children);
+};
+
+// src/components/UniformComposition.tsx
+function UniformComposition({ code, ...props }) {
+  return /* @__PURE__ */ React5.createElement(UniformCompositionWrapper, { code }, /* @__PURE__ */ React5.createElement(UniformCompositionInner, { code, ...props }));
+}
+async function UniformCompositionInner({
+  code,
+  resolveRoute,
+  resolveComponent,
+  resolveEmptyPlaceholder,
+  compositionCache,
+  clientContextComponent
+}) {
+  var _a, _b;
+  const result = await resolveRoute({
+    params: Promise.resolve({ code })
+  });
+  if (!(result == null ? void 0 : result.route) || ((_a = result == null ? void 0 : result.route) == null ? void 0 : _a.type) !== "composition") {
+    notFound();
+  }
+  const { pageState, route } = result;
+  const composition = result.route.compositionApiResponse.composition;
+  applyEditableParameters({
+    composition,
+    state: route.compositionApiResponse.state
+  });
+  compositionCache == null ? void 0 : compositionCache.setUniformComposition(composition);
+  const compositionContext = {
+    _id: composition._id,
+    type: composition.type,
+    state: pageState.compositionState,
+    isContextualEditing: pageState.compositionState === CANVAS_EDITOR_STATE,
+    matchedRoute: route.matchedRoute,
+    dynamicInputs: (_b = route.dynamicInputs) != null ? _b : {},
+    pageState
+  };
+  const [resolved] = resolveComponents({
+    target: {
+      type: "root",
+      composition
+    },
+    pageState,
+    slotName: void 0,
+    slotIndex: void 0,
+    resolveComponent,
+    resolveEmptyPlaceholder,
+    composition,
+    compositionContext
+  });
+  return /* @__PURE__ */ React5.createElement(React5.Fragment, null, resolved, /* @__PURE__ */ React5.createElement(Suspense2, null, /* @__PURE__ */ React5.createElement(
+    UniformContext,
+    {
+      clientContextComponent,
+      result: {
+        code,
+        pageState,
+        route
+      }
+    }
+  )), (pageState.compositionState === CANVAS_EDITOR_STATE || pageState.compositionState === CANVAS_DRAFT_STATE) && /* @__PURE__ */ React5.createElement(UniformScript, null));
+}
+var resolveComponents = ({
+  target,
+  pageState,
+  slotName,
+  slotIndex,
+  resolveComponent,
+  resolveEmptyPlaceholder,
+  composition,
+  compositionContext
+}) => {
+  const isRoot = !slotName && typeof slotIndex !== "number";
+  let root;
+  let parent = void 0;
+  let components;
+  if (target.type === "root") {
+    root = target.composition;
+    components = [target.composition];
+  } else {
+    root = target.root;
+    components = target.components;
+    parent = target.parent;
+  }
+  const resolved = components.map((component, componentIndex) => {
+    var _a, _b, _c;
+    const isPlaceholder = isComponentPlaceholderId(component == null ? void 0 : component._id);
+    let resolveResult = null;
+    if (isPlaceholder && resolveEmptyPlaceholder) {
+      const resolvedPlaceholder = resolveEmptyPlaceholder({
+        parentComponent: parent,
+        component,
+        slotName,
+        slotIndex: componentIndex
+      });
+      if (resolvedPlaceholder) {
+        resolveResult = {
+          component: resolvedPlaceholder.component
+        };
+      }
+    }
+    if (!resolveResult) {
+      resolveResult = resolveComponent({ component });
+    }
+    const { component: resolvedComponent, suspense: componentSuspense } = resolveResult || {
+      component: null
+    };
+    const slots = resolveSlots({
+      component,
+      root,
+      resolveComponent,
+      resolveEmptyPlaceholder,
+      pageState,
+      composition,
+      compositionContext
+    });
+    const wrapInSuspense = componentSuspense;
+    const parameters = (_a = component.parameters) != null ? _a : {};
+    const enrichmentTags = (_b = parameters[CANVAS_ENRICHMENT_TAG_PARAM]) == null ? void 0 : _b.value;
+    const visibilityRules = (_c = parameters[CANVAS_VIZ_CONTROL_PARAM]) == null ? void 0 : _c.value;
+    if (!component._id) {
+      console.warn(`Component ${component.type} has no _id`);
+    }
+    const key = `${slotName}-${componentIndex}-component`;
+    const componentProps = createComponentProps({
+      component,
+      parent: parent != null ? parent : null,
+      isRoot,
+      slotName,
+      slotIndex: isRoot ? void 0 : componentIndex,
+      slots,
+      pageState,
+      composition,
+      compositionContext
+    });
+    let element = null;
+    if (wrapInSuspense) {
+      element = createElement2(
+        Suspense2,
+        {
+          key,
+          fallback: typeof wrapInSuspense === "boolean" || typeof (wrapInSuspense == null ? void 0 : wrapInSuspense.fallback) === "undefined" ? void 0 : createElement2(wrapInSuspense.fallback)
+        },
+        createResolvedComponent({ component, props: componentProps, resolvedComponent, pageState })
+      );
+    } else {
+      element = createResolvedComponent({
+        component,
+        props: componentProps,
+        resolvedComponent,
+        pageState,
+        key
+      });
+    }
+    let tagElement = null;
+    if (enrichmentTags == null ? void 0 : enrichmentTags.length) {
+      tagElement = createElement2(ContextUpdateTransfer, {
+        key: `${slotName}-${componentIndex}-tags`,
+        update: {
+          enrichments: enrichmentTags
+        }
+      });
+    }
+    let childNode;
+    if (pageState.compositionState === CANVAS_EDITOR_STATE) {
+      const elements = [element];
+      if (tagElement) {
+        elements.push(tagElement);
+      }
+      const isPlaceholder2 = isComponentPlaceholderId(component == null ? void 0 : component._id);
+      if (!isPlaceholder2 || pageState.compositionState === CANVAS_EDITOR_STATE) {
+        childNode = createElement2(
+          PureContextualEditingComponentWrapper,
+          {
+            key: `${slotName}-${componentIndex}-wrapper`,
+            isPlaceholder: isPlaceholder2,
+            parentComponent: parent,
+            component,
+            slotName,
+            indexInSlot: componentIndex,
+            slotChildrenCount: components.length,
+            isReadOnly: "false"
+          },
+          elements
+        );
+      }
+    } else {
+      const elements = [element];
+      if (tagElement) {
+        elements.push(tagElement);
+      }
+      childNode = elements;
+    }
+    if (visibilityRules) {
+      const isVisible = resolveRuleFromPageState({
+        pageState,
+        rule: visibilityRules
+      });
+      childNode = createElement2(
+        VisibilityRulesWrapper,
+        {
+          key: `${slotName}-${componentIndex}-visibility`,
+          parameter: visibilityRules,
+          initialIsVisible: isVisible != null ? isVisible : null
+        },
+        childNode
+      );
+    }
+    return createElement2(
+      Fragment3,
+      {
+        key: !isRoot ? `${slotName}-${componentIndex}` : void 0
+      },
+      childNode
+    );
+  });
+  return resolved;
+};
+var createResolvedComponent = ({
+  component,
+  props,
+  resolvedComponent,
+  pageState,
+  key
+}) => {
+  if (component.type === CANVAS_PERSONALIZE_TYPE) {
+    const personalizeProps = createPersonalizeComponentProps({
+      common: props,
+      componentId: component._id,
+      pageState
+    });
+    return createElement2(Personalize, { ...personalizeProps, key });
+  }
+  if (component.type === CANVAS_TEST_TYPE) {
+    const extractedTest = extractTest({
+      component
+    });
+    const testProps = createTestComponentProps({
+      common: props,
+      componentId: component._id,
+      pageState,
+      test: extractedTest
+    });
+    return createElement2(Test, { ...testProps, key });
+  }
+  if (!resolvedComponent) {
+    return null;
+  }
+  return createElement2(resolvedComponent, { ...props, key });
+};
+var resolveSlots = ({
+  component,
+  root,
+  resolveComponent,
+  resolveEmptyPlaceholder,
+  pageState,
+  composition,
+  compositionContext
+}) => {
+  const slots = {};
+  if (component.slots) {
+    Object.keys(component.slots).forEach((slotName, slotIndex) => {
+      const components = component.slots[slotName];
+      const resolved = resolveComponents({
+        target: {
+          type: "slot",
+          components,
+          root,
+          parent: component
+        },
+        slotName,
+        slotIndex,
+        resolveComponent,
+        resolveEmptyPlaceholder,
+        pageState,
+        composition,
+        compositionContext
+      });
+      if (resolved) {
+        let variantIds;
+        if (component.type === CANVAS_PERSONALIZE_TYPE) {
+          variantIds = mapSlotToPersonalizedVariations(components).map((v) => v.id);
+        } else if (component.type === CANVAS_TEST_TYPE) {
+          variantIds = mapSlotToTestVariations(components).map((v) => v.id);
+        }
+        slots[slotName] = {
+          name: slotName,
+          items: components.map((component2, index) => {
+            var _a, _b;
+            const item = resolved[index];
+            if (!item) {
+              return null;
+            }
+            const pzCriteria = (_b = (_a = component2.parameters) == null ? void 0 : _a[CANVAS_PERSONALIZATION_PARAM]) == null ? void 0 : _b.value;
+            return {
+              _id: component2._id,
+              variantId: variantIds == null ? void 0 : variantIds[index],
+              [CANVAS_PERSONALIZATION_PARAM]: pzCriteria,
+              component: item
+            };
+          })
+        };
+      }
+    });
+  }
+  return slots;
+};
+
+// src/components/UniformPlayground.tsx
+import { draftMode } from "next/headers";
+import React6 from "react";
+
+// src/data/resolvePlaygroundRoute.ts
+import { deserializeEvaluationResult as deserializeEvaluationResult2 } from "@uniformdev/next-app-router-shared";
+var resolvePlaygroundRoute = async ({
+  params
+}) => {
+  const { code } = await params;
+  const pageState = deserializeEvaluationResult2({ input: code });
+  const canvasClient = getCanvasClient({
+    cache: {
+      type: "no-cache"
+    }
+  });
+  let composition = void 0;
+  try {
+    composition = await canvasClient.getCompositionById({
+      compositionId: pageState.routePath,
+      state: pageState.compositionState,
+      withComponentIDs: true
+    });
+  } catch (e) {
+    console.warn(
+      `Failed to get composition ${pageState.routePath} with state ${pageState.compositionState}`,
+      e
+    );
+  }
+  if (!composition) {
+    return {
+      code,
+      pageState,
+      route: void 0
+    };
+  }
+  return {
+    code,
+    pageState,
+    route: {
+      type: "composition",
+      compositionApiResponse: composition,
+      matchedRoute: "composition"
+    }
+  };
+};
+
+// src/components/UniformPlayground.tsx
+var UniformPlayground = async ({ resolveRoute, ...rest }) => {
+  const isDraftMode = (await draftMode()).isEnabled;
+  if (!isDraftMode) {
+    return /* @__PURE__ */ React6.createElement("div", null, /* @__PURE__ */ React6.createElement("h1", null, "Playground is only available in draft mode"));
+  }
+  return /* @__PURE__ */ React6.createElement(UniformComposition, { ...rest, resolveRoute: resolvePlaygroundRoute });
+};
+
+// src/components/generateStaticParams.ts
+import { serializeEvaluationResult } from "@uniformdev/next-app-router-shared";
+
+// src/data/extract/extractRunnables.ts
+import { getRuleId } from "@uniformdev/next-app-router-shared";
+
+// src/data/extract/extractPersonalization.ts
+import {
+  extractPersonalizationName
+} from "@uniformdev/next-app-router-shared";
+var extractPersonalization = ({
+  component
+}) => {
+  var _a, _b, _c;
+  const trackingEventName = extractPersonalizationName({ component });
+  const countParameter = (_a = component.parameters) == null ? void 0 : _a.count;
+  const algorithmParameter = (_b = component.parameters) == null ? void 0 : _b.algorithm;
+  const count = countParameter == null ? void 0 : countParameter.value;
+  const algorithm = algorithmParameter == null ? void 0 : algorithmParameter.value;
+  let parsedCount;
+  if (typeof count === "string") {
+    parsedCount = parseInt(count, 10);
+  } else if (typeof count !== "number") {
+    parsedCount = void 0;
+  } else {
+    parsedCount = count || 1;
+  }
+  const slot = ((_c = component.slots) == null ? void 0 : _c[CANVAS_PERSONALIZE_SLOT]) || [];
+  const componentVariations = mapSlotToPersonalizedVariations(
+    slot
+  ).map((variant, index) => {
+    const slotComponent = slot[index];
+    if (!slotComponent) {
+      throw new Error(`Slot component not found for index ${index}`);
+    }
+    return {
+      ...variant,
+      index,
+      componentId: slotComponent._id
+    };
+  });
+  return {
+    name: trackingEventName,
+    take: parsedCount,
+    variations: componentVariations,
+    algorithm
+  };
+};
+
+// src/data/extract/extractRunnables.ts
+var findAncestorVariant = (ancestorsAndSelf) => {
+  let nodeIndex = -1;
+  for (let i = 1; i < ancestorsAndSelf.length; i++) {
+    const node = ancestorsAndSelf[i];
+    if (node.type === "slot" && (node.parentSlot === CANVAS_PERSONALIZE_SLOT || node.parentSlot === CANVAS_TEST_SLOT)) {
+      nodeIndex = i;
+      break;
+    }
+  }
+  if (nodeIndex !== -1) {
+    const node = ancestorsAndSelf[nodeIndex];
+    return node.node._id;
+  }
+  return void 0;
+};
+var extractRunnables = (composition) => {
+  const runnable = [];
+  walkNodeTree(composition, (node) => {
+    var _a, _b;
+    if (node.type === "component") {
+      const component = node.node;
+      const visibilityRules = (_b = (_a = component.parameters) == null ? void 0 : _a[CANVAS_VIZ_CONTROL_PARAM]) == null ? void 0 : _b.value;
+      if (component.type === CANVAS_TEST_TYPE) {
+        const test = extractTest({ component });
+        runnable.push({
+          _id: component._id,
+          variantId: findAncestorVariant(node.ancestorsAndSelf),
+          type: "test",
+          result: test
+        });
+      } else if (component.type === CANVAS_PERSONALIZE_TYPE) {
+        const personalize = extractPersonalization({ component });
+        runnable.push({
+          type: "personalization",
+          variantId: findAncestorVariant(node.ancestorsAndSelf),
+          _id: component._id,
+          result: personalize
+        });
+      }
+      if (visibilityRules) {
+        runnable.push({
+          type: "visibility",
+          _id: getRuleId(visibilityRules),
+          variantId: findAncestorVariant(node.ancestorsAndSelf),
+          rules: visibilityRules
+        });
+      }
+    }
+  });
+  return runnable;
+};
+
+// src/components/generateStaticParams.ts
+var createUniformPlaygroundStaticParams = async (options) => {
+  var _a;
+  const { paths } = options;
+  const [firstPath] = paths;
+  if (!firstPath) {
+    throw new Error("At least one path is required.");
+  }
+  const possibleStates = [CANVAS_EDITOR_STATE, CANVAS_DRAFT_STATE];
+  let route = void 0;
+  for (const state of possibleStates) {
+    const routeClient = getRouteClient({
+      state
+    });
+    route = await routeClient.getRoute({
+      path: firstPath,
+      withComponentIDs: true,
+      state: CANVAS_DRAFT_STATE
+    });
+    if (route.type === "composition") {
+      break;
+    }
+  }
+  if ((route == null ? void 0 : route.type) !== "composition") {
+    throw new Error("No route found for the given path.");
+  }
+  const runnables = extractRunnables(route.compositionApiResponse.composition);
+  const choices = generatePossiblePageStates({
+    runnables,
+    path: route.compositionApiResponse.composition._id,
+    keys: void 0,
+    state: route.compositionApiResponse.state
+  });
+  return (_a = choices == null ? void 0 : choices.map((code) => {
+    return {
+      code
+    };
+  })) != null ? _a : [];
+};
+var createUniformStaticParams = async (options) => {
+  var _a;
+  const { paths, rewrite } = options;
+  const codes = [];
+  for (const path of paths) {
+    const pageStates = await processRoutePath({ path, rewrite });
+    if (pageStates) {
+      codes.push(...pageStates);
+    }
+  }
+  return (_a = codes == null ? void 0 : codes.map((code) => {
+    return {
+      code
+    };
+  })) != null ? _a : [];
+};
+async function processRoutePath({
+  path,
+  rewrite
+}) {
+  var _a;
+  const routeClient = getRouteClient({
+    state: CANVAS_PUBLISHED_STATE
+  });
+  const rewrittenPath = await (rewrite == null ? void 0 : rewrite({ path }));
+  const resolvedPath = (_a = rewrittenPath == null ? void 0 : rewrittenPath.path) != null ? _a : path;
+  const route = await routeClient.getRoute({
+    path: resolvedPath,
+    withComponentIDs: true,
+    state: CANVAS_PUBLISHED_STATE
+  });
+  if (route.type !== "composition") {
+    return void 0;
+  }
+  const runnables = extractRunnables(route.compositionApiResponse.composition);
+  const choices = generatePossiblePageStates({
+    runnables,
+    path: resolvedPath,
+    keys: rewrittenPath == null ? void 0 : rewrittenPath.keys,
+    state: CANVAS_PUBLISHED_STATE
+  });
+  return choices;
+}
+var buildDependencyMap = (runnables) => {
+  var _a;
+  const map = /* @__PURE__ */ new Map();
+  for (const runnable of runnables) {
+    const deps = (_a = map.get(runnable.variantId)) != null ? _a : [];
+    deps.push(runnable);
+    map.set(runnable.variantId, deps);
+  }
+  return map;
+};
+var runnablesToGroups = (runnables) => {
+  var _a;
+  const groups = [];
+  for (const runnable of runnables) {
+    if (runnable.type === "visibility") {
+      groups.push({
+        _id: runnable._id,
+        optionType: "visibility",
+        select: 1,
+        options: [true, false]
+      });
+    } else if (runnable.type === "test") {
+      groups.push({
+        _id: runnable._id,
+        optionType: "indexes",
+        select: 1,
+        options: runnable.result.variations.map((variation, index) => ({
+          variantId: variation.componentId,
+          index
+        }))
+      });
+    } else if (runnable.type === "personalization") {
+      const options = [];
+      let index = 0;
+      for (const variation of runnable.result.variations) {
+        options.push({
+          variantId: variation.componentId,
+          index
+        });
+        index++;
+      }
+      groups.push({
+        _id: runnable._id,
+        optionType: "indexes",
+        select: (_a = runnable.result.take) != null ? _a : 1,
+        options
+      });
+    }
+  }
+  return groups;
+};
+var extractSelectedVariantIds = (groups, permutation) => {
+  const variantIds = [];
+  for (let i = 0; i < groups.length; i++) {
+    const group = groups[i];
+    const choices = permutation[i];
+    if (group.optionType === "indexes") {
+      for (const choice of choices) {
+        variantIds.push(choice.variantId);
+      }
+    }
+  }
+  return variantIds;
+};
+var applyChoicesToPageState = (state, groups, permutation) => {
+  var _a;
+  const newState = {
+    ...state,
+    components: { ...state.components },
+    rules: state.rules ? { ...state.rules } : void 0
+  };
+  for (let i = 0; i < permutation.length; i++) {
+    const group = groups[i];
+    const choices = permutation[i];
+    if (group.optionType === "indexes") {
+      newState.components[group._id] = {
+        indexes: choices.map((v) => v.index)
+      };
+    } else if (group.optionType === "visibility" && typeof choices[0] === "boolean") {
+      newState.rules = (_a = newState.rules) != null ? _a : {};
+      newState.rules[group._id] = choices[0];
+    }
+  }
+  return newState;
+};
+var generateStatesRecursively = (dependencyMap, parentVariantId, currentState) => {
+  var _a;
+  const runnables = (_a = dependencyMap.get(parentVariantId)) != null ? _a : [];
+  if (runnables.length === 0) {
+    return [currentState];
+  }
+  const groups = runnablesToGroups(runnables);
+  const permutations = generateAllGroupPermutations(groups);
+  const results = [];
+  for (const permutation of permutations) {
+    const mergedState = applyChoicesToPageState(currentState, groups, permutation);
+    const selectedVariantIds = extractSelectedVariantIds(groups, permutation);
+    let subResults = [mergedState];
+    for (const variantId of selectedVariantIds) {
+      if (dependencyMap.has(variantId)) {
+        subResults = subResults.flatMap(
+          (state) => generateStatesRecursively(dependencyMap, variantId, state)
+        );
+      }
+    }
+    results.push(...subResults);
+  }
+  return results;
+};
+var generatePossiblePageStates = ({
+  runnables,
+  path,
+  keys,
+  state
+}) => {
+  const dependencyMap = buildDependencyMap(runnables);
+  const initialState = {
+    compositionState: state,
+    keys,
+    releaseId: void 0,
+    routePath: path,
+    components: {},
+    defaultConsent: void 0,
+    previewMode: void 0,
+    rules: void 0
+  };
+  const allStates = generateStatesRecursively(dependencyMap, void 0, initialState);
+  return allStates.map((payload) => serializeEvaluationResult({ payload }));
+};
+function permutationsWithoutRepetition(options, k) {
+  if (k === 0) return [[]];
+  if (k > options.length) return [];
+  const results = [];
+  const used = new Array(options.length).fill(false);
+  const current = [];
+  function backtrack() {
+    if (current.length === k) {
+      results.push(current.slice());
+      return;
+    }
+    for (let i = 0; i < options.length; i++) {
+      if (used[i]) continue;
+      used[i] = true;
+      current.push(options[i]);
+      backtrack();
+      current.pop();
+      used[i] = false;
+    }
+  }
+  backtrack();
+  return results;
+}
+function combineAcrossGroups(perGroupSelections) {
+  return perGroupSelections.reduce(
+    (acc, group) => acc.flatMap((config) => group.map((selection) => [...config, selection])),
+    [[]]
+  );
+}
+function generateAllGroupPermutations(groups) {
+  const perGroupSelections = groups.map((g) => permutationsWithoutRepetition(g.options, g.select));
+  return combineAcrossGroups(perGroupSelections);
+}
+
+// src/data/client.ts
+import { getCache, waitUntil } from "@vercel/functions";
+var MANIFEST_CACHE_KEY = "uniform-manifest";
+var DefaultDataClient = class {
+  async getManifest(options) {
+    var _a, _b;
+    const cache2 = options.source === "middleware" && ((_b = (_a = getServerConfig().experimental) == null ? void 0 : _a.middlewareRuntimeCache) != null ? _b : false) ? getCache() : null;
+    if (cache2) {
+      const cachedManifest = await cache2.get(MANIFEST_CACHE_KEY);
+      if (cachedManifest) {
+        return cachedManifest;
+      }
+    }
+    const manifest = await getManifest({
+      cache: {
+        type: "force-cache"
+      }
+    });
+    if (cache2) {
+      waitUntil(
+        (async () => {
+          await cache2.set(MANIFEST_CACHE_KEY, manifest, {
+            tags: generateManifestCacheTags()
+          });
+        })()
+      );
+    }
+    return manifest;
+  }
+  async getRouteFromApi({
+    route,
+    routeClient,
+    enableRuntimeCache,
+    disableSwrCache
+  }) {
+    const newCacheKey = `uniform-route-${route.state}-${route.releaseId}-${route.path}`;
+    const oldCacheKey = `uniform-route-old-${route.state}-${route.releaseId}-${route.path}`;
+    const cache2 = enableRuntimeCache ? getCache() : null;
+    const cacheNewRoute = async (result2) => {
+      if (cache2 && result2.type === "composition") {
+        const tags = generateRouteCacheTags({ path: route.path });
+        await cache2.set(newCacheKey, result2, {
+          tags
+        });
+      }
+    };
+    const cacheOldRoute = async (result2) => {
+      if (cache2 && result2.type === "composition" && !disableSwrCache) {
+        const tags = generateRouteCacheTags({ path: route.path, old: true });
+        await cache2.set(oldCacheKey, result2, {
+          tags
+        });
+      }
+    };
+    if (cache2) {
+      const [cachedRoute, oldCachedRoute] = await Promise.all([
+        cache2.get(newCacheKey),
+        disableSwrCache ? null : cache2.get(oldCacheKey)
+      ]);
+      if (cachedRoute) {
+        return cachedRoute;
+      }
+      if (oldCachedRoute) {
+        waitUntil(
+          (async () => {
+            const result2 = await routeClient.getRoute(route);
+            await cacheNewRoute(result2);
+          })()
+        );
+        return oldCachedRoute;
+      }
+    }
+    const result = await routeClient.getRoute(route);
+    waitUntil(
+      (async () => {
+        await Promise.all([
+          cacheNewRoute(result),
+          disableSwrCache ? Promise.resolve() : cacheOldRoute(result)
+        ]);
+      })()
+    );
+    return result;
+  }
+  async getRoute(options) {
+    if (options.source === "middleware") {
+      return this.getRouteMiddleware(options);
+    }
+    return this.getRoutePageState(options);
+  }
+  async enhanceRoute(_options) {
+  }
+  async getRouteMiddleware(options) {
+    var _a, _b, _c, _d;
+    const routeClient = getRouteClient({
+      searchParams: options.searchParams,
+      draftModeEnabled: options.draftModeEnabled
+    });
+    const config = getServerConfig();
+    const resolvedRoute = await this.getRouteFromApi({
+      source: "middleware",
+      route: options.route,
+      routeClient,
+      enableRuntimeCache: options.route.state === CANVAS_PUBLISHED_STATE && ((_b = (_a = config.experimental) == null ? void 0 : _a.middlewareRuntimeCache) != null ? _b : false),
+      disableSwrCache: (_d = (_c = config.experimental) == null ? void 0 : _c.disableSwrMiddlewareCache) != null ? _d : false
+    });
+    if (resolvedRoute.type === "composition") {
+      await this.enhanceRoute({
+        source: "middleware",
+        parameters: options.route,
+        route: resolvedRoute,
+        routeClient,
+        keys: void 0
+      });
+    }
+    return {
+      route: resolvedRoute
+    };
+  }
+  async getRoutePageState(options) {
+    var _a;
+    const routeClient = getRouteClient({
+      cache: options.pageState.compositionState === CANVAS_PUBLISHED_STATE ? (_a = getServerConfig().canvasCache) != null ? _a : {
+        type: "force-cache"
+      } : {
+        type: "no-cache"
+      }
+    });
+    const originalRoute = {
+      path: options.pageState.routePath,
+      state: options.pageState.compositionState,
+      withComponentIDs: true,
+      releaseId: options.pageState.releaseId
+    };
+    const resolvedRoute = await this.getRouteFromApi({
+      source: "pageState",
+      route: originalRoute,
+      routeClient,
+      enableRuntimeCache: false,
+      disableSwrCache: false
+    });
+    if (resolvedRoute.type === "composition") {
+      await this.enhanceRoute({
+        source: "pageState",
+        parameters: originalRoute,
+        route: resolvedRoute,
+        routeClient,
+        keys: options.pageState.keys
+      });
+    }
+    return {
+      route: resolvedRoute
+    };
+  }
+};
+var expireMiddlewareCacheTag = async (tag) => {
+  var _a;
+  const cache2 = ((_a = getServerConfig().experimental) == null ? void 0 : _a.middlewareRuntimeCache) ? getCache() : null;
+  if (cache2) {
+    await cache2.expireTag(tag);
+  } else {
+    console.warn("Middleware cache is not enabled, cannot clear cache tag", tag);
+  }
+};
+
+// src/data/precomputeComposition.ts
+import {
+  extractPersonalizationName as extractPersonalizationName2,
+  extractTestName as extractTestName2,
+  resolveComponentFromPageState as resolveComponentFromPageState2
+} from "@uniformdev/next-app-router-shared";
+var shouldEvaluateTest = (test, evaluateTests) => {
+  return typeof evaluateTests === "function" ? evaluateTests({
+    name: extractTestName2({ component: test }),
+    component: test
+  }) : evaluateTests;
+};
+var shouldEvaluatePersonalization = (personalization, evaluatePersonalizations) => {
+  const result = typeof evaluatePersonalizations === "function" ? evaluatePersonalizations({
+    name: extractPersonalizationName2({ component: personalization }),
+    component: personalization
+  }) : evaluatePersonalizations;
+  return result;
+};
+var precomputeComposition = ({
+  pageState,
+  route,
+  evaluatePersonalizations = true,
+  evaluateTests = true
+}) => {
+  if (!route) {
+    return Promise.resolve();
+  }
+  walkNodeTree(route.compositionApiResponse.composition, (node) => {
+    var _a, _b;
+    if (node.type === "component") {
+      const component = node.node;
+      const pageStateComponent = resolveComponentFromPageState2({
+        pageState,
+        componentId: component._id
+      });
+      if (component.type === CANVAS_TEST_TYPE && shouldEvaluateTest(component, evaluateTests)) {
+        const [testIndex] = (pageStateComponent == null ? void 0 : pageStateComponent.indexes) || [];
+        if (typeof testIndex === "undefined") {
+          node.actions.remove();
+          return;
+        }
+        const slotComponents = ((_a = component.slots) == null ? void 0 : _a[CANVAS_TEST_SLOT]) || [];
+        const visibileComponent = slotComponents[testIndex];
+        if (typeof visibileComponent !== "undefined") {
+          node.actions.replace(visibileComponent);
+        } else {
+          node.actions.remove();
+        }
+      } else if (component.type === CANVAS_PERSONALIZE_TYPE && shouldEvaluatePersonalization(component, evaluatePersonalizations)) {
+        const personalizeIndexes = (pageStateComponent == null ? void 0 : pageStateComponent.indexes) || [];
+        if (!(personalizeIndexes == null ? void 0 : personalizeIndexes.length)) {
+          node.actions.remove();
+          return;
+        }
+        const slotComponents = ((_b = component.slots) == null ? void 0 : _b[CANVAS_PERSONALIZE_SLOT]) || [];
+        const visibileComponents = personalizeIndexes.map((index) => slotComponents[index]).filter(Boolean);
+        if (visibileComponents.length) {
+          const [first, ...rest] = visibileComponents;
+          node.actions.replace(first);
+          for (const component2 of rest) {
+            node.actions.insertAfter(component2);
+          }
+        } else {
+          node.actions.remove();
+        }
+      }
+    }
+  });
+  return Promise.resolve();
+};
+
+// src/data/resolveRouteFromCode.ts
+import { deserializeEvaluationResult as deserializeEvaluationResult3 } from "@uniformdev/next-app-router-shared";
+var resolveRouteFromCode = async ({
+  params,
+  dataClient: providedDataClient
+}) => {
+  const { code } = await params;
+  const pageState = deserializeEvaluationResult3({ input: code });
+  const dataClient = providedDataClient != null ? providedDataClient : new DefaultDataClient();
+  const { route } = await dataClient.getRoute({
+    source: "pageState",
+    pageState
+  });
+  return {
+    pageState,
+    // suppress the route if it's not a composition
+    route: (route == null ? void 0 : route.type) === "composition" ? route : void 0,
+    // the code that was used to resolve the route
+    code
+  };
+};
+
+// src/data/routes.ts
+var findRouteMatch = (routes, path) => {
+  const pieces = path.split("/").filter(Boolean);
+  for (const route of routes) {
+    const patternPieces = route.pattern.split("/").filter(Boolean);
+    if (patternPieces.length !== pieces.length) {
+      continue;
+    }
+    let match = true;
+    const params = {};
+    for (let i = 0; i < patternPieces.length; i++) {
+      const patternPiece = patternPieces[i];
+      const piece = pieces[i];
+      if (patternPiece.startsWith(":")) {
+        const paramName = patternPiece.slice(1);
+        params[paramName] = piece;
+      } else if (patternPiece !== piece) {
+        match = false;
+        break;
+      }
+    }
+    if (match) {
+      return {
+        route,
+        params
+      };
+    }
+  }
+  return void 0;
+};
+
+// src/cache/helpers.ts
+import { cache } from "react";
+var serverContext = (defaultValue) => {
+  const getRef = cache(() => ({ current: defaultValue }));
+  const getValue = () => getRef().current;
+  const setValue = (value) => {
+    getRef().current = value;
+  };
+  return [getValue, setValue];
+};
+
+// src/cache/composition.ts
+var createCompositionCache = () => {
+  const [getCompositionInternal, setCompositionInternal] = serverContext({});
+  const getUniformComposition = ({ id }) => {
+    const compositions = getCompositionInternal();
+    if (!compositions) {
+      return null;
+    }
+    return compositions[id];
+  };
+  const setUniformComposition = (composition) => {
+    const compositions = getCompositionInternal();
+    compositions[composition._id] = composition;
+    setCompositionInternal(compositions);
+  };
+  const getUniformComponent = ({ compositionId, componentId }) => {
+    const composition = getUniformComposition({ id: compositionId });
+    if (!composition) {
+      return null;
+    }
+    let component;
+    walkNodeTree(composition, ({ node, actions }) => {
+      if (node._id === componentId) {
+        component = node;
+        actions.stopProcessingDescendants();
+      }
+    });
+    return component != null ? component : null;
+  };
+  return {
+    getUniformComposition,
+    setUniformComposition,
+    getUniformComponent
+  };
+};
+export {
+  DefaultDataClient,
+  UniformComposition,
+  UniformPlayground,
+  createCompositionCache,
+  createUniformPlaygroundStaticParams,
+  createUniformStaticParams,
+  expireMiddlewareCacheTag,
+  findRouteMatch,
+  getCanvasClient,
+  getManifest,
+  getManifestClient,
+  getProjectMapClient,
+  getRouteClient,
+  precomputeComposition,
+  resolvePlaygroundRoute,
+  resolveRouteFromCode,
+  serverContext
+};