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

package/dist/handler.js

@@ -0,0 +1,2664 @@
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), 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"(exports2, module2) {
+    "use strict";
+    var Node = class {
+      /// value;
+      /// next;
+      constructor(value) {
+        this.value = value;
+        this.next = void 0;
+      }
+    };
+    var Queue = class {
+      // TODO: Use private class fields when targeting Node.js 12.
+      // #_head;
+      // #_tail;
+      // #_size;
+      constructor() {
+        this.clear();
+      }
+      enqueue(value) {
+        const node = new Node(value);
+        if (this._head) {
+          this._tail.next = node;
+          this._tail = node;
+        } else {
+          this._head = node;
+          this._tail = node;
+        }
+        this._size++;
+      }
+      dequeue() {
+        const current = this._head;
+        if (!current) {
+          return;
+        }
+        this._head = this._head.next;
+        this._size--;
+        return current.value;
+      }
+      clear() {
+        this._head = void 0;
+        this._tail = void 0;
+        this._size = 0;
+      }
+      get size() {
+        return this._size;
+      }
+      *[Symbol.iterator]() {
+        let current = this._head;
+        while (current) {
+          yield current.value;
+          current = current.next;
+        }
+      }
+    };
+    module2.exports = Queue;
+  }
+});
+
+// ../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js
+var require_p_limit = __commonJS({
+  "../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js"(exports2, module2) {
+    "use strict";
+    var Queue = require_yocto_queue();
+    var pLimit2 = (concurrency) => {
+      if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+        throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+      }
+      const queue = new Queue();
+      let activeCount = 0;
+      const next = () => {
+        activeCount--;
+        if (queue.size > 0) {
+          queue.dequeue()();
+        }
+      };
+      const run = async (fn, resolve, ...args) => {
+        activeCount++;
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+          await result;
+        } catch (e) {
+        }
+        next();
+      };
+      const enqueue = (fn, resolve, ...args) => {
+        queue.enqueue(run.bind(null, fn, resolve, ...args));
+        (async () => {
+          await Promise.resolve();
+          if (activeCount < concurrency && queue.size > 0) {
+            queue.dequeue()();
+          }
+        })();
+      };
+      const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, ...args);
+      });
+      Object.defineProperties(generator, {
+        activeCount: {
+          get: () => activeCount
+        },
+        pendingCount: {
+          get: () => queue.size
+        },
+        clearQueue: {
+          value: () => {
+            queue.clear();
+          }
+        }
+      });
+      return generator;
+    };
+    module2.exports = pLimit2;
+  }
+});
+
+// src/handler.ts
+var handler_exports = {};
+__export(handler_exports, {
+  createPreviewGETRouteHandler: () => createPreviewGETRouteHandler,
+  createPreviewOPTIONSRouteHandler: () => createPreviewOPTIONSRouteHandler,
+  createPreviewPOSTRouteHandler: () => createPreviewPOSTRouteHandler
+});
+module.exports = __toCommonJS(handler_exports);
+
+// ../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 _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"(exports2, module2) {
+    "use strict";
+    var Node = class {
+      /// value;
+      /// next;
+      constructor(value) {
+        this.value = value;
+        this.next = void 0;
+      }
+    };
+    var Queue = class {
+      // TODO: Use private class fields when targeting Node.js 12.
+      // #_head;
+      // #_tail;
+      // #_size;
+      constructor() {
+        this.clear();
+      }
+      enqueue(value) {
+        const node = new Node(value);
+        if (this._head) {
+          this._tail.next = node;
+          this._tail = node;
+        } else {
+          this._head = node;
+          this._tail = node;
+        }
+        this._size++;
+      }
+      dequeue() {
+        const current = this._head;
+        if (!current) {
+          return;
+        }
+        this._head = this._head.next;
+        this._size--;
+        return current.value;
+      }
+      clear() {
+        this._head = void 0;
+        this._tail = void 0;
+        this._size = 0;
+      }
+      get size() {
+        return this._size;
+      }
+      *[Symbol.iterator]() {
+        let current = this._head;
+        while (current) {
+          yield current.value;
+          current = current.next;
+        }
+      }
+    };
+    module2.exports = Queue;
+  }
+});
+var require_p_limit2 = __commonJS2({
+  "../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js"(exports2, module2) {
+    "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;
+    };
+    module2.exports = pLimit2;
+  }
+});
+var require_retry_operation = __commonJS2({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports2, module2) {
+    "use strict";
+    function RetryOperation(timeouts, options) {
+      if (typeof options === "boolean") {
+        options = { forever: options };
+      }
+      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+      this._timeouts = timeouts;
+      this._options = options || {};
+      this._maxRetryTime = options && options.maxRetryTime || Infinity;
+      this._fn = null;
+      this._errors = [];
+      this._attempts = 1;
+      this._operationTimeout = null;
+      this._operationTimeoutCb = null;
+      this._timeout = null;
+      this._operationStart = null;
+      this._timer = null;
+      if (this._options.forever) {
+        this._cachedTimeouts = this._timeouts.slice(0);
+      }
+    }
+    module2.exports = RetryOperation;
+    RetryOperation.prototype.reset = function() {
+      this._attempts = 1;
+      this._timeouts = this._originalTimeouts.slice(0);
+    };
+    RetryOperation.prototype.stop = function() {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (this._timer) {
+        clearTimeout(this._timer);
+      }
+      this._timeouts = [];
+      this._cachedTimeouts = null;
+    };
+    RetryOperation.prototype.retry = function(err) {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (!err) {
+        return false;
+      }
+      var currentTime = (/* @__PURE__ */ new Date()).getTime();
+      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.push(err);
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+      }
+      this._errors.push(err);
+      var timeout = this._timeouts.shift();
+      if (timeout === void 0) {
+        if (this._cachedTimeouts) {
+          this._errors.splice(0, this._errors.length - 1);
+          timeout = this._cachedTimeouts.slice(-1);
+        } else {
+          return false;
+        }
+      }
+      var self = this;
+      this._timer = setTimeout(function() {
+        self._attempts++;
+        if (self._operationTimeoutCb) {
+          self._timeout = setTimeout(function() {
+            self._operationTimeoutCb(self._attempts);
+          }, self._operationTimeout);
+          if (self._options.unref) {
+            self._timeout.unref();
+          }
+        }
+        self._fn(self._attempts);
+      }, timeout);
+      if (this._options.unref) {
+        this._timer.unref();
+      }
+      return true;
+    };
+    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+      this._fn = fn;
+      if (timeoutOps) {
+        if (timeoutOps.timeout) {
+          this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+          this._operationTimeoutCb = timeoutOps.cb;
+        }
+      }
+      var self = this;
+      if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function() {
+          self._operationTimeoutCb();
+        }, self._operationTimeout);
+      }
+      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+      this._fn(this._attempts);
+    };
+    RetryOperation.prototype.try = function(fn) {
+      console.log("Using RetryOperation.try() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = function(fn) {
+      console.log("Using RetryOperation.start() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = RetryOperation.prototype.try;
+    RetryOperation.prototype.errors = function() {
+      return this._errors;
+    };
+    RetryOperation.prototype.attempts = function() {
+      return this._attempts;
+    };
+    RetryOperation.prototype.mainError = function() {
+      if (this._errors.length === 0) {
+        return null;
+      }
+      var counts = {};
+      var mainError = null;
+      var mainErrorCount = 0;
+      for (var i = 0; i < this._errors.length; i++) {
+        var error = this._errors[i];
+        var message = error.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+          mainError = error;
+          mainErrorCount = count;
+        }
+      }
+      return mainError;
+    };
+  }
+});
+var require_retry = __commonJS2({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js"(exports2) {
+    "use strict";
+    var RetryOperation = require_retry_operation();
+    exports2.operation = function(options) {
+      var timeouts = exports2.timeouts(options);
+      return new RetryOperation(timeouts, {
+        forever: options && (options.forever || options.retries === Infinity),
+        unref: options && options.unref,
+        maxRetryTime: options && options.maxRetryTime
+      });
+    };
+    exports2.timeouts = function(options) {
+      if (options instanceof Array) {
+        return [].concat(options);
+      }
+      var opts = {
+        retries: 10,
+        factor: 2,
+        minTimeout: 1 * 1e3,
+        maxTimeout: Infinity,
+        randomize: false
+      };
+      for (var key in options) {
+        opts[key] = options[key];
+      }
+      if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+      }
+      var timeouts = [];
+      for (var i = 0; i < opts.retries; i++) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      if (options && options.forever && !timeouts.length) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      timeouts.sort(function(a, b) {
+        return a - b;
+      });
+      return timeouts;
+    };
+    exports2.createTimeout = function(attempt, opts) {
+      var random = opts.randomize ? Math.random() + 1 : 1;
+      var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+      timeout = Math.min(timeout, opts.maxTimeout);
+      return timeout;
+    };
+    exports2.wrap = function(obj, options, methods) {
+      if (options instanceof Array) {
+        methods = options;
+        options = null;
+      }
+      if (!methods) {
+        methods = [];
+        for (var key in obj) {
+          if (typeof obj[key] === "function") {
+            methods.push(key);
+          }
+        }
+      }
+      for (var i = 0; i < methods.length; i++) {
+        var method = methods[i];
+        var original = obj[method];
+        obj[method] = function retryWrapper(original2) {
+          var op = exports2.operation(options);
+          var args = Array.prototype.slice.call(arguments, 1);
+          var callback = args.pop();
+          args.push(function(err) {
+            if (op.retry(err)) {
+              return;
+            }
+            if (err) {
+              arguments[0] = op.mainError();
+            }
+            callback.apply(this, arguments);
+          });
+          op.attempt(function() {
+            original2.apply(obj, args);
+          });
+        }.bind(obj, original);
+        obj[method].options = options;
+      }
+    };
+  }
+});
+var require_retry2 = __commonJS2({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js"(exports2, module2) {
+    "use strict";
+    module2.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");
+var CANVAS_DRAFT_STATE = 0;
+var CANVAS_EDITOR_STATE = 63;
+var SECRET_QUERY_STRING_PARAM = "secret";
+var IN_CONTEXT_EDITOR_QUERY_STRING_PARAM = "is_incontext_editing_mode";
+var IN_CONTEXT_EDITOR_PLAYGROUND_QUERY_STRING_PARAM = "is_incontext_editing_playground";
+var EDGE_MAX_CACHE_TTL = 24 * 60 * 60;
+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 createVariableReference(variableName) {
+  return `\${${variableName.replace(/([${}])/g, "\\$1")}}`;
+}
+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 isAllowedReferrer = (referrer) => {
+  return Boolean(referrer == null ? void 0 : referrer.match(/(^https:\/\/|\.)(uniform.app|uniform.wtf|localhost:\d{4})\//));
+};
+
+// src/handler/createPreviewGETRouteHandler.ts
+var import_headers = require("next/headers");
+var import_navigation = require("next/navigation");
+var import_server = require("next/server");
+
+// src/config/helpers.ts
+var import_uniform_server = __toESM(require("uniform.server.config"));
+var getServerConfig = () => {
+  return import_uniform_server.default;
+};
+
+// src/handler/createPreviewGETRouteHandler.ts
+var BASE_URL_EXAMPLE = "https://example.com";
+var getQueryParam = (req, paramName) => {
+  const value = req.nextUrl.searchParams.get(paramName);
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  return Array.isArray(value) ? value[0] : value;
+};
+var contextualEditingQueryParams = [
+  IN_CONTEXT_EDITOR_QUERY_STRING_PARAM,
+  IN_CONTEXT_EDITOR_PLAYGROUND_QUERY_STRING_PARAM
+];
+var createPreviewGETRouteHandler = (options) => {
+  return async (request) => {
+    const isConfigCheck = getQueryParam(request, "is_config_check") === "true";
+    const { playgroundPath } = getServerConfig();
+    if (isConfigCheck) {
+      return Response.json(
+        {
+          hasPlayground: Boolean(playgroundPath),
+          isUsingCustomFullPathResolver: false
+        },
+        {
+          headers: {
+            "Access-Control-Allow-Origin": process.env.UNIFORM_CLI_BASE_URL || "https://uniform.app"
+          }
+        }
+      );
+    }
+    if (request.headers.get("sec-fetch-mode") === "no-cors") {
+      return new Response(null, { status: 204 });
+    }
+    if (!process.env.UNIFORM_PREVIEW_SECRET) {
+      return new Response("No preview secret is configured", { status: 401 });
+    }
+    const { searchParams } = new URL(request.url);
+    const id = getQueryParam(request, compositionQueryParam.id);
+    const path = getQueryParam(request, compositionQueryParam.path);
+    const isPlayground = searchParams.get(IN_CONTEXT_EDITOR_PLAYGROUND_QUERY_STRING_PARAM) === "true" || id && !path;
+    const locale = getQueryParam(request, compositionQueryParam.locale);
+    let pathToRedirectTo;
+    if (isPlayground) {
+      if (!playgroundPath) {
+        return new Response("No playground path is configured", { status: 401 });
+      }
+      pathToRedirectTo = playgroundPath;
+      if (options == null ? void 0 : options.processPlaygroundPath) {
+        const processedPath = options.processPlaygroundPath({ playgroundPath, locale });
+        if (processedPath) {
+          pathToRedirectTo = processedPath;
+        }
+      }
+    }
+    const slug = getQueryParam(request, compositionQueryParam.slug);
+    const disable = getQueryParam(request, "disable");
+    const secret = getQueryParam(request, SECRET_QUERY_STRING_PARAM);
+    const referer = request.headers.get("referer");
+    const isUniformContextualEditing = getQueryParam(request, IN_CONTEXT_EDITOR_QUERY_STRING_PARAM) === "true" && isAllowedReferrer(referer || void 0);
+    const releaseId = getQueryParam(request, "releaseId");
+    if (typeof pathToRedirectTo === "undefined") {
+      const resolveFullPath = (options == null ? void 0 : options.resolveFullPath) || resolveFullPathDefault;
+      pathToRedirectTo = resolveFullPath({ id, slug, path, locale });
+    }
+    validateLocalRedirectUrl(pathToRedirectTo);
+    if (!pathToRedirectTo) {
+      return new Response("Could not resolve the full path of the preview page", { status: 400 });
+    }
+    if (disable) {
+      (await (0, import_headers.draftMode)()).disable();
+      (0, import_navigation.redirect)(pathToRedirectTo);
+      return;
+    }
+    if (secret !== process.env.UNIFORM_PREVIEW_SECRET) {
+      return new Response("Invalid preview secret", { status: 401 });
+    }
+    const draft = await (0, import_headers.draftMode)();
+    draft.enable();
+    const cookieStore = await (0, import_headers.cookies)();
+    const draftCookie = cookieStore.get("__prerender_bypass");
+    if (draftCookie == null ? void 0 : draftCookie.value) {
+      cookieStore.set({
+        name: "__prerender_bypass",
+        value: draftCookie.value,
+        httpOnly: true,
+        path: "/",
+        secure: true,
+        sameSite: "none"
+        // Allow cookie in cross-origin iframes
+      });
+    }
+    const redirectionUrl = new URL(pathToRedirectTo, BASE_URL_EXAMPLE);
+    assignRequestQueryToSearchParams(redirectionUrl.searchParams, searchParams);
+    if (isPlayground) {
+      redirectionUrl.searchParams.set("id", searchParams.get("id") || "");
+      if (locale) {
+        redirectionUrl.searchParams.set("locale", locale);
+      }
+      if (releaseId) {
+        redirectionUrl.searchParams.set("releaseId", releaseId);
+      }
+    }
+    if (releaseId) {
+      redirectionUrl.searchParams.set("releaseId", releaseId);
+    }
+    if (!isUniformContextualEditing) {
+      contextualEditingQueryParams.forEach((param) => {
+        redirectionUrl.searchParams.delete(param);
+      });
+    }
+    const fullPathToRedirectTo = redirectionUrl.href.replace(BASE_URL_EXAMPLE, "");
+    return import_server.NextResponse.redirect(new URL(fullPathToRedirectTo, request.url), {
+      status: 307
+    });
+  };
+};
+function validateLocalRedirectUrl(pathToRedirectTo) {
+  if (pathToRedirectTo == null ? void 0 : pathToRedirectTo.match(/^[a-z]+:\/\//g)) {
+    throw new Error("Tried to redirect to absolute URL with protocol. Disallowing open redirect.");
+  }
+}
+var resolveFullPathDefault = ({ slug, path }) => {
+  return path || slug;
+};
+var compositionQueryParam = {
+  id: "id",
+  slug: "slug",
+  path: "path",
+  locale: "locale"
+};
+var assignRequestQueryToSearchParams = (searchParams, query) => {
+  const compositionQueryParamNames = Object.values(compositionQueryParam);
+  for (const [name, value] of query.entries()) {
+    if (name === SECRET_QUERY_STRING_PARAM) {
+      continue;
+    }
+    if (compositionQueryParamNames.includes(name)) {
+      continue;
+    }
+    if (typeof value === "undefined") {
+      continue;
+    }
+    searchParams.append(name, value);
+  }
+};
+
+// src/handler/createPreviewOPTIONSRouteHandler.ts
+var createPreviewOPTIONSRouteHandler = () => {
+  return async () => {
+    return new Response(null, {
+      headers: {
+        "Access-Control-Allow-Origin": process.env.UNIFORM_CLI_BASE_URL || "https://uniform.app",
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+        "Access-Control-Allow-Headers": "*"
+      }
+    });
+  };
+};
+
+// src/handler/createPreviewPOSTRouteHandler.ts
+var import_functions = require("@vercel/functions");
+var import_cache4 = require("next/cache");
+
+// src/handler/helpers.ts
+var import_svix = require("svix");
+
+// src/clients/canvas.ts
+var import_server_only = require("server-only");
+
+// 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/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 resolveCanvasCache = (options) => {
+  return resolveCache({
+    options,
+    defaultCache: getServerConfig().canvasCache
+  });
+};
+var resolveProjectMapCache = (options) => {
+  return resolveCache({
+    options,
+    defaultCache: getServerConfig().projectMapCache
+  });
+};
+var resolveCache = ({
+  options,
+  defaultCache
+}) => {
+  let cache = defaultCache;
+  if (options) {
+    if (isSpecificCacheMode(options)) {
+      cache = options.cache;
+    } else if (isStateCacheMode(options)) {
+      if (options.state === CANVAS_DRAFT_STATE || options.state === CANVAS_EDITOR_STATE) {
+        cache = {
+          type: "no-cache",
+          bypassCache: true
+        };
+      }
+    } else if (isDetectCacheMode(options)) {
+      const { disabled } = shouldCacheBeDisabled(options);
+      if (disabled) {
+        cache = {
+          type: "no-cache",
+          bypassCache: true
+        };
+      }
+    }
+  }
+  return cache || {
+    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 cache = void 0;
+  let revalidate = void 0;
+  if (mode.type === "revalidate") {
+    cache = void 0;
+    revalidate = mode.interval;
+  } else {
+    cache = mode.type;
+  }
+  return {
+    cache,
+    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 cache = resolveCanvasCache(options);
+  return new CanvasClient({
+    projectId: env.getProjectId(),
+    apiHost: env.getApiHost(),
+    apiKey: env.getApiKey(),
+    edgeApiHost: env.getEdgeApiHost(),
+    disableSWR: typeof cache.disableSWR !== "undefined" ? cache.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(cache);
+      return fetch(req, {
+        ...init,
+        cache: fetchCache,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "x-bypass-cache": typeof cache.bypassCache !== "undefined" ? cache.bypassCache.toString() : "false"
+        },
+        next: {
+          revalidate,
+          tags: tags.length ? tags : void 0
+        }
+      });
+    }
+  });
+};
+
+// src/clients/projectMap.ts
+var import_server_only2 = require("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 cache = 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(cache);
+      return fetch(req, {
+        ...init,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "x-bypass-cache": typeof cache.bypassCache !== "undefined" ? cache.bypassCache.toString() : "false"
+        },
+        cache: fetchCache,
+        next: {
+          revalidate
+        }
+      });
+    }
+  });
+  return manifestClient;
+};
+
+// src/handler/helpers.ts
+var isSvixMessage = async (request) => {
+  const requiredHeaders = ["svix-id", "svix-timestamp", "svix-signature"];
+  const hasAllRequiredHeaders = requiredHeaders.every((header) => request.headers.has(header));
+  if (!hasAllRequiredHeaders) {
+    return {
+      looksLikeMessage: false,
+      validation: false
+    };
+  }
+  if (typeof process.env.UNIFORM_WEBHOOK_SECRET !== "undefined") {
+    const payload = await request.clone().text();
+    const headers = Object.fromEntries(request.headers.entries());
+    const wh = new import_svix.Webhook(process.env.UNIFORM_WEBHOOK_SECRET);
+    try {
+      wh.verify(payload, headers);
+    } catch (e) {
+      return {
+        looksLikeMessage: true,
+        validation: false
+      };
+    }
+  }
+  return {
+    looksLikeMessage: true,
+    validation: true
+  };
+};
+var processCompositionChange = async (compositionId) => {
+  const projectMapClient = getProjectMapClient({
+    cache: {
+      type: "no-cache"
+    }
+  });
+  const [{ nodes }, composition] = await Promise.all([
+    projectMapClient.getNodes({
+      compositionId
+    }),
+    getComposition({ compositionId })
+  ]);
+  const tags = [];
+  const paths = [];
+  if (composition == null ? void 0 : composition.pattern) {
+    tags.push("route");
+  }
+  if (nodes) {
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      const result = buildProjectMapNodePaths(node.path);
+      tags.push(...result.tags);
+      if (result.paths) {
+        paths.push(...result.paths);
+      }
+    }
+  }
+  tags.push(buildCompositionTag(compositionId));
+  return {
+    tags,
+    paths
+  };
+};
+var getComposition = async ({ compositionId }) => {
+  const canvasClient = getCanvasClient({
+    cache: {
+      type: "no-cache"
+    }
+  });
+  try {
+    const composition = await canvasClient.getCompositionById({
+      compositionId
+    });
+    return composition;
+  } catch (err) {
+    if (err instanceof ApiClientError && err.statusCode === 404) {
+      return null;
+    }
+    throw err;
+  }
+};
+var buildProjectMapNodePaths = (path) => {
+  const tags = [];
+  const paths = [];
+  const isDynamic = path.includes(":");
+  if (!isDynamic) {
+    tags.push(buildPathTag(path));
+    paths.push(path);
+  } else {
+    const pieces = path.split("/");
+    const invalidatePieces = [];
+    for (let j = 0; j < pieces.length; j++) {
+      const piece = pieces[j];
+      if (piece.startsWith(":")) {
+        break;
+      }
+      invalidatePieces.push(piece);
+    }
+    const toInvalidate = invalidatePieces.join("/");
+    tags.push(buildPathTag(toInvalidate));
+    paths.push(toInvalidate);
+  }
+  return {
+    tags,
+    paths
+  };
+};
+var getPathName = (url) => {
+  try {
+    const { pathname } = new URL(url);
+    return pathname;
+  } catch (e) {
+    return url;
+  }
+};
+var processRedirectChange = async (sourceUrl) => {
+  const tags = [];
+  const pathName = getPathName(sourceUrl);
+  tags.push(buildPathTag(pathName));
+  return {
+    tags,
+    paths: [pathName]
+  };
+};
+
+// src/handler/messages/handleCompositionChanged.ts
+var import_webhooks = require("@uniformdev/webhooks");
+var handleCompositionChanged = async (body) => {
+  const parsed = import_webhooks.CompositionChangedDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return processCompositionChange(parsed.data.id);
+};
+
+// src/handler/messages/handleCompositionDeleted.ts
+var import_webhooks2 = require("@uniformdev/webhooks");
+var handleCompositionDeleted = async (body) => {
+  const parsed = import_webhooks2.CompositionDeletedDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return processCompositionChange(parsed.data.id);
+};
+
+// src/handler/messages/handleCompositionPublished.ts
+var import_webhooks3 = require("@uniformdev/webhooks");
+var handleCompositionPublished = async (body) => {
+  const parsed = import_webhooks3.CompositionPublishedDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return processCompositionChange(parsed.data.id);
+};
+
+// src/handler/messages/handleManifestPublished.ts
+var import_webhooks4 = require("@uniformdev/webhooks");
+var handleManifestPublished = async (body) => {
+  const parsed = import_webhooks4.ManifestPublishedDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return {
+    tags: ["manifest"]
+  };
+};
+
+// src/handler/messages/handleProjectMapNodeDelete.ts
+var import_webhooks5 = require("@uniformdev/webhooks");
+var handleProjectMapNodeDelete = async (body) => {
+  const parsed = import_webhooks5.ProjectMapNodeDeleteDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const tags = [];
+  const paths = [];
+  const result = buildProjectMapNodePaths(parsed.data.path);
+  tags.push(...result.tags);
+  if (result.paths) {
+    paths.push(...result.paths);
+  }
+  return {
+    tags,
+    paths
+  };
+};
+
+// src/handler/messages/handleProjectMapNodeInsert.ts
+var import_webhooks6 = require("@uniformdev/webhooks");
+var handleProjectMapNodeInsert = async (body) => {
+  const parsed = import_webhooks6.ProjectMapNodeInsertDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const tags = [];
+  const paths = [];
+  const result = buildProjectMapNodePaths(parsed.data.path);
+  tags.push(...result.tags);
+  if (result.paths) {
+    paths.push(...result.paths);
+  }
+  return {
+    tags,
+    paths
+  };
+};
+
+// src/handler/messages/handleProjectMapNodeUpdate.ts
+var import_webhooks7 = require("@uniformdev/webhooks");
+var handleProjectMapNodeUpdate = async (body) => {
+  const parsed = import_webhooks7.ProjectMapNodeUpdateDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const tags = [];
+  const paths = [];
+  const currentResult = buildProjectMapNodePaths(parsed.data.path);
+  tags.push(...currentResult.tags);
+  if (currentResult.paths) {
+    paths.push(...currentResult.paths);
+  }
+  const previousResult = buildProjectMapNodePaths(parsed.data.previous_path);
+  tags.push(...previousResult.tags);
+  if (previousResult.paths) {
+    paths.push(...previousResult.paths);
+  }
+  return {
+    tags,
+    paths
+  };
+};
+
+// src/handler/messages/handleRedirectDelete.ts
+var import_webhooks8 = require("@uniformdev/webhooks");
+var handleRedirectDelete = async (body) => {
+  const parsed = import_webhooks8.RedirectDeleteDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return processRedirectChange(parsed.data.source_url);
+};
+
+// src/handler/messages/handleRedirectInsert.ts
+var import_webhooks9 = require("@uniformdev/webhooks");
+var handleRedirectInsert = async (body) => {
+  const parsed = import_webhooks9.RedirectInsertDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return processRedirectChange(parsed.data.source_url);
+};
+
+// src/handler/messages/handleRedirectUpdate.ts
+var import_webhooks10 = require("@uniformdev/webhooks");
+var handleRedirectUpdate = async (body) => {
+  const parsed = import_webhooks10.RedirectUpdateDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return processRedirectChange(parsed.data.source_url);
+};
+
+// src/handler/createPreviewPOSTRouteHandler.ts
+var createPreviewPOSTRouteHandler = () => {
+  return async (request) => {
+    let previewSecretPassed = false;
+    if (process.env.UNIFORM_PREVIEW_SECRET) {
+      const secretValue = request.nextUrl.searchParams.get(SECRET_QUERY_STRING_PARAM);
+      if (secretValue !== process.env.UNIFORM_PREVIEW_SECRET) {
+        console.warn(
+          "The preview secret passed in the query string does not match the UNIFORM_PREVIEW_SECRET env var."
+        );
+      } else {
+        previewSecretPassed = true;
+      }
+    } else {
+      if (!process.env.UNIFORM_WEBHOOK_SECRET) {
+        console.warn("Both UNIFORM_PREVIEW_SECRET and UNIFORM_WEBHOOK_SECRET are not set.");
+      }
+      previewSecretPassed = true;
+    }
+    if (!previewSecretPassed) {
+      return new Response("The request could not be validated.", {
+        status: 401
+      });
+    }
+    const { looksLikeMessage, validation } = await isSvixMessage(request);
+    if (looksLikeMessage) {
+      if (!validation) {
+        return new Response("This looks like a webhook request but the validation failed.", { status: 401 });
+      }
+      return handleSvixMessage(request);
+    }
+    return new Response("This is not a webhook request.", { status: 401 });
+  };
+};
+var handleSvixMessage = async (request) => {
+  var _a;
+  const handlers = [
+    handleProjectMapNodeUpdate,
+    handleProjectMapNodeInsert,
+    handleProjectMapNodeDelete,
+    handleCompositionDeleted,
+    handleCompositionChanged,
+    handleCompositionPublished,
+    handleRedirectInsert,
+    handleRedirectUpdate,
+    handleRedirectDelete,
+    handleManifestPublished
+  ];
+  let tags = void 0;
+  let paths = void 0;
+  let jsonBody;
+  try {
+    jsonBody = await request.json();
+  } catch (err) {
+    console.error("Error parsing the request body as JSON.", err);
+    return new Response("Error parsing the request body as JSON.", {
+      status: 400
+    });
+  }
+  for (let i = 0; i < handlers.length; i++) {
+    const handler = handlers[i];
+    const result = await handler(jsonBody);
+    if (result) {
+      tags = result.tags;
+      paths = result.paths;
+      break;
+    }
+  }
+  if (tags == null ? void 0 : tags.length) {
+    const cache = ((_a = getServerConfig().experimental) == null ? void 0 : _a.middlewareRuntimeCache) ? (0, import_functions.getCache)() : void 0;
+    for (let i = 0; i < tags.length; i++) {
+      const tag = tags[i];
+      (0, import_cache4.revalidateTag)(tag, "max");
+      if (cache) {
+        await cache.expireTag(tag);
+      }
+    }
+  }
+  if (paths == null ? void 0 : paths.length) {
+    for (let i = 0; i < paths.length; i++) {
+      const path = paths[i];
+      (0, import_cache4.revalidatePath)(path);
+    }
+  }
+  return new Response(
+    JSON.stringify({
+      handled: typeof tags !== "undefined" || typeof paths !== "undefined",
+      tags,
+      paths
+    })
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPreviewGETRouteHandler,
+  createPreviewOPTIONSRouteHandler,
+  createPreviewPOSTRouteHandler
+});