@uniformdev/next-app-router 20.81.1-alpha.7.sha-91a5b13e0c → 20.81.1

package/dist/cache.mjs

@@ -41,6 +41,124 @@ var __privateWrapper = (obj, member, setter, getter) => ({
   }
 });
 
+// ../../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 Node2 = class {
+      /// value;
+      /// next;
+      constructor(value) {
+        this.value = value;
+        this.next = void 0;
+      }
+    };
+    var Queue2 = class {
+      // TODO: Use private class fields when targeting Node.js 12.
+      // #_head;
+      // #_tail;
+      // #_size;
+      constructor() {
+        this.clear();
+      }
+      enqueue(value) {
+        const node = new Node2(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 = Queue2;
+  }
+});
+
+// ../../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 Queue2 = require_yocto_queue();
+    var pLimit3 = (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 Queue2();
+      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 = pLimit3;
+  }
+});
+
 // ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js
 var require_retry_operation = __commonJS({
   "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports, module) {
@@ -272,9 +390,436 @@ var require_retry2 = __commonJS({
   }
 });
 
-// ../canvas/dist/index.mjs
-import { ApiClient } from "@uniformdev/context/api";
-import { ApiClientError } from "@uniformdev/context/api";
+// src/data/resolveRouteFromCode.ts
+import { deserializeEvaluationResult } from "@uniformdev/next-app-router-shared";
+
+// ../context/dist/api/api.mjs
+var import_p_limit = __toESM(require_p_limit(), 1);
+var __defProp2 = Object.defineProperty;
+var __typeError2 = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+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 defaultLimitPolicy = (0, import_p_limit.default)(6);
+var UNIFORM_BEARER_TOKEN_NOT_VALID_OR_EXPIRED_MESSAGE = "Bearer token not valid or expired";
+var ApiClientError = class _ApiClientError extends Error {
+  constructor(errorMessage, fetchMethod, fetchUri, statusCode, statusText, requestId) {
+    super(
+      `${errorMessage}
+ ${statusCode}${statusText ? " " + statusText : ""} (${fetchMethod} ${fetchUri}${requestId ? ` Request ID: ${requestId}` : ""})`
+    );
+    __publicField2(this, "errorMessage", errorMessage);
+    __publicField2(this, "fetchMethod", fetchMethod);
+    __publicField2(this, "fetchUri", fetchUri);
+    __publicField2(this, "statusCode", statusCode);
+    __publicField2(this, "statusText", statusText);
+    __publicField2(this, "requestId", requestId);
+    Object.setPrototypeOf(this, _ApiClientError.prototype);
+  }
+};
+var BearerTokenNotValidOrExpiredError = class _BearerTokenNotValidOrExpiredError extends ApiClientError {
+  constructor(errorMessage, fetchMethod, fetchUri, statusCode, statusText, requestId) {
+    super(errorMessage, fetchMethod, fetchUri, statusCode, statusText, requestId);
+    Object.setPrototypeOf(this, _BearerTokenNotValidOrExpiredError.prototype);
+  }
+};
+var ApiClient = class _ApiClient {
+  constructor(options) {
+    __publicField2(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, _b;
+      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`;
+        }
+        if (apiResponse.status === 401 && message === UNIFORM_BEARER_TOKEN_NOT_VALID_OR_EXPIRED_MESSAGE) {
+          throw new BearerTokenNotValidOrExpiredError(
+            message,
+            (_a = options == null ? void 0 : options.method) != null ? _a : "GET",
+            fetchUri.toString(),
+            apiResponse.status,
+            apiResponse.statusText,
+            _ApiClient.getRequestId(apiResponse)
+          );
+        }
+        throw new ApiClientError(
+          message,
+          (_b = options == null ? void 0 : options.method) != null ? _b : "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, Math.max(0, resetWait + backoffWait)));
+    backoffRetriesLeft -= 1;
+  }
+  return response;
+}
+var isPlainObject = (obj) => typeof obj === "object" && obj !== null && !Array.isArray(obj);
+function rewriteFiltersForApi(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 _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(__privateGet2(_AggregateClient2, _url), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) an Aggregate */
+  async upsert(body) {
+    const fetchUri = this.createUrl(__privateGet2(_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(__privateGet2(_AggregateClient2, _url));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url = /* @__PURE__ */ new WeakMap();
+__privateAdd2(_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(__privateGet2(_DimensionClient2, _url2), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+};
+_url2 = /* @__PURE__ */ new WeakMap();
+__privateAdd2(_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(__privateGet2(_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(__privateGet2(_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(__privateGet2(_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(__privateGet2(_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(__privateGet2(_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();
+__privateAdd2(_EnrichmentClient, _url3, "/api/v1/enrichments");
+__privateAdd2(_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(__privateGet2(_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();
+__privateAdd2(_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(__privateGet2(_QuirkClient2, _url5), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) a Quirk */
+  async upsert(body) {
+    const fetchUri = this.createUrl(__privateGet2(_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(__privateGet2(_QuirkClient2, _url5));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url5 = /* @__PURE__ */ new WeakMap();
+__privateAdd2(_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(__privateGet2(_SignalClient2, _url6), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) a Signal */
+  async upsert(body) {
+    const fetchUri = this.createUrl(__privateGet2(_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(__privateGet2(_SignalClient2, _url6));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url6 = /* @__PURE__ */ new WeakMap();
+__privateAdd2(_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(__privateGet2(_TestClient2, _url7), { ...options, projectId });
+    return await this.apiClient(fetchUri);
+  }
+  /** Updates or creates (based on id) a Test */
+  async upsert(body) {
+    const fetchUri = this.createUrl(__privateGet2(_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(__privateGet2(_TestClient2, _url7));
+    await this.apiClient(fetchUri, {
+      method: "DELETE",
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
+  }
+};
+_url7 = /* @__PURE__ */ new WeakMap();
+__privateAdd2(_TestClient, _url7, "/api/v2/test");
 
 // ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
 var Node = class {
@@ -347,7 +892,7 @@ _tail = new WeakMap();
 _size = new WeakMap();
 
 // ../../node_modules/.pnpm/p-limit@6.2.0/node_modules/p-limit/index.js
-function pLimit(concurrency) {
+function pLimit2(concurrency) {
   validateConcurrency(concurrency);
   const queue = new Queue();
   let activeCount = 0;
@@ -627,44 +1172,19 @@ function pThrottle({ limit, interval, strict, onDelay }) {
 }
 
 // ../canvas/dist/index.mjs
-import { ApiClientError as ApiClientError2 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient2 } from "@uniformdev/context/api";
-import { rewriteFiltersForApi } from "@uniformdev/context/api";
-import { rewriteFiltersForApi as rewriteFiltersForApi2 } from "@uniformdev/context/api";
-import { ApiClientError as ApiClientError3 } from "@uniformdev/context/api";
-import { rewriteFiltersForApi as rewriteFiltersForApi3 } from "@uniformdev/context/api";
-import { ApiClientError as ApiClientError4 } from "@uniformdev/context/api";
-import { rewriteFiltersForApi as rewriteFiltersForApi4 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient3, rewriteFiltersForApi as rewriteFiltersForApi5 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient4, rewriteFiltersForApi as rewriteFiltersForApi6 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient5 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient6 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient7 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient8 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient9 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient10 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient11 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient12 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient13 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient14 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient15 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient16 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient17 } from "@uniformdev/context/api";
-import { ApiClientError as ApiClientError5 } from "@uniformdev/context/api";
-import { ApiClient as ApiClient18 } from "@uniformdev/context/api";
-var __typeError2 = (msg) => {
+var __typeError3 = (msg) => {
   throw TypeError(msg);
 };
-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 __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);
 function createLimitPolicy({
   throttle = { interval: 1e3, limit: 10 },
   retry: retry3 = { retries: 1, factor: 1.66 },
   limit = 10
 }) {
   const throttler = throttle ? pThrottle(throttle) : null;
-  const limiter = limit ? pLimit(limit) : null;
+  const limiter = limit ? pLimit2(limit) : null;
   return function limitPolicy(func) {
     let currentFunc = async () => await func();
     if (throttler) {
@@ -692,16 +1212,6 @@ function createLimitPolicy({
     return currentFunc();
   };
 }
-var ContentClientBase = class extends ApiClient2 {
-  constructor(options, defaultBypassCache) {
-    var _a, _b;
-    super({
-      ...options,
-      limitPolicy: (_a = options.limitPolicy) != null ? _a : createLimitPolicy({}),
-      bypassCache: (_b = options.bypassCache) != null ? _b : defaultBypassCache
-    });
-  }
-};
 var SELECT_QUERY_PREFIX = "select.";
 function appendCsv(out, key, values) {
   if (values === void 0) {
@@ -754,89 +1264,9 @@ var CANVAS_COMPONENT_DISPLAY_NAME_PARAM = `${CANVAS_INTERNAL_PARAM_PREFIX}displa
 var CANVAS_HYPOTHESIS_PARAM = `${CANVAS_INTERNAL_PARAM_PREFIX}hypothesis`;
 var IN_CONTEXT_EDITOR_QUERY_STRING_PARAM = "is_incontext_editing_mode";
 var EDGE_MAX_CACHE_TTL = 24 * 60 * 60;
-function resolveCompositionSelector(args) {
-  if ("compositionId" in args) {
-    const { compositionId, editionId, versionId, ...readOptions } = args;
-    return {
-      readOptions,
-      // raw mode matches on composition OR edition id via the compositionId param
-      compositionId: editionId != null ? editionId : compositionId,
-      versionId,
-      hasCompositionId: true,
-      pinnedEdition: editionId !== void 0
-    };
-  }
-  return { readOptions: args, hasCompositionId: false, pinnedEdition: false };
-}
-var DEFAULT_EDGE_API_HOST = "https://uniform.global";
-var DeliveryClientBase = class extends ContentClientBase {
-  constructor(options) {
-    var _a;
-    super(
-      options,
-      /* defaultBypassCache */
-      false
-    );
-    this.edgeApiHost = (_a = options.edgeApiHost) != null ? _a : DEFAULT_EDGE_API_HOST;
-    this.edgeRequestInit = options.disableSWR ? { headers: { "x-disable-swr": "true" } } : void 0;
-  }
-  /** Coerces the `diagnostics` option into the shape the edge endpoints accept. */
-  coerceDiagnostics(diagnostics) {
-    return typeof diagnostics === "boolean" ? diagnostics : diagnostics === "no-data" ? "no-data" : void 0;
-  }
-};
-var EDGE_SINGLE_URL = "/api/v1/composition";
-var EDGE_LIST_URL = "/api/v1/compositions";
-var CompositionDeliveryClient = class extends DeliveryClientBase {
-  constructor(options) {
-    super(options);
-  }
-  /** Fetches exactly one composition (throws `ApiClientError(404)` if absent). */
-  get(args) {
-    var _a;
-    const { diagnostics, select, ...rest } = args;
-    const { readOptions, compositionId, versionId, pinnedEdition } = resolveCompositionSelector(rest);
-    const url = this.createUrl(
-      EDGE_SINGLE_URL,
-      {
-        ...readOptions,
-        ...projectionToQuery(select),
-        // A pinned edition is folded into compositionId (raw matches edition or
-        // composition id); there is no editionId query param on this endpoint.
-        compositionId,
-        versionId,
-        projectId: this.options.projectId,
-        state: (_a = args.state) != null ? _a : CANVAS_PUBLISHED_STATE,
-        // editionId pins a specific edition for preview; otherwise locale-best.
-        editions: pinnedEdition ? "raw" : "auto",
-        diagnostics: this.coerceDiagnostics(diagnostics)
-      },
-      this.edgeApiHost
-    );
-    return this.apiClient(url, this.edgeRequestInit);
-  }
-  /** Fetches a list of compositions, optionally filtered. */
-  list(args = {}) {
-    var _a;
-    const { diagnostics, filters, select, ...rest } = args;
-    const url = this.createUrl(
-      EDGE_LIST_URL,
-      {
-        ...rest,
-        ...rewriteFiltersForApi(filters),
-        ...projectionToQuery(select),
-        projectId: this.options.projectId,
-        state: (_a = args.state) != null ? _a : CANVAS_PUBLISHED_STATE,
-        diagnostics: this.coerceDiagnostics(diagnostics)
-      },
-      this.edgeApiHost
-    );
-    return this.apiClient(url, this.edgeRequestInit);
-  }
-};
 var _contentTypesUrl;
 var _entriesUrl;
-var _ContentClient = class _ContentClient2 extends ApiClient4 {
+var _ContentClient = class _ContentClient2 extends ApiClient {
   constructor(options) {
     var _a;
     super(options);
@@ -844,16 +1274,16 @@ var _ContentClient = class _ContentClient2 extends ApiClient4 {
   }
   getContentTypes(options) {
     const { projectId } = this.options;
-    const fetchUri = this.createUrl(__privateGet2(_ContentClient2, _contentTypesUrl), { ...options, projectId });
+    const fetchUri = this.createUrl(__privateGet3(_ContentClient2, _contentTypesUrl), { ...options, projectId });
     return this.apiClient(fetchUri);
   }
   getEntries(options) {
     const { projectId } = this.options;
     const { skipDataResolution, filters, select, ...params } = options;
-    const rewrittenFilters = rewriteFiltersForApi6(filters);
+    const rewrittenFilters = rewriteFiltersForApi(filters);
     const rewrittenSelect = projectionToQuery(select);
     if (skipDataResolution) {
-      const url = this.createUrl(__privateGet2(_ContentClient2, _entriesUrl), {
+      const url = this.createUrl(__privateGet3(_ContentClient2, _entriesUrl), {
         ...params,
         ...rewrittenFilters,
         ...rewrittenSelect,
@@ -862,7 +1292,7 @@ var _ContentClient = class _ContentClient2 extends ApiClient4 {
       return this.apiClient(url);
     }
     const edgeUrl = this.createUrl(
-      __privateGet2(_ContentClient2, _entriesUrl),
+      __privateGet3(_ContentClient2, _entriesUrl),
       { ...this.getEdgeOptions(params), ...rewrittenFilters, ...rewrittenSelect },
       this.edgeApiHost
     );
@@ -880,7 +1310,7 @@ var _ContentClient = class _ContentClient2 extends ApiClient4 {
     return this.apiClient(historyUrl);
   }
   async upsertContentType(body, opts = {}) {
-    const fetchUri = this.createUrl(__privateGet2(_ContentClient2, _contentTypesUrl));
+    const fetchUri = this.createUrl(__privateGet3(_ContentClient2, _contentTypesUrl));
     if (typeof body.contentType.slugSettings === "object" && body.contentType.slugSettings !== null && Object.keys(body.contentType.slugSettings).length === 0) {
       delete body.contentType.slugSettings;
     }
@@ -892,7 +1322,7 @@ var _ContentClient = class _ContentClient2 extends ApiClient4 {
     });
   }
   async upsertEntry(body, options) {
-    const fetchUri = this.createUrl(__privateGet2(_ContentClient2, _entriesUrl));
+    const fetchUri = this.createUrl(__privateGet3(_ContentClient2, _entriesUrl));
     const headers = {};
     if (options == null ? void 0 : options.ifUnmodifiedSince) {
       headers["x-if-unmodified-since"] = options.ifUnmodifiedSince;
@@ -906,7 +1336,7 @@ var _ContentClient = class _ContentClient2 extends ApiClient4 {
     return { modified: response.headers.get("x-modified-at") };
   }
   async deleteContentType(body) {
-    const fetchUri = this.createUrl(__privateGet2(_ContentClient2, _contentTypesUrl));
+    const fetchUri = this.createUrl(__privateGet3(_ContentClient2, _contentTypesUrl));
     await this.apiClient(fetchUri, {
       method: "DELETE",
       body: JSON.stringify({ ...body, projectId: this.options.projectId }),
@@ -914,7 +1344,7 @@ var _ContentClient = class _ContentClient2 extends ApiClient4 {
     });
   }
   async deleteEntry(body) {
-    const fetchUri = this.createUrl(__privateGet2(_ContentClient2, _entriesUrl));
+    const fetchUri = this.createUrl(__privateGet3(_ContentClient2, _entriesUrl));
     await this.apiClient(fetchUri, {
       method: "DELETE",
       body: JSON.stringify({ ...body, projectId: this.options.projectId }),
@@ -933,17 +1363,17 @@ var _ContentClient = class _ContentClient2 extends ApiClient4 {
 };
 _contentTypesUrl = /* @__PURE__ */ new WeakMap();
 _entriesUrl = /* @__PURE__ */ new WeakMap();
-__privateAdd2(_ContentClient, _contentTypesUrl, "/api/v1/content-types");
-__privateAdd2(_ContentClient, _entriesUrl, "/api/v1/entries");
-var _url;
-var _DataTypeClient = class _DataTypeClient2 extends ApiClient6 {
+__privateAdd3(_ContentClient, _contentTypesUrl, "/api/v1/content-types");
+__privateAdd3(_ContentClient, _entriesUrl, "/api/v1/entries");
+var _url8;
+var _DataTypeClient = class _DataTypeClient2 extends ApiClient {
   constructor(options) {
     super(options);
   }
   /** Fetches a list of DataTypes for a project */
   async list(options) {
     const { projectId } = this.options;
-    const fetchUri = this.createUrl(__privateGet2(_DataTypeClient2, _url), { ...options, projectId });
+    const fetchUri = this.createUrl(__privateGet3(_DataTypeClient2, _url8), { ...options, projectId });
     return await this.apiClient(fetchUri);
   }
   /** @deprecated Use {@link list} instead. */
@@ -952,7 +1382,7 @@ var _DataTypeClient = class _DataTypeClient2 extends ApiClient6 {
   }
   /** Updates or creates (based on id) a DataType */
   async save(body) {
-    const fetchUri = this.createUrl(__privateGet2(_DataTypeClient2, _url));
+    const fetchUri = this.createUrl(__privateGet3(_DataTypeClient2, _url8));
     await this.apiClient(fetchUri, {
       method: "PUT",
       body: JSON.stringify({ ...body, projectId: this.options.projectId }),
@@ -965,7 +1395,7 @@ var _DataTypeClient = class _DataTypeClient2 extends ApiClient6 {
   }
   /** Deletes a DataType */
   async remove(body) {
-    const fetchUri = this.createUrl(__privateGet2(_DataTypeClient2, _url));
+    const fetchUri = this.createUrl(__privateGet3(_DataTypeClient2, _url8));
     await this.apiClient(fetchUri, {
       method: "DELETE",
       body: JSON.stringify({ ...body, projectId: this.options.projectId }),
@@ -973,10 +1403,10 @@ var _DataTypeClient = class _DataTypeClient2 extends ApiClient6 {
     });
   }
 };
-_url = /* @__PURE__ */ new WeakMap();
-__privateAdd2(_DataTypeClient, _url, "/api/v1/data-types");
+_url8 = /* @__PURE__ */ new WeakMap();
+__privateAdd3(_DataTypeClient, _url8, "/api/v1/data-types");
 var _baseUrl;
-var _IntegrationPropertyEditorsClient = class _IntegrationPropertyEditorsClient2 extends ApiClient8 {
+var _IntegrationPropertyEditorsClient = class _IntegrationPropertyEditorsClient2 extends ApiClient {
   constructor(options) {
     super(options);
     this.teamId = options.teamId;
@@ -985,7 +1415,7 @@ var _IntegrationPropertyEditorsClient = class _IntegrationPropertyEditorsClient2
    * 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), {
+    const fetchUri = this.createUrl(__privateGet3(_IntegrationPropertyEditorsClient2, _baseUrl), {
       ...options,
       teamId: this.teamId
     });
@@ -995,7 +1425,7 @@ var _IntegrationPropertyEditorsClient = class _IntegrationPropertyEditorsClient2
    * Creates or updates a custom AI property editor on a Mesh app.
    */
   async deploy(body) {
-    const fetchUri = this.createUrl(__privateGet2(_IntegrationPropertyEditorsClient2, _baseUrl));
+    const fetchUri = this.createUrl(__privateGet3(_IntegrationPropertyEditorsClient2, _baseUrl));
     await this.apiClient(fetchUri, {
       method: "PUT",
       body: JSON.stringify({ ...body, teamId: this.teamId }),
@@ -1006,7 +1436,7 @@ var _IntegrationPropertyEditorsClient = class _IntegrationPropertyEditorsClient2
    * Removes a custom AI property editor from a Mesh app.
    */
   async delete(body) {
-    const fetchUri = this.createUrl(__privateGet2(_IntegrationPropertyEditorsClient2, _baseUrl));
+    const fetchUri = this.createUrl(__privateGet3(_IntegrationPropertyEditorsClient2, _baseUrl));
     await this.apiClient(fetchUri, {
       method: "DELETE",
       body: JSON.stringify({ ...body, teamId: this.teamId }),
@@ -1015,16 +1445,16 @@ var _IntegrationPropertyEditorsClient = class _IntegrationPropertyEditorsClient2
   }
 };
 _baseUrl = /* @__PURE__ */ new WeakMap();
-__privateAdd2(_IntegrationPropertyEditorsClient, _baseUrl, "/api/v1/integration-property-editors");
-var _url2;
+__privateAdd3(_IntegrationPropertyEditorsClient, _baseUrl, "/api/v1/integration-property-editors");
+var _url22;
 var _projectsUrl;
-var _ProjectClient = class _ProjectClient2 extends ApiClient12 {
+var _ProjectClient = class _ProjectClient2 extends ApiClient {
   constructor(options) {
     super({ ...options, bypassCache: true });
   }
   /** Fetches single Project */
   async get(options) {
-    const fetchUri = this.createUrl(__privateGet2(_ProjectClient2, _url2), { ...options });
+    const fetchUri = this.createUrl(__privateGet3(_ProjectClient2, _url22), { ...options });
     return await this.apiClient(fetchUri);
   }
   /**
@@ -1033,7 +1463,7 @@ var _ProjectClient = class _ProjectClient2 extends ApiClient12 {
    * When omitted, returns all accessible teams and their projects.
    */
   async list(options) {
-    const fetchUri = this.createUrl(__privateGet2(_ProjectClient2, _projectsUrl), options ? { ...options } : {});
+    const fetchUri = this.createUrl(__privateGet3(_ProjectClient2, _projectsUrl), options ? { ...options } : {});
     return await this.apiClient(fetchUri);
   }
   /** @deprecated Use {@link list} instead. */
@@ -1042,7 +1472,7 @@ var _ProjectClient = class _ProjectClient2 extends ApiClient12 {
   }
   /** Updates or creates (based on id) a Project */
   async save(body) {
-    const fetchUri = this.createUrl(__privateGet2(_ProjectClient2, _url2));
+    const fetchUri = this.createUrl(__privateGet3(_ProjectClient2, _url22));
     return await this.apiClient(fetchUri, {
       method: "PUT",
       body: JSON.stringify({ ...body })
@@ -1054,7 +1484,7 @@ var _ProjectClient = class _ProjectClient2 extends ApiClient12 {
   }
   /** Deletes a Project */
   async remove(body) {
-    const fetchUri = this.createUrl(__privateGet2(_ProjectClient2, _url2));
+    const fetchUri = this.createUrl(__privateGet3(_ProjectClient2, _url22));
     await this.apiClient(fetchUri, {
       method: "DELETE",
       body: JSON.stringify({ ...body }),
@@ -1066,12 +1496,12 @@ var _ProjectClient = class _ProjectClient2 extends ApiClient12 {
     return this.remove(body);
   }
 };
-_url2 = /* @__PURE__ */ new WeakMap();
+_url22 = /* @__PURE__ */ new WeakMap();
 _projectsUrl = /* @__PURE__ */ new WeakMap();
-__privateAdd2(_ProjectClient, _url2, "/api/v1/project");
-__privateAdd2(_ProjectClient, _projectsUrl, "/api/v1/projects");
+__privateAdd3(_ProjectClient, _url22, "/api/v1/project");
+__privateAdd3(_ProjectClient, _projectsUrl, "/api/v1/projects");
 var ROUTE_URL = "/api/v1/route";
-var RouteClient = class extends ApiClient17 {
+var RouteClient = class extends ApiClient {
   constructor(options) {
     var _a;
     if (!options.limitPolicy) {
@@ -1114,38 +1544,10 @@ var getDataSourceVariantFromRouteGetParams = (params, defaultPreviewState) => {
   return dataSourceVariant;
 };
 
-// src/cache.ts
-import { cacheTag } from "next/cache";
-
-// src/utils/tag.ts
-var encodePathForTag = (path) => path.split("/").map((segment) => /[^\x00-\x7F]/.test(segment) ? encodeURIComponent(segment) : segment).join("/");
-var buildPathTag = (path) => {
-  const actualPath = path.startsWith("/") ? path : `/${path}`;
-  return `path:${encodePathForTag(actualPath)}`.toLowerCase();
-};
-var buildCompositionTag = (compositionId) => {
-  return `composition:${compositionId}`.toLowerCase();
-};
-var buildCompositionSlugTag = (slug) => {
-  return `composition-slug:${encodePathForTag(slug)}`.toLowerCase();
-};
-
-// src/clients/tags.ts
-var generateRouteCacheTags = ({ path }) => {
-  const tags = ["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;
-};
+// src/data/client.ts
+import { getCache, waitUntil } from "@vercel/functions";
 
-// src/clients/canvas.ts
+// src/clients/manifest.ts
 import "server-only";
 
 // src/utils/env.ts
@@ -1198,6 +1600,11 @@ var isStateCacheMode = (options) => {
 var isDetectCacheMode = (options) => {
   return "searchParams" in options && "draftModeEnabled" in options;
 };
+var resolveManifestCache = (options) => {
+  return resolveCache({
+    options
+  });
+};
 var resolveCanvasCache = (options) => {
   return resolveCache({
     options
@@ -1265,7 +1672,6 @@ var determineFetchCacheOptions = (mode) => {
 };
 
 // src/clients/retry.ts
-import { ApiClientError as ApiClientError6 } from "@uniformdev/context/api";
 function createThrottler(limit, interval) {
   let available = limit;
   let refillScheduled = false;
@@ -1376,7 +1782,7 @@ function createLimitPolicy2({
           if (retryOptions.onFailedAttempt) {
             await retryOptions.onFailedAttempt(error);
           }
-          if (error instanceof ApiClientError6 && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
+          if (error instanceof ApiClientError && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
             throw error;
           }
         }
@@ -1386,66 +1792,67 @@ function createLimitPolicy2({
   };
 }
 
-// src/clients/canvas.ts
-var buildCanvasClientOptions = (options) => {
-  const cache = resolveCanvasCache(options);
-  return {
-    projectId: env.getProjectId(),
+// src/utils/tag.ts
+var buildPathTag = (path) => {
+  const actualPath = path.startsWith("/") ? path : `/${path}`;
+  return `path:${actualPath}`.toLowerCase();
+};
+
+// 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 cache = resolveManifestCache(options);
+  const manifestClient = new ManifestClient({
     apiHost: env.getApiHost(),
     apiKey: env.getApiKey(),
-    edgeApiHost: env.getEdgeApiHost(),
-    disableSWR: typeof cache.disableSWR !== "undefined" ? cache.disableSWR : true,
+    projectId: env.getProjectId(),
     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 slugKey = "slug";
-        const compositionId = requestedUrl.searchParams.get(compositionIdKey);
-        const compositionIds = requestedUrl.searchParams.get(compositionIdsKey);
-        const slug = requestedUrl.searchParams.get(slugKey);
-        if (compositionId) {
-          tags.push(buildCompositionTag(compositionId));
-        }
-        if (slug) {
-          tags.push(buildCompositionSlugTag(slug));
-        }
-        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"
         },
+        cache: fetchCache,
         next: {
           revalidate,
-          tags: tags.length ? tags : void 0
+          tags: generateManifestCacheTags()
         }
       });
     }
-  };
+  });
+  return manifestClient;
 };
-var getCompositionDeliveryClient = (options) => {
-  return new CompositionDeliveryClient(buildCanvasClientOptions(options));
+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/route.ts
@@ -1499,200 +1906,217 @@ var getRouteClient = (options) => {
   return client;
 };
 
+// src/config/helpers.ts
+import config from "@uniformdev/next-app-router/config/resolved";
+var getMiddlewareRuntimeCache = () => {
+  if (process.env.NODE_ENV === "development" && !process.env.RUNTIME_CACHE_ENDPOINT) {
+    return false;
+  }
+  if (typeof config.middlewareRuntimeCache === "boolean") {
+    return config.middlewareRuntimeCache;
+  }
+  return true;
+};
+var getDisableSwrMiddlewareCache = () => {
+  var _a;
+  if (typeof ((_a = config.experimental) == null ? void 0 : _a.disableSwrMiddlewareCache) === "boolean") {
+    return config.experimental.disableSwrMiddlewareCache;
+  }
+  return false;
+};
+
 // src/data/client.ts
-var DataClient = class {
-  constructor({ fetchCache = true } = {}) {
-    this.fetchCache = fetchCache;
-  }
-  async getRoute({ pageState }) {
-    const routeClient = getRouteClient({ cache: this.resolveCache(pageState) });
-    const parameters = {
-      path: pageState.routePath,
-      state: pageState.compositionState,
-      dataSourceVariant: getDataSourceVariantFromRouteGetParams({}, pageState.compositionState),
-      withComponentIDs: true,
-      releaseId: pageState.releaseId,
-      locale: pageState.locale,
-      ignoreRedirects: shouldIgnoreRedirects({ state: pageState.compositionState })
-    };
-    return routeClient.get(parameters);
+var MANIFEST_CACHE_KEY = "uniform-manifest";
+var DefaultDataClient = class {
+  async getManifest(options) {
+    const cache = options.source === "middleware" && getMiddlewareRuntimeCache() ? getCache() : null;
+    if (cache) {
+      const cachedManifest = await cache.get(MANIFEST_CACHE_KEY);
+      if (cachedManifest) {
+        return cachedManifest;
+      }
+    }
+    const manifest = await getManifest({
+      cache: isDevelopmentEnvironment() ? {
+        type: "no-cache",
+        bypassCache: true
+      } : {
+        type: "force-cache"
+      }
+    });
+    if (cache) {
+      waitUntil(
+        (async () => {
+          await cache.set(MANIFEST_CACHE_KEY, manifest, {
+            tags: generateManifestCacheTags()
+          });
+        })()
+      );
+    }
+    return manifest;
   }
-  /** Returns `null` when no composition matches the selector in the page state's composition state. */
-  async getComposition({
-    pageState,
-    selector
+  async getRouteFromApi({
+    route,
+    routeClient,
+    enableRuntimeCache,
+    disableSwrCache
   }) {
-    const client = getCompositionDeliveryClient({ cache: this.resolveCache(pageState) });
-    try {
-      return await client.get({
-        ...selector,
-        state: pageState.compositionState,
-        withComponentIDs: true,
-        releaseId: pageState.releaseId,
-        locale: pageState.locale
-      });
-    } catch (e) {
-      if (e instanceof ApiClientError5 && e.statusCode === 404) {
-        return null;
+    const newCacheKey = `uniform-route-${route.state}-${route.releaseId}-${route.path}`;
+    const oldCacheKey = `uniform-route-old-${route.state}-${route.releaseId}-${route.path}`;
+    const cache = enableRuntimeCache ? getCache() : null;
+    const cacheNewRoute = async (result2) => {
+      if (cache && result2.type === "composition") {
+        const tags = generateRouteCacheTags({ path: route.path });
+        await cache.set(newCacheKey, result2, {
+          tags
+        });
+      }
+    };
+    const cacheOldRoute = async (result2) => {
+      if (cache && result2.type === "composition" && !disableSwrCache) {
+        const tags = generateRouteCacheTags({ path: route.path, old: true });
+        await cache.set(oldCacheKey, result2, {
+          tags
+        });
+      }
+    };
+    if (cache) {
+      const [cachedRoute, oldCachedRoute] = await Promise.all([
+        cache.get(newCacheKey),
+        disableSwrCache ? null : cache.get(oldCacheKey)
+      ]);
+      if (cachedRoute) {
+        return cachedRoute;
+      }
+      if (oldCachedRoute) {
+        waitUntil(
+          (async () => {
+            const result2 = await routeClient.get(route);
+            await cacheNewRoute(result2);
+          })()
+        );
+        return oldCachedRoute;
       }
-      throw e;
     }
+    const result = await routeClient.get(route);
+    waitUntil(
+      (async () => {
+        await Promise.all([
+          cacheNewRoute(result),
+          disableSwrCache ? Promise.resolve() : cacheOldRoute(result)
+        ]);
+      })()
+    );
+    return result;
   }
-  resolveCache(pageState) {
-    if (pageState.compositionState !== CANVAS_PUBLISHED_STATE || isDevelopmentEnvironment()) {
-      return { type: "no-cache", bypassCache: true };
+  async getRoute(options) {
+    if (options.source === "middleware") {
+      return this.getRouteMiddleware(options);
     }
-    return this.fetchCache ? { type: "force-cache" } : { type: "no-cache" };
+    return this.getRoutePageState(options);
   }
-};
-
-// src/data/deserializePageState.ts
-import { deserializeEvaluationResult } from "@uniformdev/next-app-router-shared";
-var deserializePageState = ({ code }) => deserializeEvaluationResult({ input: code });
-
-// src/data/resolveCompositionForPageState.ts
-var resolveCompositionForPageState = async ({
-  pageState,
-  selector,
-  matchedRoute,
-  dataClient = new DataClient()
-}) => {
-  const states = pageState.compositionState === CANVAS_EDITOR_STATE ? [CANVAS_EDITOR_STATE, CANVAS_DRAFT_STATE] : [pageState.compositionState];
-  let composition = null;
-  for (const state of states) {
-    try {
-      composition = await dataClient.getComposition({
-        pageState: { ...pageState, compositionState: state },
-        selector
+  async enhanceRoute(_options) {
+  }
+  async getRouteMiddleware(options) {
+    const routeClient = getRouteClient({
+      searchParams: options.searchParams,
+      draftModeEnabled: options.draftModeEnabled
+    });
+    const resolvedRoute = await this.getRouteFromApi({
+      source: "middleware",
+      route: options.route,
+      routeClient,
+      // The runtime cache is keyed on the route path. Development bypasses it so an author sees
+      // an edit right away, the same way the fetch cache is bypassed for development.
+      enableRuntimeCache: options.route.state === CANVAS_PUBLISHED_STATE && getMiddlewareRuntimeCache() && !isDevelopmentEnvironment(),
+      disableSwrCache: getDisableSwrMiddlewareCache()
+    });
+    if (resolvedRoute.type === "composition") {
+      await this.enhanceRoute({
+        source: "middleware",
+        parameters: options.route,
+        route: resolvedRoute,
+        routeClient,
+        keys: void 0
       });
-    } catch (e) {
-      console.warn(`Failed to get composition ${JSON.stringify(selector)} with state ${state}`, e);
     }
-    if (composition) {
-      break;
-    }
-  }
-  if (!composition) {
-    return { pageState, route: void 0 };
+    return {
+      route: resolvedRoute
+    };
   }
-  return {
-    pageState: { ...pageState, compositionState: composition.state },
-    route: {
-      type: "composition",
-      compositionApiResponse: composition,
-      matchedRoute
+  async getRoutePageState(options) {
+    const shouldBypassCache = options.pageState.compositionState !== CANVAS_PUBLISHED_STATE || isDevelopmentEnvironment();
+    const routeClient = getRouteClient({
+      cache: shouldBypassCache ? {
+        type: "no-cache",
+        bypassCache: true
+      } : {
+        type: "force-cache"
+      }
+    });
+    const originalRoute = {
+      path: options.pageState.routePath,
+      state: options.pageState.compositionState,
+      dataSourceVariant: getDataSourceVariantFromRouteGetParams({}, options.pageState.compositionState),
+      withComponentIDs: true,
+      releaseId: options.pageState.releaseId,
+      locale: options.pageState.locale,
+      ignoreRedirects: shouldIgnoreRedirects({ state: options.pageState.compositionState })
+    };
+    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
+    };
+  }
 };
 
-// src/data/resolveCompositionById.ts
-var resolveCompositionById = ({
-  pageState,
-  compositionId,
-  matchedRoute = pageState.routePath
-}) => resolveCompositionForPageState({ pageState, selector: { compositionId }, matchedRoute });
-
-// src/data/resolveCompositionBySlug.ts
-var resolveCompositionBySlug = ({
-  pageState,
-  slug,
-  matchedRoute = pageState.routePath
-}) => resolveCompositionForPageState({ pageState, selector: { slug }, matchedRoute });
-
-// src/data/resolveRouteForPageState.ts
-var resolveRouteForPageState = async ({
-  pageState: providedPageState,
-  dataClient = new DataClient()
+// src/data/resolveRouteFromCode.ts
+var resolveRouteFromCode = async ({
+  code,
+  dataClient: providedDataClient
 }) => {
-  const states = providedPageState.compositionState === CANVAS_EDITOR_STATE ? [CANVAS_EDITOR_STATE, CANVAS_DRAFT_STATE] : [providedPageState.compositionState];
-  let pageState = providedPageState;
-  let route = null;
-  for (const state of states) {
-    pageState = { ...providedPageState, compositionState: state };
-    try {
-      route = await dataClient.getRoute({ pageState });
-    } catch (e) {
-      console.warn(`Failed to retrieve route by path: ${pageState.routePath} with state ${state}`, e);
-    }
-    if (route && route.type !== "notFound") {
-      break;
-    }
-  }
-  if ((route == null ? void 0 : route.type) === "composition" || (route == null ? void 0 : route.type) === "redirect") {
-    return { pageState, route };
-  }
-  return { pageState, route: void 0 };
+  const pageState = deserializeEvaluationResult({ 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/cache.ts
-var tagScope = (result, requestedTags) => {
-  var _a;
-  const tags = [...requestedTags];
-  if (((_a = result.route) == null ? void 0 : _a.type) === "composition") {
-    tags.push(buildCompositionTag(result.route.compositionApiResponse.composition._id));
-  }
-  cacheTag(...tags);
-  return result;
-};
-var createScopeDataClient = () => new DataClient({ fetchCache: false });
-var isPublished = (pageState) => pageState.compositionState === CANVAS_PUBLISHED_STATE;
-var resolveRouteCached = async (pageState) => {
-  "use cache";
-  return tagScope(
-    await resolveRouteForPageState({ pageState, dataClient: createScopeDataClient() }),
-    generateRouteCacheTags({ path: pageState.routePath })
-  );
-};
-var resolveCompositionByIdCached = async ({
-  pageState,
-  compositionId,
-  matchedRoute = pageState.routePath
+var resolveRouteFromCode2 = async ({
+  code,
+  dataClient: providedDataClient
 }) => {
   "use cache";
-  return tagScope(
-    await resolveCompositionForPageState({
-      pageState,
-      selector: { compositionId },
-      matchedRoute,
-      dataClient: createScopeDataClient()
-    }),
-    [buildCompositionTag(compositionId)]
-  );
-};
-var resolveCompositionBySlugCached = async ({
-  pageState,
-  slug,
-  matchedRoute = pageState.routePath
-}) => {
-  "use cache";
-  return tagScope(
-    await resolveCompositionForPageState({
-      pageState,
-      selector: { slug },
-      matchedRoute,
-      dataClient: createScopeDataClient()
-    }),
-    [buildCompositionSlugTag(slug)]
-  );
-};
-var resolveRouteFromCode = async ({
-  code
-}) => {
-  const pageState = deserializePageState({ code });
-  return isPublished(pageState) ? resolveRouteCached(pageState) : resolveRouteForPageState({ pageState });
-};
-var resolveRouteFromPath = async ({
-  pageState,
-  path
-}) => {
-  const pathPageState = { ...pageState, routePath: path };
-  return isPublished(pageState) ? resolveRouteCached(pathPageState) : resolveRouteForPageState({ pageState: pathPageState });
+  const result = await resolveRouteFromCode({
+    code,
+    dataClient: providedDataClient
+  });
+  return result;
 };
-var resolveCompositionById2 = async (options) => isPublished(options.pageState) ? resolveCompositionByIdCached(options) : resolveCompositionById(options);
-var resolveCompositionBySlug2 = async (options) => isPublished(options.pageState) ? resolveCompositionBySlugCached(options) : resolveCompositionBySlug(options);
 export {
-  resolveCompositionById2 as resolveCompositionById,
-  resolveCompositionBySlug2 as resolveCompositionBySlug,
-  resolveRouteFromCode,
-  resolveRouteFromPath
+  resolveRouteFromCode2 as resolveRouteFromCode
 };