@uniformdev/next-app-router 20.69.0 → 20.69.1-alpha.10

package/dist/middleware.js

@@ -8,6 +8,7 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -32,16 +33,25 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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 __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, 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"(exports2, module2) {
     "use strict";
-    var Node = class {
+    var Node2 = class {
       /// value;
       /// next;
       constructor(value) {
@@ -49,7 +59,7 @@ var require_yocto_queue = __commonJS({
         this.next = void 0;
       }
     };
-    var Queue = class {
+    var Queue2 = class {
       // TODO: Use private class fields when targeting Node.js 12.
       // #_head;
       // #_tail;
@@ -58,7 +68,7 @@ var require_yocto_queue = __commonJS({
         this.clear();
       }
       enqueue(value) {
-        const node = new Node(value);
+        const node = new Node2(value);
         if (this._head) {
           this._tail.next = node;
           this._tail = node;
@@ -93,7 +103,7 @@ var require_yocto_queue = __commonJS({
         }
       }
     };
-    module2.exports = Queue;
+    module2.exports = Queue2;
   }
 });
 
@@ -101,12 +111,12 @@ var require_yocto_queue = __commonJS({
 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) => {
+    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 Queue();
+      const queue = new Queue2();
       let activeCount = 0;
       const next = () => {
         activeCount--;
@@ -151,7 +161,238 @@ var require_p_limit = __commonJS({
       });
       return generator;
     };
-    module2.exports = pLimit2;
+    module2.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"(exports2, module2) {
+    "use strict";
+    function RetryOperation(timeouts, options) {
+      if (typeof options === "boolean") {
+        options = { forever: options };
+      }
+      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+      this._timeouts = timeouts;
+      this._options = options || {};
+      this._maxRetryTime = options && options.maxRetryTime || Infinity;
+      this._fn = null;
+      this._errors = [];
+      this._attempts = 1;
+      this._operationTimeout = null;
+      this._operationTimeoutCb = null;
+      this._timeout = null;
+      this._operationStart = null;
+      this._timer = null;
+      if (this._options.forever) {
+        this._cachedTimeouts = this._timeouts.slice(0);
+      }
+    }
+    module2.exports = RetryOperation;
+    RetryOperation.prototype.reset = function() {
+      this._attempts = 1;
+      this._timeouts = this._originalTimeouts.slice(0);
+    };
+    RetryOperation.prototype.stop = function() {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (this._timer) {
+        clearTimeout(this._timer);
+      }
+      this._timeouts = [];
+      this._cachedTimeouts = null;
+    };
+    RetryOperation.prototype.retry = function(err) {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (!err) {
+        return false;
+      }
+      var currentTime = (/* @__PURE__ */ new Date()).getTime();
+      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.push(err);
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+      }
+      this._errors.push(err);
+      var timeout = this._timeouts.shift();
+      if (timeout === void 0) {
+        if (this._cachedTimeouts) {
+          this._errors.splice(0, this._errors.length - 1);
+          timeout = this._cachedTimeouts.slice(-1);
+        } else {
+          return false;
+        }
+      }
+      var self = this;
+      this._timer = setTimeout(function() {
+        self._attempts++;
+        if (self._operationTimeoutCb) {
+          self._timeout = setTimeout(function() {
+            self._operationTimeoutCb(self._attempts);
+          }, self._operationTimeout);
+          if (self._options.unref) {
+            self._timeout.unref();
+          }
+        }
+        self._fn(self._attempts);
+      }, timeout);
+      if (this._options.unref) {
+        this._timer.unref();
+      }
+      return true;
+    };
+    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+      this._fn = fn;
+      if (timeoutOps) {
+        if (timeoutOps.timeout) {
+          this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+          this._operationTimeoutCb = timeoutOps.cb;
+        }
+      }
+      var self = this;
+      if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function() {
+          self._operationTimeoutCb();
+        }, self._operationTimeout);
+      }
+      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+      this._fn(this._attempts);
+    };
+    RetryOperation.prototype.try = function(fn) {
+      console.log("Using RetryOperation.try() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = function(fn) {
+      console.log("Using RetryOperation.start() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = RetryOperation.prototype.try;
+    RetryOperation.prototype.errors = function() {
+      return this._errors;
+    };
+    RetryOperation.prototype.attempts = function() {
+      return this._attempts;
+    };
+    RetryOperation.prototype.mainError = function() {
+      if (this._errors.length === 0) {
+        return null;
+      }
+      var counts = {};
+      var mainError = null;
+      var mainErrorCount = 0;
+      for (var i = 0; i < this._errors.length; i++) {
+        var error = this._errors[i];
+        var message = error.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+          mainError = error;
+          mainErrorCount = count;
+        }
+      }
+      return mainError;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js
+var require_retry = __commonJS({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js"(exports2) {
+    "use strict";
+    var RetryOperation = require_retry_operation();
+    exports2.operation = function(options) {
+      var timeouts = exports2.timeouts(options);
+      return new RetryOperation(timeouts, {
+        forever: options && (options.forever || options.retries === Infinity),
+        unref: options && options.unref,
+        maxRetryTime: options && options.maxRetryTime
+      });
+    };
+    exports2.timeouts = function(options) {
+      if (options instanceof Array) {
+        return [].concat(options);
+      }
+      var opts = {
+        retries: 10,
+        factor: 2,
+        minTimeout: 1 * 1e3,
+        maxTimeout: Infinity,
+        randomize: false
+      };
+      for (var key in options) {
+        opts[key] = options[key];
+      }
+      if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+      }
+      var timeouts = [];
+      for (var i = 0; i < opts.retries; i++) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      if (options && options.forever && !timeouts.length) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      timeouts.sort(function(a, b) {
+        return a - b;
+      });
+      return timeouts;
+    };
+    exports2.createTimeout = function(attempt, opts) {
+      var random = opts.randomize ? Math.random() + 1 : 1;
+      var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+      timeout = Math.min(timeout, opts.maxTimeout);
+      return timeout;
+    };
+    exports2.wrap = function(obj, options, methods) {
+      if (options instanceof Array) {
+        methods = options;
+        options = null;
+      }
+      if (!methods) {
+        methods = [];
+        for (var key in obj) {
+          if (typeof obj[key] === "function") {
+            methods.push(key);
+          }
+        }
+      }
+      for (var i = 0; i < methods.length; i++) {
+        var method = methods[i];
+        var original = obj[method];
+        obj[method] = function retryWrapper(original2) {
+          var op = exports2.operation(options);
+          var args = Array.prototype.slice.call(arguments, 1);
+          var callback = args.pop();
+          args.push(function(err) {
+            if (op.retry(err)) {
+              return;
+            }
+            if (err) {
+              arguments[0] = op.mainError();
+            }
+            callback.apply(this, arguments);
+          });
+          op.attempt(function() {
+            original2.apply(obj, args);
+          });
+        }.bind(obj, original);
+        obj[method].options = options;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js
+var require_retry2 = __commonJS({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_retry();
   }
 });
 
@@ -359,8 +600,8 @@ var __defProp2 = Object.defineProperty;
 var __typeError2 = (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 __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);
@@ -382,7 +623,7 @@ var ApiClientError = class _ApiClientError extends Error {
 };
 var ApiClient = class _ApiClient {
   constructor(options) {
-    __publicField(this, "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");
@@ -683,472 +924,266 @@ var _QuirkClient = class _QuirkClient2 extends ApiClient {
     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");
-
-// ../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 __typeError3 = (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 __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 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;
-    };
+      body: JSON.stringify({ ...body, projectId: this.options.projectId }),
+      expectNoContent: true
+    });
   }
-});
-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));
+  /** 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 {
+  constructor(value) {
+    __publicField(this, "value");
+    __publicField(this, "next");
+    this.value = value;
+  }
+};
+var _head, _tail, _size;
+var Queue = class {
+  constructor() {
+    __privateAdd(this, _head);
+    __privateAdd(this, _tail);
+    __privateAdd(this, _size);
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (__privateGet(this, _head)) {
+      __privateGet(this, _tail).next = node;
+      __privateSet(this, _tail, node);
+    } else {
+      __privateSet(this, _head, node);
+      __privateSet(this, _tail, node);
+    }
+    __privateWrapper(this, _size)._++;
+  }
+  dequeue() {
+    const current = __privateGet(this, _head);
+    if (!current) {
+      return;
+    }
+    __privateSet(this, _head, __privateGet(this, _head).next);
+    __privateWrapper(this, _size)._--;
+    if (!__privateGet(this, _head)) {
+      __privateSet(this, _tail, void 0);
+    }
+    return current.value;
+  }
+  peek() {
+    if (!__privateGet(this, _head)) {
+      return;
+    }
+    return __privateGet(this, _head).value;
+  }
+  clear() {
+    __privateSet(this, _head, void 0);
+    __privateSet(this, _tail, void 0);
+    __privateSet(this, _size, 0);
+  }
+  get size() {
+    return __privateGet(this, _size);
+  }
+  *[Symbol.iterator]() {
+    let current = __privateGet(this, _head);
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  *drain() {
+    while (__privateGet(this, _head)) {
+      yield this.dequeue();
+    }
+  }
+};
+_head = new WeakMap();
+_tail = new WeakMap();
+_size = new WeakMap();
+
+// ../../node_modules/.pnpm/p-limit@6.2.0/node_modules/p-limit/index.js
+function pLimit2(concurrency) {
+  validateConcurrency(concurrency);
+  const queue = new Queue();
+  let activeCount = 0;
+  const resumeNext = () => {
+    if (activeCount < concurrency && queue.size > 0) {
+      queue.dequeue()();
+      activeCount++;
+    }
+  };
+  const next = () => {
+    activeCount--;
+    resumeNext();
+  };
+  const run = async (function_, resolve, arguments_) => {
+    const result = (async () => function_(...arguments_))();
+    resolve(result);
+    try {
+      await result;
+    } catch (e) {
+    }
+    next();
+  };
+  const enqueue = (function_, resolve, arguments_) => {
+    new Promise((internalResolve) => {
+      queue.enqueue(internalResolve);
+    }).then(
+      run.bind(void 0, function_, resolve, arguments_)
+    );
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency) {
+        resumeNext();
       }
-      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;
+    })();
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve) => {
+    enqueue(function_, resolve, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        queue.clear();
       }
-      if (!methods) {
-        methods = [];
-        for (var key in obj) {
-          if (typeof obj[key] === "function") {
-            methods.push(key);
+    },
+    concurrency: {
+      get: () => concurrency,
+      set(newConcurrency) {
+        validateConcurrency(newConcurrency);
+        concurrency = newConcurrency;
+        queueMicrotask(() => {
+          while (activeCount < concurrency && queue.size > 0) {
+            resumeNext();
           }
-        }
-      }
-      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();
+    }
+  });
+  return generator;
+}
+function validateConcurrency(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
   }
-});
-var import_p_limit2 = __toESM2(require_p_limit2());
-var import_retry = __toESM2(require_retry2(), 1);
-var networkErrorMsgs = /* @__PURE__ */ new Set([
+}
+
+// ../../node_modules/.pnpm/p-retry@6.2.1/node_modules/p-retry/index.js
+var import_retry = __toESM(require_retry2(), 1);
+
+// ../../node_modules/.pnpm/is-network-error@1.1.0/node_modules/is-network-error/index.js
+var objectToString = Object.prototype.toString;
+var isError = (value) => objectToString.call(value) === "[object Error]";
+var errorMessages = /* @__PURE__ */ new Set([
+  "network error",
+  // Chrome
   "Failed to fetch",
   // Chrome
   "NetworkError when attempting to fetch resource.",
   // Firefox
   "The Internet connection appears to be offline.",
-  // Safari
+  // Safari 16
+  "Load failed",
+  // Safari 17+
   "Network request failed",
   // `cross-fetch`
-  "fetch failed"
+  "fetch failed",
+  // Undici (Node.js)
+  "terminated"
   // Undici (Node.js)
 ]);
+function isNetworkError(error) {
+  const isValid = error && isError(error) && error.name === "TypeError" && typeof error.message === "string";
+  if (!isValid) {
+    return false;
+  }
+  if (error.message === "Load failed") {
+    return error.stack === void 0;
+  }
+  return errorMessages.has(error.message);
+}
+
+// ../../node_modules/.pnpm/p-retry@6.2.1/node_modules/p-retry/index.js
 var AbortError = class extends Error {
   constructor(message) {
     super();
@@ -1169,63 +1204,71 @@ var decorateErrorWithCounts = (error, attemptNumber, options) => {
   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
+    var _a, _b, _c;
+    options = { ...options };
+    (_a = options.onFailedAttempt) != null ? _a : options.onFailedAttempt = () => {
     };
+    (_b = options.shouldRetry) != null ? _b : options.shouldRetry = () => true;
+    (_c = options.retries) != null ? _c : options.retries = 10;
     const operation = import_retry.default.operation(options);
+    const abortHandler = () => {
+      var _a2;
+      operation.stop();
+      reject((_a2 = options.signal) == null ? void 0 : _a2.reason);
+    };
+    if (options.signal && !options.signal.aborted) {
+      options.signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    const cleanUp = () => {
+      var _a2;
+      (_a2 = options.signal) == null ? void 0 : _a2.removeEventListener("abort", abortHandler);
+      operation.stop();
+    };
     operation.attempt(async (attemptNumber) => {
       try {
-        resolve(await input(attemptNumber));
+        const result = await input(attemptNumber);
+        cleanUp();
+        resolve(result);
       } 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 {
+        try {
+          if (!(error instanceof Error)) {
+            throw new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`);
+          }
+          if (error instanceof AbortError) {
+            throw error.originalError;
+          }
+          if (error instanceof TypeError && !isNetworkError(error)) {
+            throw error;
+          }
           decorateErrorWithCounts(error, attemptNumber, options);
-          try {
-            await options.onFailedAttempt(error);
-          } catch (error2) {
-            reject(error2);
-            return;
+          if (!await options.shouldRetry(error)) {
+            operation.stop();
+            reject(error);
           }
+          await options.onFailedAttempt(error);
           if (!operation.retry(error)) {
-            reject(operation.mainError());
+            throw operation.mainError();
           }
+        } catch (finalError) {
+          decorateErrorWithCounts(finalError, attemptNumber, options);
+          cleanUp();
+          reject(finalError);
         }
       }
     });
-    if (options.signal && !options.signal.aborted) {
-      options.signal.addEventListener("abort", () => {
-        operation.stop();
-        const reason = options.signal.reason === void 0 ? getDOMException("The operation was aborted.") : options.signal.reason;
-        reject(reason instanceof Error ? reason : getDOMException(reason));
-      }, {
-        once: true
-      });
-    }
   });
 }
+
+// ../../node_modules/.pnpm/p-throttle@6.2.0/node_modules/p-throttle/index.js
 var AbortError2 = class extends Error {
   constructor() {
     super("Throttled function aborted");
     this.name = "AbortError";
   }
 };
-function pThrottle({ limit, interval, strict }) {
+function pThrottle({ limit, interval, strict, onDelay }) {
   if (!Number.isFinite(limit)) {
     throw new TypeError("Expected `limit` to be a finite number");
   }
@@ -1253,32 +1296,38 @@ function pThrottle({ limit, interval, strict }) {
   const strictTicks = [];
   function strictDelay() {
     const now = Date.now();
-    if (strictTicks.length < limit) {
-      strictTicks.push(now);
-      return 0;
+    if (strictTicks.length > 0 && now - strictTicks.at(-1) > interval) {
+      strictTicks.length = 0;
     }
-    const earliestTime = strictTicks.shift() + interval;
-    if (now >= earliestTime) {
+    if (strictTicks.length < limit) {
       strictTicks.push(now);
       return 0;
     }
-    strictTicks.push(earliestTime);
-    return earliestTime - now;
+    const nextExecutionTime = strictTicks[0] + interval;
+    strictTicks.shift();
+    strictTicks.push(nextExecutionTime);
+    return Math.max(0, nextExecutionTime - now);
   }
   const getDelay = strict ? strictDelay : windowedDelay;
   return (function_) => {
-    const throttled = function(...args) {
+    const throttled = function(...arguments_) {
       if (!throttled.isEnabled) {
-        return (async () => function_.apply(this, args))();
+        return (async () => function_.apply(this, arguments_))();
       }
-      let timeout;
+      let timeoutId;
       return new Promise((resolve, reject) => {
         const execute = () => {
-          resolve(function_.apply(this, args));
-          queue.delete(timeout);
+          resolve(function_.apply(this, arguments_));
+          queue.delete(timeoutId);
         };
-        timeout = setTimeout(execute, getDelay());
-        queue.set(timeout, reject);
+        const delay = getDelay();
+        if (delay > 0) {
+          timeoutId = setTimeout(execute, delay);
+          queue.set(timeoutId, reject);
+          onDelay == null ? void 0 : onDelay(...arguments_);
+        } else {
+          execute();
+        }
       });
     };
     throttled.abort = () => {
@@ -1290,16 +1339,29 @@ function pThrottle({ limit, interval, strict }) {
       strictTicks.splice(0, strictTicks.length);
     };
     throttled.isEnabled = true;
+    Object.defineProperty(throttled, "queueSize", {
+      get() {
+        return queue.size;
+      }
+    });
     return throttled;
   };
 }
+
+// ../canvas/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);
 function createLimitPolicy({
   throttle = { interval: 1e3, limit: 10 },
-  retry: retry2 = { retries: 1, factor: 1.66 },
+  retry: retry3 = { retries: 1, factor: 1.66 },
   limit = 10
 }) {
   const throttler = throttle ? pThrottle(throttle) : null;
-  const limiter = limit ? (0, import_p_limit2.default)(limit) : null;
+  const limiter = limit ? pLimit2(limit) : null;
   return function limitPolicy(func) {
     let currentFunc = async () => await func();
     if (throttler) {
@@ -1310,13 +1372,13 @@ function createLimitPolicy({
       const limitFunc = currentFunc;
       currentFunc = () => limiter(limitFunc);
     }
-    if (retry2) {
+    if (retry3) {
       const retryFunc = currentFunc;
       currentFunc = () => pRetry(retryFunc, {
-        ...retry2,
+        ...retry3,
         onFailedAttempt: async (error) => {
-          if (retry2.onFailedAttempt) {
-            await retry2.onFailedAttempt(error);
+          if (retry3.onFailedAttempt) {
+            await retry3.onFailedAttempt(error);
           }
           if (error instanceof ApiClientError && typeof error.statusCode === "number" && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429 && error.statusCode !== 408) {
             throw error;
@@ -2505,7 +2567,7 @@ function createLimiter(concurrency) {
     });
   };
 }
-async function retry(fn, options) {
+async function retry2(fn, options) {
   let lastError;
   let delay = 1e3;
   for (let attempt = 1; attempt <= options.retries + 1; attempt++) {
@@ -2545,7 +2607,7 @@ function createLimitPolicy2({
     }
     if (retryOptions) {
       const retryFunc = currentFunc;
-      currentFunc = () => retry(retryFunc, {
+      currentFunc = () => retry2(retryFunc, {
         ...retryOptions,
         onFailedAttempt: async (error) => {
           if (retryOptions.onFailedAttempt) {
@@ -3284,12 +3346,12 @@ function mitt_default(n) {
 var import_rfdc = __toESM(require_rfdc(), 1);
 var import_rfdc2 = __toESM(require_rfdc(), 1);
 var import_rfdc3 = __toESM(require_rfdc(), 1);
-var __defProp4 = Object.defineProperty;
+var __defProp3 = Object.defineProperty;
 var __typeError4 = (msg) => {
   throw TypeError(msg);
 };
-var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp4(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 __defNormalProp3 = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField3 = (obj, key, value) => __defNormalProp3(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __accessCheck4 = (obj, member, msg) => member.has(obj) || __typeError4("Cannot " + msg);
 var __privateGet4 = (obj, member, getter) => (__accessCheck4(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd4 = (obj, member, value) => member.has(obj) ? __typeError4("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
@@ -3366,7 +3428,7 @@ var SignalInstance = class {
   constructor(data, evaluator, onLogMessage) {
     __privateAdd4(this, _evaluator);
     __privateAdd4(this, _onLogMessage);
-    __publicField2(this, "signal");
+    __publicField3(this, "signal");
     this.signal = data;
     __privateSet2(this, _evaluator, evaluator);
     __privateSet2(this, _onLogMessage, onLogMessage);
@@ -3424,7 +3486,7 @@ var ManifestInstance = class {
     onLogMessage = () => {
     }
   }) {
-    __publicField2(this, "data");
+    __publicField3(this, "data");
     __privateAdd4(this, _mf);
     __privateAdd4(this, _signalInstances);
     __privateAdd4(this, _goalEvaluators, []);
@@ -4211,7 +4273,7 @@ var TransitionDataStore = class {
     __privateAdd4(this, _data);
     __privateAdd4(this, _initialData);
     __privateAdd4(this, _mitt, mitt_default());
-    __publicField2(this, "events", {
+    __publicField3(this, "events", {
       on: __privateGet4(this, _mitt).on,
       off: __privateGet4(this, _mitt).off
     });
@@ -4576,8 +4638,8 @@ var LocalStorage = class {
   constructor(partitionKey) {
     this.partitionKey = partitionKey;
     __privateAdd4(this, _LocalStorage_instances);
-    __publicField2(this, "inMemoryFallback", {});
-    __publicField2(this, "hasLocalStorageObject", typeof document !== "undefined" && typeof localStorage !== "undefined");
+    __publicField3(this, "inMemoryFallback", {});
+    __publicField3(this, "hasLocalStorageObject", typeof document !== "undefined" && typeof localStorage !== "undefined");
   }
   get(key) {
     const keyValue = __privateMethod(this, _LocalStorage_instances, key_fn).call(this, key);
@@ -4638,7 +4700,7 @@ var VisitorDataStore = class {
     __privateAdd4(this, _persist);
     __privateAdd4(this, _visitTimeout);
     __privateAdd4(this, _options);
-    __publicField2(this, "events", {
+    __publicField3(this, "events", {
       on: __privateGet4(this, _mitt2).on,
       off: __privateGet4(this, _mitt2).off
     });
@@ -4839,7 +4901,7 @@ var calculateScores_fn;
 var Context = class {
   constructor(options) {
     __privateAdd4(this, _Context_instances);
-    __publicField2(this, "manifest");
+    __publicField3(this, "manifest");
     __privateAdd4(this, _personalizationSelectionAlgorithms);
     __privateAdd4(this, _serverTransitionState);
     __privateAdd4(this, _scores, {});
@@ -4849,11 +4911,11 @@ var Context = class {
     __privateAdd4(this, _commands);
     __privateAdd4(this, _requireConsentForPersonalization);
     __privateAdd4(this, _mitt3, mitt_default());
-    __publicField2(this, "events", {
+    __publicField3(this, "events", {
       on: __privateGet4(this, _mitt3).on,
       off: __privateGet4(this, _mitt3).off
     });
-    __publicField2(this, "storage");
+    __publicField3(this, "storage");
     var _a, _b, _c;
     const { manifest, ...storageOptions } = options;
     __privateSet2(this, _state, {});