@overturo/js 0.0.0-stage → 1.5.1

package/dist/index.js

@@ -0,0 +1,4579 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+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 __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// node_modules/ajv-formats/dist/formats.js
+var require_formats = __commonJS({
+  "node_modules/ajv-formats/dist/formats.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.formatNames = exports.fastFormats = exports.fullFormats = void 0;
+    function fmtDef(validate2, compare) {
+      return { validate: validate2, compare };
+    }
+    exports.fullFormats = {
+      // date: http://tools.ietf.org/html/rfc3339#section-5.6
+      date: fmtDef(date, compareDate),
+      // date-time: http://tools.ietf.org/html/rfc3339#section-5.6
+      time: fmtDef(getTime(true), compareTime),
+      "date-time": fmtDef(getDateTime(true), compareDateTime),
+      "iso-time": fmtDef(getTime(), compareIsoTime),
+      "iso-date-time": fmtDef(getDateTime(), compareIsoDateTime),
+      // duration: https://tools.ietf.org/html/rfc3339#appendix-A
+      duration: /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/,
+      uri,
+      "uri-reference": /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i,
+      // uri-template: https://tools.ietf.org/html/rfc6570
+      "uri-template": /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i,
+      // For the source: https://gist.github.com/dperini/729294
+      // For test cases: https://mathiasbynens.be/demo/url-regex
+      url: /^(?:https?|ftp):\/\/(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)(?:\.(?:[a-z0-9\u{00a1}-\u{ffff}]+-)*[a-z0-9\u{00a1}-\u{ffff}]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu,
+      email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
+      hostname: /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i,
+      // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html
+      ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
+      ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
+      regex,
+      // uuid: http://tools.ietf.org/html/rfc4122
+      uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
+      // JSON-pointer: https://tools.ietf.org/html/rfc6901
+      // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A
+      "json-pointer": /^(?:\/(?:[^~/]|~0|~1)*)*$/,
+      "json-pointer-uri-fragment": /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i,
+      // relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00
+      "relative-json-pointer": /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/,
+      // the following formats are used by the openapi specification: https://spec.openapis.org/oas/v3.0.0#data-types
+      // byte: https://github.com/miguelmota/is-base64
+      byte,
+      // signed 32 bit integer
+      int32: { type: "number", validate: validateInt32 },
+      // signed 64 bit integer
+      int64: { type: "number", validate: validateInt64 },
+      // C-type float
+      float: { type: "number", validate: validateNumber },
+      // C-type double
+      double: { type: "number", validate: validateNumber },
+      // hint to the UI to hide input strings
+      password: true,
+      // unchecked string payload
+      binary: true
+    };
+    exports.fastFormats = {
+      ...exports.fullFormats,
+      date: fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d$/, compareDate),
+      time: fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareTime),
+      "date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i, compareDateTime),
+      "iso-time": fmtDef(/^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoTime),
+      "iso-date-time": fmtDef(/^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i, compareIsoDateTime),
+      // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js
+      uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
+      "uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
+      // email (sources from jsen validator):
+      // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363
+      // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'wilful violation')
+      email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i
+    };
+    exports.formatNames = Object.keys(exports.fullFormats);
+    function isLeapYear(year) {
+      return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    }
+    var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+    var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    function date(str) {
+      const matches = DATE.exec(str);
+      if (!matches)
+        return false;
+      const year = +matches[1];
+      const month = +matches[2];
+      const day = +matches[3];
+      return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]);
+    }
+    function compareDate(d1, d2) {
+      if (!(d1 && d2))
+        return void 0;
+      if (d1 > d2)
+        return 1;
+      if (d1 < d2)
+        return -1;
+      return 0;
+    }
+    var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
+    function getTime(strictTimeZone) {
+      return function time(str) {
+        const matches = TIME.exec(str);
+        if (!matches)
+          return false;
+        const hr = +matches[1];
+        const min = +matches[2];
+        const sec = +matches[3];
+        const tz = matches[4];
+        const tzSign = matches[5] === "-" ? -1 : 1;
+        const tzH = +(matches[6] || 0);
+        const tzM = +(matches[7] || 0);
+        if (tzH > 23 || tzM > 59 || strictTimeZone && !tz)
+          return false;
+        if (hr <= 23 && min <= 59 && sec < 60)
+          return true;
+        const utcMin = min - tzM * tzSign;
+        const utcHr = hr - tzH * tzSign - (utcMin < 0 ? 1 : 0);
+        return (utcHr === 23 || utcHr === -1) && (utcMin === 59 || utcMin === -1) && sec < 61;
+      };
+    }
+    function compareTime(s1, s2) {
+      if (!(s1 && s2))
+        return void 0;
+      const t1 = (/* @__PURE__ */ new Date("2020-01-01T" + s1)).valueOf();
+      const t2 = (/* @__PURE__ */ new Date("2020-01-01T" + s2)).valueOf();
+      if (!(t1 && t2))
+        return void 0;
+      return t1 - t2;
+    }
+    function compareIsoTime(t1, t2) {
+      if (!(t1 && t2))
+        return void 0;
+      const a1 = TIME.exec(t1);
+      const a2 = TIME.exec(t2);
+      if (!(a1 && a2))
+        return void 0;
+      t1 = a1[1] + a1[2] + a1[3];
+      t2 = a2[1] + a2[2] + a2[3];
+      if (t1 > t2)
+        return 1;
+      if (t1 < t2)
+        return -1;
+      return 0;
+    }
+    var DATE_TIME_SEPARATOR = /t|\s/i;
+    function getDateTime(strictTimeZone) {
+      const time = getTime(strictTimeZone);
+      return function date_time(str) {
+        const dateTime = str.split(DATE_TIME_SEPARATOR);
+        return dateTime.length === 2 && date(dateTime[0]) && time(dateTime[1]);
+      };
+    }
+    function compareDateTime(dt1, dt2) {
+      if (!(dt1 && dt2))
+        return void 0;
+      const d1 = new Date(dt1).valueOf();
+      const d2 = new Date(dt2).valueOf();
+      if (!(d1 && d2))
+        return void 0;
+      return d1 - d2;
+    }
+    function compareIsoDateTime(dt1, dt2) {
+      if (!(dt1 && dt2))
+        return void 0;
+      const [d1, t1] = dt1.split(DATE_TIME_SEPARATOR);
+      const [d2, t2] = dt2.split(DATE_TIME_SEPARATOR);
+      const res = compareDate(d1, d2);
+      if (res === void 0)
+        return void 0;
+      return res || compareTime(t1, t2);
+    }
+    var NOT_URI_FRAGMENT = /\/|:/;
+    var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+    function uri(str) {
+      return NOT_URI_FRAGMENT.test(str) && URI.test(str);
+    }
+    var BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
+    function byte(str) {
+      BYTE.lastIndex = 0;
+      return BYTE.test(str);
+    }
+    var MIN_INT32 = -(2 ** 31);
+    var MAX_INT32 = 2 ** 31 - 1;
+    function validateInt32(value) {
+      return Number.isInteger(value) && value <= MAX_INT32 && value >= MIN_INT32;
+    }
+    function validateInt64(value) {
+      return Number.isInteger(value);
+    }
+    function validateNumber() {
+      return true;
+    }
+    var Z_ANCHOR = /[^\\]\\Z/;
+    function regex(str) {
+      if (Z_ANCHOR.test(str))
+        return false;
+      try {
+        new RegExp(str);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+  }
+});
+
+// node_modules/ajv/dist/runtime/ucs2length.js
+var require_ucs2length = __commonJS({
+  "node_modules/ajv/dist/runtime/ucs2length.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function ucs2length(str) {
+      const len = str.length;
+      let length = 0;
+      let pos = 0;
+      let value;
+      while (pos < len) {
+        length++;
+        value = str.charCodeAt(pos++);
+        if (value >= 55296 && value <= 56319 && pos < len) {
+          value = str.charCodeAt(pos);
+          if ((value & 64512) === 56320)
+            pos++;
+        }
+      }
+      return length;
+    }
+    exports.default = ucs2length;
+    ucs2length.code = 'require("ajv/dist/runtime/ucs2length").default';
+  }
+});
+
+// src/constants.ts
+var MESSAGE_TYPES_V2 = {
+  READY: "overturo:ready",
+  STATE: "overturo:state",
+  COMPLETE: "overturo:complete",
+  CANCEL: "overturo:cancel",
+  ERROR: "overturo:error",
+  RESIZE: "overturo:resize",
+  DEADLINE: "overturo:deadline"
+};
+var EMBED_DEFAULTS = {
+  width: "100%",
+  minHeight: "400px",
+  maxHeight: "none",
+  border: "none",
+  borderRadius: "0",
+  background: "transparent"
+};
+var EMBED_STYLE_KEYS = Object.keys(EMBED_DEFAULTS);
+var POPUP_DEFAULTS = {
+  width: 500,
+  height: 700
+};
+var SETUP_MESSAGE_TYPES = {
+  READY: "overturoid:ready",
+  RESIZE: "overturoid:resize",
+  STEP: "overturoid:setup:step",
+  CREATED: "overturoid:setup:created",
+  CANCEL: "overturoid:cancel",
+  ERROR: "overturoid:error",
+  PING: "overturoid:ping",
+  HEARTBEAT: "overturoid:heartbeat"
+};
+var SETUP_POPUP_DEFAULTS = {
+  width: 600,
+  height: 800
+};
+var API_PATH = "/api/v1/consent_sessions";
+var DECISIONS_API_PATH = "/api/v1/decisions";
+var DECISIONS_FLOW_PATH = "/decisions";
+var MEETING_CONSENTS_API_PATH = "/api/v1/meeting_consents";
+var SETUP_API_PATH = "/api/v1/accord_setup_sessions";
+var PREVIEW_TOKENS_PATH = "/api/v1/preview_tokens";
+var DEFAULT_BASE_URL = "https://overturo.com";
+var MESSAGE_PREFIX_V2 = "overturo:";
+function isForeignEnvelope(data) {
+  const type = data?.type;
+  return typeof type === "string" && !type.startsWith(MESSAGE_PREFIX_V2);
+}
+var DEFAULT_TIMEOUT = 3e4;
+var CONSENT_FIELD_ELEMENT_NAME = "overturo-consent-field";
+
+// src/errors.ts
+var OverturoError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OverturoError";
+  }
+};
+var OverturoValidationError = class extends OverturoError {
+  constructor(message) {
+    super(message);
+    this.name = "OverturoValidationError";
+  }
+};
+var OverturoApiError = class extends OverturoError {
+  constructor(message, status, body) {
+    super(message);
+    this.name = "OverturoApiError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var OverturoNetworkError = class extends OverturoError {
+  constructor(message, cause) {
+    super(message);
+    this.name = "OverturoNetworkError";
+    this.cause = cause;
+  }
+};
+var OverturoTimeoutError = class extends OverturoError {
+  constructor(message = "Operation timed out") {
+    super(message);
+    this.name = "OverturoTimeoutError";
+  }
+};
+var OapDenied = class _OapDenied extends OverturoApiError {
+  constructor(envelope, status, body) {
+    super(envelope.message, status, body);
+    this.name = "OapDenied";
+    this.reason_code = envelope.reason_code;
+    this.failed_bound = envelope.failed_bound;
+    this.denial_category = envelope.denial_category;
+    this.cascade_step = envelope.cascade_step;
+    this.detail = envelope.detail;
+  }
+  /**
+   * Build the most-specific subclass for the envelope. Reason-code
+   * dispatch takes precedence over category dispatch so the most
+   * specific subclass wins (sequence denials are
+   * trajectory_denied but get their own subclass).
+   */
+  static fromEnvelope(envelope, status, body) {
+    if (envelope.reason_code === "sequence_prohibited" || envelope.reason_code === "sequence_missing_predecessor") {
+      return new OapSequenceDenied(envelope, status, body);
+    }
+    switch (envelope.denial_category) {
+      case "authorization_denied":
+        return new OapAuthorizationDenied(envelope, status, body);
+      case "intent_denied":
+        return new OapIntentDenied(envelope, status, body);
+      case "trajectory_denied":
+        return new OapTrajectoryDenied(envelope, status, body);
+      default:
+        return new _OapDenied(envelope, status, body);
+    }
+  }
+};
+var OapAuthorizationDenied = class extends OapDenied {
+  constructor(envelope, status, body) {
+    super(envelope, status, body);
+    this.name = "OapAuthorizationDenied";
+  }
+};
+var OapIntentDenied = class extends OapDenied {
+  constructor(envelope, status, body) {
+    super(envelope, status, body);
+    this.name = "OapIntentDenied";
+  }
+};
+var OapTrajectoryDenied = class extends OapDenied {
+  constructor(envelope, status, body) {
+    super(envelope, status, body);
+    this.name = "OapTrajectoryDenied";
+  }
+};
+var OapSequenceDenied = class extends OapTrajectoryDenied {
+  constructor(envelope, status, body) {
+    super(envelope, status, body);
+    this.name = "OapSequenceDenied";
+  }
+};
+
+// src/api.ts
+function extractErrorMessage(body, status) {
+  if (body && typeof body === "object") {
+    const raw = body.error;
+    if (typeof raw === "string" && raw.length > 0) return raw;
+    if (raw && typeof raw === "object") {
+      const inner = raw;
+      if (typeof inner.message === "string" && inner.message.length > 0) {
+        return typeof inner.code === "string" && inner.code.length > 0 ? `${inner.code}: ${inner.message}` : inner.message;
+      }
+      if (inner.errors && typeof inner.errors === "object") {
+        const firstField = Object.keys(inner.errors)[0];
+        if (firstField) {
+          const msgs = inner.errors[firstField];
+          const first = Array.isArray(msgs) ? msgs[0] : msgs;
+          if (typeof first === "string") {
+            const codePrefix = typeof inner.code === "string" && inner.code.length > 0 ? `${inner.code}: ` : "";
+            return `${codePrefix}${firstField} ${first}`;
+          }
+        }
+      }
+      if (typeof inner.code === "string" && inner.code.length > 0) {
+        return inner.code;
+      }
+    }
+    const topMessage = body.message;
+    if (typeof topMessage === "string" && topMessage.length > 0) return topMessage;
+  }
+  return `HTTP ${status}`;
+}
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function toSnakeCase(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(toSnakeCase);
+  }
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[camelToSnake(key)] = toSnakeCase(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function toCamelCase(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(toCamelCase);
+  }
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[snakeToCamel(key)] = toCamelCase(value);
+    }
+    return result;
+  }
+  return obj;
+}
+var ApiClient = class {
+  constructor(options) {
+    this.baseUrl = options.baseUrl;
+    this.publishableKey = options.publishableKey;
+    this.apiKey = options.apiKey;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  /**
+   * GET that returns the raw Response object without JSON parsing, case
+   * conversion or error throwing. Used where part of the body must stay
+   * verbatim (keys that are data, such as purpose names).
+   */
+  async rawGet(path) {
+    return this.rawRequest("GET", path);
+  }
+  /**
+   * POST that returns the raw Response object without JSON parsing or error throwing.
+   * Used by exchange() to handle HTTP 202 (fulfillment pending) with retry logic.
+   */
+  async rawPost(path, body) {
+    return this.rawRequest("POST", path, body);
+  }
+  async rawRequest(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Publishable-Key": this.publishableKey
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const controller = new AbortController();
+    let timeoutId;
+    if (this.timeout > 0) {
+      timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    }
+    try {
+      return await fetch(url, {
+        method,
+        headers,
+        body: body === void 0 ? void 0 : JSON.stringify(toSnakeCase(body)),
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new OverturoTimeoutError(`Request timed out after ${this.timeout}ms`);
+      }
+      throw new OverturoNetworkError("Network request failed", error);
+    } finally {
+      if (timeoutId !== void 0) clearTimeout(timeoutId);
+    }
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Publishable-Key": this.publishableKey
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const controller = new AbortController();
+    let timeoutId;
+    if (this.timeout > 0) {
+      timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    }
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(toSnakeCase(body)) : void 0,
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new OverturoTimeoutError(`Request timed out after ${this.timeout}ms`);
+      }
+      throw new OverturoNetworkError("Network request failed", error);
+    } finally {
+      if (timeoutId !== void 0) clearTimeout(timeoutId);
+    }
+    if (!response.ok) {
+      let responseBody;
+      try {
+        responseBody = await response.json();
+      } catch {
+        responseBody = null;
+      }
+      const message = extractErrorMessage(responseBody, response.status);
+      throw new OverturoApiError(message, response.status, responseBody);
+    }
+    const text = await response.text();
+    if (!text) {
+      return {};
+    }
+    return toCamelCase(JSON.parse(text));
+  }
+};
+
+// src/approvals_facade.ts
+var _decisions, _api;
+var ApprovalsFacade = class {
+  constructor(decisions, api) {
+    __privateAdd(this, _decisions);
+    __privateAdd(this, _api);
+    __privateSet(this, _decisions, decisions);
+    __privateSet(this, _api, api);
+  }
+  async open(opts) {
+    if (!opts.escalationId) {
+      throw new OverturoValidationError("escalationId is required");
+    }
+    const mode = opts.mode ?? "embed";
+    const session = await __privateGet(this, _decisions).createSession({
+      kind: "approval",
+      subjectRef: opts.escalationId,
+      mode,
+      embedOrigin: opts.embedOrigin,
+      state: opts.state,
+      redirectUri: opts.redirectUri
+    });
+    if (mode === "popup") {
+      return __privateGet(this, _decisions).popup({
+        token: session.token,
+        onComplete: (outcome) => {
+          if (outcome.kind === "approval") opts.onComplete?.(outcome);
+        },
+        onCancel: opts.onCancel,
+        onError: opts.onError
+      });
+    }
+    if (mode === "redirect") {
+      const url = __privateGet(this, _decisions).url({ token: session.token, mode: "redirect" });
+      window.location.href = url;
+      return {
+        token: session.token,
+        mode: "redirect",
+        destroy: async () => {
+        }
+      };
+    }
+    return __privateGet(this, _decisions).embed({
+      token: session.token,
+      container: opts.container,
+      style: opts.style,
+      loading: opts.loading,
+      onReady: opts.onReady,
+      onState: (_kind, payload) => opts.onState?.(payload),
+      onComplete: (outcome) => {
+        if (outcome.kind === "approval") opts.onComplete?.(outcome);
+      },
+      onCancel: opts.onCancel,
+      onError: opts.onError,
+      onDeadline: opts.onDeadline,
+      onCounter: opts.onCounter
+    });
+  }
+  url(opts) {
+    return __privateGet(this, _decisions).url({
+      token: opts.escalationId,
+      mode: opts.mode
+    });
+  }
+  /**
+   * Polls `${decisions_api}/:token` for deadline metadata. Returns the
+   * computed remainingMs alongside the absolute deadlineAt for clock-
+   * skew tolerance in consumers.
+   */
+  async deadline(token) {
+    if (!token) {
+      throw new OverturoValidationError("token is required for deadline");
+    }
+    const status = await __privateGet(this, _api).get(`${DECISIONS_API_PATH}/${token}`);
+    return {
+      remainingMs: Math.max(0, new Date(status.deadlineAt).getTime() - Date.now()),
+      deadlineAt: status.deadlineAt
+    };
+  }
+};
+_decisions = new WeakMap();
+_api = new WeakMap();
+
+// src/consent_facade.ts
+var _decisions2;
+var ConsentFacade = class {
+  constructor(decisions) {
+    __privateAdd(this, _decisions2);
+    __privateSet(this, _decisions2, decisions);
+  }
+  /**
+   * Creates a consent session and mounts the iframe in one call.
+   * Bridges v0's `onStep(payload)` to v1's `onState(kind, payload)`
+   * so existing call sites keep working with a single rename.
+   */
+  async open(opts) {
+    if (!opts.flowId) {
+      throw new OverturoValidationError("flowId is required");
+    }
+    const mode = opts.mode ?? "embed";
+    const session = await __privateGet(this, _decisions2).createSession({
+      kind: "consent",
+      subjectRef: opts.flowId,
+      mode,
+      embedOrigin: opts.embedOrigin,
+      scope: opts.scope,
+      state: opts.state,
+      nonce: opts.nonce,
+      redirectUri: opts.redirectUri
+    });
+    if (mode === "popup") {
+      return __privateGet(this, _decisions2).popup({
+        token: session.token,
+        onComplete: (outcome) => {
+          if (outcome.kind === "consent") opts.onComplete?.(outcome);
+        },
+        onCancel: opts.onCancel,
+        onError: opts.onError
+      });
+    }
+    if (mode === "redirect") {
+      const url = __privateGet(this, _decisions2).url({ token: session.token, mode: "redirect" });
+      window.location.href = url;
+      return {
+        token: session.token,
+        mode: "redirect",
+        destroy: async () => {
+        }
+      };
+    }
+    return __privateGet(this, _decisions2).embed({
+      token: session.token,
+      container: opts.container,
+      style: opts.style,
+      loading: opts.loading,
+      onReady: opts.onReady,
+      onState: (_kind, payload) => opts.onStep?.(payload),
+      onComplete: (outcome) => {
+        if (outcome.kind === "consent") opts.onComplete?.(outcome);
+      },
+      onCancel: opts.onCancel,
+      onError: opts.onError
+    });
+  }
+  url(opts) {
+    return __privateGet(this, _decisions2).url({
+      token: opts.flowId,
+      mode: opts.mode
+    });
+  }
+  /**
+   * pre-flight disclosure discovery. Thin delegate to
+   * `decisions.discover` so the kind facades stay symmetric.
+   */
+  discover(opts) {
+    return __privateGet(this, _decisions2).discover(opts);
+  }
+};
+_decisions2 = new WeakMap();
+
+// src/forms/intercept.ts
+var DEFAULT_TOKEN_FIELD = "overturo_capture_token";
+var CAPTURED_MARK = "overturoCaptured";
+var CAPTURE_TIMEOUT_MS = 5e3;
+var attached = /* @__PURE__ */ new WeakMap();
+function interceptSubmit(form, opts, run) {
+  if (attached.has(form)) {
+    throw new OverturoValidationError("duplicate_attach: this form already has a capture interception; detach it before attaching again");
+  }
+  attached.set(form, true);
+  let inFlight = false;
+  const tokenField = opts.tokenFieldName ?? DEFAULT_TOKEN_FIELD;
+  const handler = (ev) => {
+    if (form.dataset[CAPTURED_MARK] === "1") {
+      delete form.dataset[CAPTURED_MARK];
+      return;
+    }
+    ev.preventDefault();
+    ev.stopImmediatePropagation();
+    if (inFlight) return;
+    inFlight = true;
+    form.querySelector(`input[name="${tokenField}"]`)?.remove();
+    const submitter = ev.submitter ?? null;
+    void (async () => {
+      try {
+        const { token } = await withTimeout(run({ submitter }), CAPTURE_TIMEOUT_MS);
+        setHiddenInput(form, tokenField, token);
+      } catch (e) {
+        opts.onError?.(e);
+      } finally {
+        inFlight = false;
+        if (opts.submitAfterCapture !== false) {
+          form.dataset[CAPTURED_MARK] = "1";
+          resubmit(form, submitter);
+        }
+      }
+    })();
+  };
+  form.addEventListener("submit", handler, { capture: true });
+  return () => {
+    attached.delete(form);
+    form.removeEventListener("submit", handler, { capture: true });
+    delete form.dataset[CAPTURED_MARK];
+    form.querySelector(`input[name="${tokenField}"]`)?.remove();
+  };
+}
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new OverturoValidationError(`capture timed out after ${ms} ms; the form submits without a capture token`)),
+      ms
+    );
+    promise.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve(v);
+      },
+      (e) => {
+        clearTimeout(timer);
+        reject(e);
+      }
+    );
+  });
+}
+function resubmit(form, submitter) {
+  if (submitter && submitter.isConnected && typeof form.requestSubmit === "function") {
+    try {
+      form.requestSubmit(submitter);
+      return;
+    } catch {
+    }
+  }
+  if (typeof form.requestSubmit === "function") form.requestSubmit();
+  else if (submitter && typeof submitter.click === "function") submitter.click();
+  else form.submit();
+}
+function resolveForm(form) {
+  const el = typeof form === "string" ? document.querySelector(form) : form;
+  if (!(el instanceof HTMLFormElement)) throw new OverturoValidationError("form must resolve to a <form> element");
+  return el;
+}
+function setHiddenInput(form, name, value) {
+  let input = form.querySelector(`input[name="${name}"]`);
+  if (!input) {
+    input = document.createElement("input");
+    input.type = "hidden";
+    input.name = name;
+    form.appendChild(input);
+  }
+  input.value = value;
+}
+
+// src/forms/presentation.ts
+function resolveControl(root, selector) {
+  const el = root.querySelector(selector);
+  return el instanceof HTMLInputElement ? el : null;
+}
+function presentationFor(control, initiallyChecked) {
+  if (!control || control.type !== "checkbox" && control.type !== "radio") {
+    return { decision: "declined", default_checked: false, mandatory: false };
+  }
+  return {
+    decision: control.checked ? "granted" : "declined",
+    // Shown ticked by default: the HTML attribute, or a script that ticked it before the person saw it.
+    default_checked: control.defaultChecked || initiallyChecked === true,
+    mandatory: mandatoryFor(control)
+  };
+}
+function mandatoryFor(control) {
+  if (!control.required) return false;
+  if (control.type !== "radio" || !control.name) return true;
+  const root = control.form ?? control.ownerDocument;
+  const group = Array.from(root.querySelectorAll('input[type="radio"]')).filter((r) => r.name === control.name);
+  return group.length <= 1;
+}
+function decisionsFor(form, map, initiallyChecked = {}) {
+  const out = {};
+  for (const [purpose, selector] of Object.entries(map)) {
+    out[purpose] = presentationFor(resolveControl(form, selector), initiallyChecked[purpose]);
+  }
+  return out;
+}
+
+// src/forms/snapshot.ts
+var SNAPSHOT_MAX_BYTES = 16 * 1024;
+var VALUE_BEARING = "input, textarea, select";
+var EVENT_ATTR = /^on/i;
+var FREE_TEXT_ATTRS = /* @__PURE__ */ new Set(["title", "aria-label", "aria-description"]);
+function sanitisedSnapshot(form, consentSelectors) {
+  const clone = form.cloneNode(true);
+  const keep = /* @__PURE__ */ new Set();
+  for (const selector of consentSelectors) {
+    const el = clone.querySelector(selector);
+    if (el) keep.add(el);
+  }
+  clone.querySelectorAll("script, style, iframe, object, embed").forEach((el) => el.remove());
+  [clone, ...Array.from(clone.querySelectorAll("*"))].forEach((el) => {
+    for (const attr of Array.from(el.attributes)) {
+      const name = attr.name.toLowerCase();
+      if (EVENT_ATTR.test(name) || name === "srcdoc" || name.startsWith("data-") || FREE_TEXT_ATTRS.has(name)) {
+        el.removeAttribute(attr.name);
+      }
+    }
+  });
+  clone.querySelectorAll(VALUE_BEARING).forEach((node) => {
+    const el = node;
+    if (keep.has(el)) {
+      const input = el;
+      if (input.checked) input.setAttribute("checked", "");
+      else input.removeAttribute("checked");
+      el.removeAttribute("value");
+      return;
+    }
+    el.removeAttribute("value");
+    el.removeAttribute("placeholder");
+    if (el instanceof HTMLTextAreaElement) el.textContent = "";
+    if (el instanceof HTMLSelectElement) {
+      el.querySelectorAll("option").forEach((o) => {
+        o.removeAttribute("selected");
+        o.removeAttribute("value");
+      });
+    }
+    if (el instanceof HTMLInputElement) {
+      el.removeAttribute("checked");
+      if (el.type === "hidden") el.remove();
+    }
+  });
+  const html = clone.outerHTML;
+  return truncateUtf8(html, SNAPSHOT_MAX_BYTES);
+}
+function truncateUtf8(text, maxBytes) {
+  const encoder = new TextEncoder();
+  if (encoder.encode(text).byteLength <= maxBytes) return text;
+  let out = text;
+  while (encoder.encode(out).byteLength > maxBytes) {
+    out = out.slice(0, Math.floor(out.length * 0.9));
+  }
+  return out;
+}
+
+// src/forms.ts
+var CAPTURE_PATH = "/api/v1/decisions/capture";
+var FormsFacade = class {
+  constructor(api, decisions, flowBaseUrl, publishableKey) {
+    this.api = api;
+    this.decisions = decisions;
+    this.flowBaseUrl = flowBaseUrl;
+    this.publishableKey = publishableKey;
+  }
+  /** Wires the capture onto the form; returns a detach function. */
+  attach(opts) {
+    if (!opts.flowId) throw new OverturoValidationError("flowId is required");
+    const form = resolveForm(opts.form);
+    if (opts.field) return this.attachField(form, opts);
+    const map = opts.map;
+    if (!map || Object.keys(map).length === 0) throw new OverturoValidationError("map must name at least one purpose (or pass field)");
+    const initiallyChecked = initialCheckedState(form, map);
+    if (opts.wording) void this.writeWording(form, opts);
+    return interceptSubmit(form, opts, async () => {
+      const unresolved = Object.entries(map).filter(([, selector]) => !resolveControl(form, selector));
+      if (unresolved.length) {
+        throw new OverturoValidationError(`consent control not found for: ${unresolved.map(([p]) => p).join(", ")}`);
+      }
+      const body = this.buildCaptureBody(form, opts, initiallyChecked);
+      const digests = await this.labelDigests(form, opts);
+      if (digests) body.noticeHashes = digests;
+      const raw = await this.api.post(CAPTURE_PATH, body);
+      const result = {
+        token: raw.capture.sessionToken,
+        attestationId: raw.capture.attestationId,
+        committed: raw.capture.committed,
+        wordingVerdict: raw.capture.wordingVerdict ?? null,
+        recordId: raw.capture.recordId ?? null
+      };
+      opts.onCaptured?.(result);
+      return { token: result.token };
+    });
+  }
+  /**
+   * 202 D9 — the embedded consent field: the control is Overturo-rendered
+   * inside the form, so the element does the capture from its own frame. The
+   * field entry (`@overturo/js/field` / `overturo-field.js`) must be loaded;
+   * one field per flow per form.
+   */
+  attachField(form, opts) {
+    const element = resolveField(form, opts.field);
+    const flow = element.getAttribute("flow");
+    if (flow && flow !== opts.flowId) throw new OverturoValidationError("the field's flow attribute must match flowId");
+    const duplicate = Array.from(form.querySelectorAll(CONSENT_FIELD_ELEMENT_NAME)).some(
+      (el) => el !== element && (el.getAttribute("flow") || opts.flowId) === opts.flowId
+    );
+    if (duplicate) throw new OverturoValidationError("duplicate_field: one consent field per flow per form");
+    return element.attachTo(form, opts, { flowBaseUrl: this.flowBaseUrl, publishableKey: this.publishableKey });
+  }
+  /** Builds the capture body the way `attach` does — exposed for integrators who post themselves. */
+  buildCaptureBody(form, opts, initiallyChecked = {}) {
+    const subject = resolveControl(form, opts.subjectField);
+    const external = opts.externalIdField ? resolveControl(form, opts.externalIdField) : null;
+    const map = opts.map ?? {};
+    const body = {
+      flowId: opts.flowId,
+      decisions: decisionsFor(form, map, initiallyChecked),
+      subject: {
+        email: subject?.value?.trim() || void 0,
+        externalId: external?.value?.trim() || void 0
+      },
+      snapshot: sanitisedSnapshot(form, Object.values(map)),
+      pageUrl: typeof window !== "undefined" ? window.location.href : void 0,
+      formId: form.getAttribute("id") || void 0
+    };
+    if (opts.commit) body.commit = true;
+    if (opts.locale) body.locale = opts.locale;
+    return body;
+  }
+  /**
+   * 201 D11 — the digest of each mapped label's text as the person saw it
+   * (a 256-bit digest of the trimmed text — the algorithm the forms
+   * documentation publishes), so the record can
+   * say whether the form's wording matched the wording published for the flow.
+   * Needs `labels` (purpose → label selector) and WebCrypto; otherwise nothing is attested.
+   */
+  async labelDigests(form, opts) {
+    const labels = opts.labels ?? opts.wording;
+    if (!labels || typeof crypto === "undefined" || !crypto.subtle) return void 0;
+    const out = {};
+    for (const [purpose, selector] of Object.entries(labels)) {
+      const text = form.querySelector(selector)?.textContent?.trim();
+      if (!text) continue;
+      const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+      out[purpose] = Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    return Object.keys(out).length ? out : void 0;
+  }
+  /** 201 D11 — writes the published wording into the labels the integrator names. */
+  async writeWording(form, opts) {
+    if (!opts.wording) return;
+    try {
+      const disclosures = await this.decisions.discover({ flowId: opts.flowId, locale: opts.locale });
+      for (const [purpose, selector] of Object.entries(opts.wording)) {
+        const target = form.querySelector(selector);
+        const row = disclosures.purposes.find((p) => p.name === purpose);
+        if (target && row) replaceText(target, row.description ?? row.label);
+      }
+    } catch (e) {
+      opts.onError?.(e);
+    }
+  }
+};
+function replaceText(target, text) {
+  const textNodes = Array.from(target.childNodes).filter((n) => n.nodeType === Node.TEXT_NODE);
+  if (textNodes.length === 0 || target.children.length === 0) {
+    if (target.children.length === 0) target.textContent = text;
+    else target.appendChild(document.createTextNode(" " + text));
+    return;
+  }
+  textNodes.forEach((n, i) => {
+    n.textContent = i === 0 ? text : "";
+  });
+}
+function initialCheckedState(form, map) {
+  const out = {};
+  for (const [purpose, selector] of Object.entries(map)) {
+    const control = resolveControl(form, selector);
+    if (control) out[purpose] = control.checked;
+  }
+  return out;
+}
+function resolveField(form, field) {
+  const el = typeof field === "string" ? form.querySelector(field) || document.querySelector(field) : field;
+  if (!(el instanceof HTMLElement) || el.tagName.toLowerCase() !== CONSENT_FIELD_ELEMENT_NAME) {
+    throw new OverturoValidationError(`field must resolve to an <${CONSENT_FIELD_ELEMENT_NAME}> element`);
+  }
+  if (typeof el.attachTo !== "function") {
+    throw new OverturoValidationError("field_entry_not_loaded: load @overturo/js/field (overturo-field.js) before attaching a field");
+  }
+  return el;
+}
+
+// src/signing_facade.ts
+var _decisions3, _api2;
+var SigningFacade = class {
+  constructor(decisions, api) {
+    __privateAdd(this, _decisions3);
+    __privateAdd(this, _api2);
+    __privateSet(this, _decisions3, decisions);
+    __privateSet(this, _api2, api);
+  }
+  async open(opts) {
+    if (!opts.signatureRef) {
+      throw new OverturoValidationError("signatureRef is required");
+    }
+    const mode = opts.mode ?? "embed";
+    const session = await __privateGet(this, _decisions3).createSession({
+      kind: "signature_request",
+      subjectRef: opts.signatureRef,
+      mode,
+      embedOrigin: opts.embedOrigin,
+      state: opts.state,
+      redirectUri: opts.redirectUri
+    });
+    if (mode === "popup") {
+      return __privateGet(this, _decisions3).popup({
+        token: session.token,
+        onComplete: (outcome) => {
+          if (outcome.kind === "signature_request") opts.onComplete?.(outcome);
+        },
+        onCancel: opts.onCancel,
+        onError: opts.onError
+      });
+    }
+    if (mode === "redirect") {
+      const url = __privateGet(this, _decisions3).url({ token: session.token, mode: "redirect" });
+      window.location.href = url;
+      return {
+        token: session.token,
+        mode: "redirect",
+        destroy: async () => {
+        }
+      };
+    }
+    return __privateGet(this, _decisions3).embed({
+      token: session.token,
+      container: opts.container,
+      style: opts.style,
+      loading: opts.loading,
+      onReady: opts.onReady,
+      onState: (_kind, payload) => opts.onState?.(payload),
+      onComplete: (outcome) => {
+        if (outcome.kind === "signature_request") opts.onComplete?.(outcome);
+      },
+      onCancel: opts.onCancel,
+      onError: opts.onError,
+      onDeadline: opts.onDeadline,
+      onCounter: opts.onCounter
+    });
+  }
+  url(opts) {
+    return __privateGet(this, _decisions3).url({
+      token: opts.signatureRef,
+      mode: opts.mode
+    });
+  }
+  /**
+   * Polls `${decisions_api}/:token` for deadline metadata. Returns the
+   * computed remainingMs alongside the absolute deadlineAt for clock-
+   * skew tolerance in consumers.
+   */
+  async deadline(token) {
+    if (!token) {
+      throw new OverturoValidationError("token is required for deadline");
+    }
+    const status = await __privateGet(this, _api2).get(`${DECISIONS_API_PATH}/${token}`);
+    return {
+      remainingMs: Math.max(0, new Date(status.deadlineAt).getTime() - Date.now()),
+      deadlineAt: status.deadlineAt
+    };
+  }
+};
+_decisions3 = new WeakMap();
+_api2 = new WeakMap();
+
+// src/dom.ts
+function resolveContainer(container) {
+  if (typeof container === "string") {
+    const el = document.querySelector(container);
+    if (!el) {
+      throw new OverturoValidationError(`Container element not found: "${container}"`);
+    }
+    return el;
+  }
+  return container;
+}
+function applyStyle(el, defaults, overrides) {
+  const style = { ...defaults };
+  if (overrides) {
+    for (const key of EMBED_STYLE_KEYS) {
+      if (key in overrides) {
+        style[key] = overrides[key];
+      }
+    }
+  }
+  for (const [key, value] of Object.entries(style)) {
+    ;
+    el.style[key] = value;
+  }
+}
+
+// src/generated/postmessage-v2/envelope.js
+var envelope_default = validate29;
+var schema40 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/envelope.json", "title": "TrustSurface postMessage envelope v2", "type": "object", "additionalProperties": false, "required": ["type", "kind", "version", "payload", "ts", "message_id"], "properties": { "type": { "type": "string", "enum": ["overturo:ready", "overturo:state", "overturo:complete", "overturo:cancel", "overturo:error", "overturo:resize", "overturo:deadline"] }, "kind": { "type": "string", "enum": ["consent", "approval", "signature_request"] }, "version": { "type": "integer", "const": 2 }, "payload": { "type": "object", "additionalProperties": true }, "ts": { "type": "string", "format": "date-time" }, "message_id": { "type": "string", "pattern": "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$" } } };
+var formats0 = require_formats().fullFormats["date-time"];
+var pattern4 = new RegExp("^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$", "u");
+function validate29(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate29.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.type === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.kind === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "kind" }, message: "must have required property 'kind'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.version === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "version" }, message: "must have required property 'version'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.payload === void 0) {
+      const err3 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "payload" }, message: "must have required property 'payload'" };
+      if (vErrors === null) {
+        vErrors = [err3];
+      } else {
+        vErrors.push(err3);
+      }
+      errors++;
+    }
+    if (data.ts === void 0) {
+      const err4 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "ts" }, message: "must have required property 'ts'" };
+      if (vErrors === null) {
+        vErrors = [err4];
+      } else {
+        vErrors.push(err4);
+      }
+      errors++;
+    }
+    if (data.message_id === void 0) {
+      const err5 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "message_id" }, message: "must have required property 'message_id'" };
+      if (vErrors === null) {
+        vErrors = [err5];
+      } else {
+        vErrors.push(err5);
+      }
+      errors++;
+    }
+    for (const key0 in data) {
+      if (!(key0 === "type" || key0 === "kind" || key0 === "version" || key0 === "payload" || key0 === "ts" || key0 === "message_id")) {
+        const err6 = { instancePath, schemaPath: "#/additionalProperties", keyword: "additionalProperties", params: { additionalProperty: key0 }, message: "must NOT have additional properties" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+    }
+    if (data.type !== void 0) {
+      let data0 = data.type;
+      if (typeof data0 !== "string") {
+        const err7 = { instancePath: instancePath + "/type", schemaPath: "#/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err7];
+        } else {
+          vErrors.push(err7);
+        }
+        errors++;
+      }
+      if (!(data0 === "overturo:ready" || data0 === "overturo:state" || data0 === "overturo:complete" || data0 === "overturo:cancel" || data0 === "overturo:error" || data0 === "overturo:resize" || data0 === "overturo:deadline")) {
+        const err8 = { instancePath: instancePath + "/type", schemaPath: "#/properties/type/enum", keyword: "enum", params: { allowedValues: schema40.properties.type.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+    if (data.kind !== void 0) {
+      let data1 = data.kind;
+      if (typeof data1 !== "string") {
+        const err9 = { instancePath: instancePath + "/kind", schemaPath: "#/properties/kind/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err9];
+        } else {
+          vErrors.push(err9);
+        }
+        errors++;
+      }
+      if (!(data1 === "consent" || data1 === "approval" || data1 === "signature_request")) {
+        const err10 = { instancePath: instancePath + "/kind", schemaPath: "#/properties/kind/enum", keyword: "enum", params: { allowedValues: schema40.properties.kind.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err10];
+        } else {
+          vErrors.push(err10);
+        }
+        errors++;
+      }
+    }
+    if (data.version !== void 0) {
+      let data2 = data.version;
+      if (!(typeof data2 == "number" && (!(data2 % 1) && !isNaN(data2)))) {
+        const err11 = { instancePath: instancePath + "/version", schemaPath: "#/properties/version/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+        if (vErrors === null) {
+          vErrors = [err11];
+        } else {
+          vErrors.push(err11);
+        }
+        errors++;
+      }
+      if (2 !== data2) {
+        const err12 = { instancePath: instancePath + "/version", schemaPath: "#/properties/version/const", keyword: "const", params: { allowedValue: 2 }, message: "must be equal to constant" };
+        if (vErrors === null) {
+          vErrors = [err12];
+        } else {
+          vErrors.push(err12);
+        }
+        errors++;
+      }
+    }
+    if (data.payload !== void 0) {
+      let data3 = data.payload;
+      if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
+      } else {
+        const err13 = { instancePath: instancePath + "/payload", schemaPath: "#/properties/payload/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err13];
+        } else {
+          vErrors.push(err13);
+        }
+        errors++;
+      }
+    }
+    if (data.ts !== void 0) {
+      let data4 = data.ts;
+      if (typeof data4 === "string") {
+        if (!formats0.validate(data4)) {
+          const err14 = { instancePath: instancePath + "/ts", schemaPath: "#/properties/ts/format", keyword: "format", params: { format: "date-time" }, message: 'must match format "date-time"' };
+          if (vErrors === null) {
+            vErrors = [err14];
+          } else {
+            vErrors.push(err14);
+          }
+          errors++;
+        }
+      } else {
+        const err15 = { instancePath: instancePath + "/ts", schemaPath: "#/properties/ts/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err15];
+        } else {
+          vErrors.push(err15);
+        }
+        errors++;
+      }
+    }
+    if (data.message_id !== void 0) {
+      let data5 = data.message_id;
+      if (typeof data5 === "string") {
+        if (!pattern4.test(data5)) {
+          const err16 = { instancePath: instancePath + "/message_id", schemaPath: "#/properties/message_id/pattern", keyword: "pattern", params: { pattern: "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$" }, message: 'must match pattern "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"' };
+          if (vErrors === null) {
+            vErrors = [err16];
+          } else {
+            vErrors.push(err16);
+          }
+          errors++;
+        }
+      } else {
+        const err17 = { instancePath: instancePath + "/message_id", schemaPath: "#/properties/message_id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err17];
+        } else {
+          vErrors.push(err17);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err18 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err18];
+    } else {
+      vErrors.push(err18);
+    }
+    errors++;
+  }
+  validate29.errors = vErrors;
+  return errors === 0;
+}
+validate29.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/ready.js
+var ready_default = validate30;
+var schema41 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/ready.json", "title": "READY payload (kind-agnostic; branding fields vary per application)", "type": "object", "additionalProperties": true, "required": ["kind", "session_token", "deadline_at", "branding", "mode", "locale"], "properties": { "kind": { "type": "string", "enum": ["consent", "approval", "signature_request"] }, "session_token": { "type": "string", "minLength": 43, "maxLength": 43 }, "deadline_at": { "type": ["string", "null"], "format": "date-time" }, "branding": { "type": "object", "additionalProperties": true, "required": ["application_name"], "properties": { "application_name": { "type": "string" }, "logo_url": { "type": ["string", "null"] }, "primary_color": { "type": ["string", "null"] } } }, "mode": { "type": "string", "enum": ["embed", "popup", "redirect"] }, "locale": { "type": "string" } } };
+var func1 = require_ucs2length().default;
+var formats02 = require_formats().fullFormats["date-time"];
+function validate30(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate30.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.kind === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "kind" }, message: "must have required property 'kind'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.session_token === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "session_token" }, message: "must have required property 'session_token'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.deadline_at === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "deadline_at" }, message: "must have required property 'deadline_at'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.branding === void 0) {
+      const err3 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "branding" }, message: "must have required property 'branding'" };
+      if (vErrors === null) {
+        vErrors = [err3];
+      } else {
+        vErrors.push(err3);
+      }
+      errors++;
+    }
+    if (data.mode === void 0) {
+      const err4 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "mode" }, message: "must have required property 'mode'" };
+      if (vErrors === null) {
+        vErrors = [err4];
+      } else {
+        vErrors.push(err4);
+      }
+      errors++;
+    }
+    if (data.locale === void 0) {
+      const err5 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "locale" }, message: "must have required property 'locale'" };
+      if (vErrors === null) {
+        vErrors = [err5];
+      } else {
+        vErrors.push(err5);
+      }
+      errors++;
+    }
+    if (data.kind !== void 0) {
+      let data0 = data.kind;
+      if (typeof data0 !== "string") {
+        const err6 = { instancePath: instancePath + "/kind", schemaPath: "#/properties/kind/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+      if (!(data0 === "consent" || data0 === "approval" || data0 === "signature_request")) {
+        const err7 = { instancePath: instancePath + "/kind", schemaPath: "#/properties/kind/enum", keyword: "enum", params: { allowedValues: schema41.properties.kind.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err7];
+        } else {
+          vErrors.push(err7);
+        }
+        errors++;
+      }
+    }
+    if (data.session_token !== void 0) {
+      let data1 = data.session_token;
+      if (typeof data1 === "string") {
+        if (func1(data1) > 43) {
+          const err8 = { instancePath: instancePath + "/session_token", schemaPath: "#/properties/session_token/maxLength", keyword: "maxLength", params: { limit: 43 }, message: "must NOT have more than 43 characters" };
+          if (vErrors === null) {
+            vErrors = [err8];
+          } else {
+            vErrors.push(err8);
+          }
+          errors++;
+        }
+        if (func1(data1) < 43) {
+          const err9 = { instancePath: instancePath + "/session_token", schemaPath: "#/properties/session_token/minLength", keyword: "minLength", params: { limit: 43 }, message: "must NOT have fewer than 43 characters" };
+          if (vErrors === null) {
+            vErrors = [err9];
+          } else {
+            vErrors.push(err9);
+          }
+          errors++;
+        }
+      } else {
+        const err10 = { instancePath: instancePath + "/session_token", schemaPath: "#/properties/session_token/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err10];
+        } else {
+          vErrors.push(err10);
+        }
+        errors++;
+      }
+    }
+    if (data.deadline_at !== void 0) {
+      let data2 = data.deadline_at;
+      if (typeof data2 !== "string" && data2 !== null) {
+        const err11 = { instancePath: instancePath + "/deadline_at", schemaPath: "#/properties/deadline_at/type", keyword: "type", params: { type: schema41.properties.deadline_at.type }, message: "must be string,null" };
+        if (vErrors === null) {
+          vErrors = [err11];
+        } else {
+          vErrors.push(err11);
+        }
+        errors++;
+      }
+      if (typeof data2 === "string") {
+        if (!formats02.validate(data2)) {
+          const err12 = { instancePath: instancePath + "/deadline_at", schemaPath: "#/properties/deadline_at/format", keyword: "format", params: { format: "date-time" }, message: 'must match format "date-time"' };
+          if (vErrors === null) {
+            vErrors = [err12];
+          } else {
+            vErrors.push(err12);
+          }
+          errors++;
+        }
+      }
+    }
+    if (data.branding !== void 0) {
+      let data3 = data.branding;
+      if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
+        if (data3.application_name === void 0) {
+          const err13 = { instancePath: instancePath + "/branding", schemaPath: "#/properties/branding/required", keyword: "required", params: { missingProperty: "application_name" }, message: "must have required property 'application_name'" };
+          if (vErrors === null) {
+            vErrors = [err13];
+          } else {
+            vErrors.push(err13);
+          }
+          errors++;
+        }
+        if (data3.application_name !== void 0) {
+          if (typeof data3.application_name !== "string") {
+            const err14 = { instancePath: instancePath + "/branding/application_name", schemaPath: "#/properties/branding/properties/application_name/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err14];
+            } else {
+              vErrors.push(err14);
+            }
+            errors++;
+          }
+        }
+        if (data3.logo_url !== void 0) {
+          let data5 = data3.logo_url;
+          if (typeof data5 !== "string" && data5 !== null) {
+            const err15 = { instancePath: instancePath + "/branding/logo_url", schemaPath: "#/properties/branding/properties/logo_url/type", keyword: "type", params: { type: schema41.properties.branding.properties.logo_url.type }, message: "must be string,null" };
+            if (vErrors === null) {
+              vErrors = [err15];
+            } else {
+              vErrors.push(err15);
+            }
+            errors++;
+          }
+        }
+        if (data3.primary_color !== void 0) {
+          let data6 = data3.primary_color;
+          if (typeof data6 !== "string" && data6 !== null) {
+            const err16 = { instancePath: instancePath + "/branding/primary_color", schemaPath: "#/properties/branding/properties/primary_color/type", keyword: "type", params: { type: schema41.properties.branding.properties.primary_color.type }, message: "must be string,null" };
+            if (vErrors === null) {
+              vErrors = [err16];
+            } else {
+              vErrors.push(err16);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err17 = { instancePath: instancePath + "/branding", schemaPath: "#/properties/branding/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err17];
+        } else {
+          vErrors.push(err17);
+        }
+        errors++;
+      }
+    }
+    if (data.mode !== void 0) {
+      let data7 = data.mode;
+      if (typeof data7 !== "string") {
+        const err18 = { instancePath: instancePath + "/mode", schemaPath: "#/properties/mode/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err18];
+        } else {
+          vErrors.push(err18);
+        }
+        errors++;
+      }
+      if (!(data7 === "embed" || data7 === "popup" || data7 === "redirect")) {
+        const err19 = { instancePath: instancePath + "/mode", schemaPath: "#/properties/mode/enum", keyword: "enum", params: { allowedValues: schema41.properties.mode.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err19];
+        } else {
+          vErrors.push(err19);
+        }
+        errors++;
+      }
+    }
+    if (data.locale !== void 0) {
+      if (typeof data.locale !== "string") {
+        const err20 = { instancePath: instancePath + "/locale", schemaPath: "#/properties/locale/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err20];
+        } else {
+          vErrors.push(err20);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err21 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err21];
+    } else {
+      vErrors.push(err21);
+    }
+    errors++;
+  }
+  validate30.errors = vErrors;
+  return errors === 0;
+}
+validate30.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/resize.js
+var resize_default = validate31;
+function validate31(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate31.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.height === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "height" }, message: "must have required property 'height'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.height !== void 0) {
+      let data0 = data.height;
+      if (!(typeof data0 == "number" && (!(data0 % 1) && !isNaN(data0)))) {
+        const err1 = { instancePath: instancePath + "/height", schemaPath: "#/properties/height/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+        if (vErrors === null) {
+          vErrors = [err1];
+        } else {
+          vErrors.push(err1);
+        }
+        errors++;
+      }
+      if (typeof data0 == "number") {
+        if (data0 < 0 || isNaN(data0)) {
+          const err2 = { instancePath: instancePath + "/height", schemaPath: "#/properties/height/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+          if (vErrors === null) {
+            vErrors = [err2];
+          } else {
+            vErrors.push(err2);
+          }
+          errors++;
+        }
+      }
+    }
+  } else {
+    const err3 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err3];
+    } else {
+      vErrors.push(err3);
+    }
+    errors++;
+  }
+  validate31.errors = vErrors;
+  return errors === 0;
+}
+validate31.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/cancel.js
+var cancel_default = validate24;
+var schema35 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/cancel.json", "title": "CANCEL payload (kind-agnostic \u2014 bidirectional)", "type": "object", "additionalProperties": true, "required": ["reason", "cancelled_by"], "properties": { "reason": { "type": "string", "enum": ["user_declined", "principal_navigated_away", "host_requested", "system_revoked"] }, "cancelled_by": { "type": "string", "enum": ["principal", "host", "system"] } } };
+function validate24(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate24.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.reason === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "reason" }, message: "must have required property 'reason'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.cancelled_by === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "cancelled_by" }, message: "must have required property 'cancelled_by'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.reason !== void 0) {
+      let data0 = data.reason;
+      if (typeof data0 !== "string") {
+        const err2 = { instancePath: instancePath + "/reason", schemaPath: "#/properties/reason/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err2];
+        } else {
+          vErrors.push(err2);
+        }
+        errors++;
+      }
+      if (!(data0 === "user_declined" || data0 === "principal_navigated_away" || data0 === "host_requested" || data0 === "system_revoked")) {
+        const err3 = { instancePath: instancePath + "/reason", schemaPath: "#/properties/reason/enum", keyword: "enum", params: { allowedValues: schema35.properties.reason.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.cancelled_by !== void 0) {
+      let data1 = data.cancelled_by;
+      if (typeof data1 !== "string") {
+        const err4 = { instancePath: instancePath + "/cancelled_by", schemaPath: "#/properties/cancelled_by/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+      if (!(data1 === "principal" || data1 === "host" || data1 === "system")) {
+        const err5 = { instancePath: instancePath + "/cancelled_by", schemaPath: "#/properties/cancelled_by/enum", keyword: "enum", params: { allowedValues: schema35.properties.cancelled_by.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err6 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err6];
+    } else {
+      vErrors.push(err6);
+    }
+    errors++;
+  }
+  validate24.errors = vErrors;
+  return errors === 0;
+}
+validate24.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/consent/state.js
+var state_default = validate28;
+var schema39 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/consent/state.json", "title": "consent STATE payload", "type": "object", "additionalProperties": true, "required": ["from", "to", "step_index", "total_steps"], "properties": { "from": { "type": ["string", "null"] }, "to": { "type": "string" }, "step_index": { "type": "integer", "minimum": 0 }, "total_steps": { "type": "integer", "minimum": 1 }, "kind_payload": { "type": "object", "additionalProperties": true } } };
+function validate28(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate28.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.from === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "from" }, message: "must have required property 'from'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.to === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "to" }, message: "must have required property 'to'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.step_index === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "step_index" }, message: "must have required property 'step_index'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.total_steps === void 0) {
+      const err3 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "total_steps" }, message: "must have required property 'total_steps'" };
+      if (vErrors === null) {
+        vErrors = [err3];
+      } else {
+        vErrors.push(err3);
+      }
+      errors++;
+    }
+    if (data.from !== void 0) {
+      let data0 = data.from;
+      if (typeof data0 !== "string" && data0 !== null) {
+        const err4 = { instancePath: instancePath + "/from", schemaPath: "#/properties/from/type", keyword: "type", params: { type: schema39.properties.from.type }, message: "must be string,null" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+    if (data.to !== void 0) {
+      if (typeof data.to !== "string") {
+        const err5 = { instancePath: instancePath + "/to", schemaPath: "#/properties/to/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+    if (data.step_index !== void 0) {
+      let data2 = data.step_index;
+      if (!(typeof data2 == "number" && (!(data2 % 1) && !isNaN(data2)))) {
+        const err6 = { instancePath: instancePath + "/step_index", schemaPath: "#/properties/step_index/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+      if (typeof data2 == "number") {
+        if (data2 < 0 || isNaN(data2)) {
+          const err7 = { instancePath: instancePath + "/step_index", schemaPath: "#/properties/step_index/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+          if (vErrors === null) {
+            vErrors = [err7];
+          } else {
+            vErrors.push(err7);
+          }
+          errors++;
+        }
+      }
+    }
+    if (data.total_steps !== void 0) {
+      let data3 = data.total_steps;
+      if (!(typeof data3 == "number" && (!(data3 % 1) && !isNaN(data3)))) {
+        const err8 = { instancePath: instancePath + "/total_steps", schemaPath: "#/properties/total_steps/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+      if (typeof data3 == "number") {
+        if (data3 < 1 || isNaN(data3)) {
+          const err9 = { instancePath: instancePath + "/total_steps", schemaPath: "#/properties/total_steps/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+          if (vErrors === null) {
+            vErrors = [err9];
+          } else {
+            vErrors.push(err9);
+          }
+          errors++;
+        }
+      }
+    }
+    if (data.kind_payload !== void 0) {
+      let data4 = data.kind_payload;
+      if (data4 && typeof data4 == "object" && !Array.isArray(data4)) {
+      } else {
+        const err10 = { instancePath: instancePath + "/kind_payload", schemaPath: "#/properties/kind_payload/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err10];
+        } else {
+          vErrors.push(err10);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err11 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err11];
+    } else {
+      vErrors.push(err11);
+    }
+    errors++;
+  }
+  validate28.errors = vErrors;
+  return errors === 0;
+}
+validate28.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/consent/complete.js
+var complete_default = validate25;
+var schema36 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/consent/complete.json", "title": "consent COMPLETE payload", "type": "object", "additionalProperties": true, "required": ["outcome", "completed_at"], "properties": { "outcome": { "type": "string", "enum": ["granted", "declined"] }, "exchange_token": { "type": ["string", "null"], "description": "Consent token the host exchanges via POST /api/v1/decisions/:token/exchange" }, "completed_at": { "type": "string", "format": "date-time" } } };
+var formats03 = require_formats().fullFormats["date-time"];
+function validate25(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate25.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.outcome === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "outcome" }, message: "must have required property 'outcome'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.completed_at === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "completed_at" }, message: "must have required property 'completed_at'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.outcome !== void 0) {
+      let data0 = data.outcome;
+      if (typeof data0 !== "string") {
+        const err2 = { instancePath: instancePath + "/outcome", schemaPath: "#/properties/outcome/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err2];
+        } else {
+          vErrors.push(err2);
+        }
+        errors++;
+      }
+      if (!(data0 === "granted" || data0 === "declined")) {
+        const err3 = { instancePath: instancePath + "/outcome", schemaPath: "#/properties/outcome/enum", keyword: "enum", params: { allowedValues: schema36.properties.outcome.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.exchange_token !== void 0) {
+      let data1 = data.exchange_token;
+      if (typeof data1 !== "string" && data1 !== null) {
+        const err4 = { instancePath: instancePath + "/exchange_token", schemaPath: "#/properties/exchange_token/type", keyword: "type", params: { type: schema36.properties.exchange_token.type }, message: "must be string,null" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+    if (data.completed_at !== void 0) {
+      let data2 = data.completed_at;
+      if (typeof data2 === "string") {
+        if (!formats03.validate(data2)) {
+          const err5 = { instancePath: instancePath + "/completed_at", schemaPath: "#/properties/completed_at/format", keyword: "format", params: { format: "date-time" }, message: 'must match format "date-time"' };
+          if (vErrors === null) {
+            vErrors = [err5];
+          } else {
+            vErrors.push(err5);
+          }
+          errors++;
+        }
+      } else {
+        const err6 = { instancePath: instancePath + "/completed_at", schemaPath: "#/properties/completed_at/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err7 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err7];
+    } else {
+      vErrors.push(err7);
+    }
+    errors++;
+  }
+  validate25.errors = vErrors;
+  return errors === 0;
+}
+validate25.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/consent/error.js
+var error_default = validate27;
+var schema38 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/consent/error.json", "title": "consent ERROR payload", "type": "object", "additionalProperties": true, "required": ["code", "message", "fatal"], "properties": { "code": { "type": "string" }, "message": { "type": "string" }, "fatal": { "type": "boolean" }, "recoverable_via": { "type": ["string", "null"], "enum": ["reload", "new_session", null] } } };
+function validate27(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate27.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.code === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "code" }, message: "must have required property 'code'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.message === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "message" }, message: "must have required property 'message'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.fatal === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "fatal" }, message: "must have required property 'fatal'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.code !== void 0) {
+      if (typeof data.code !== "string") {
+        const err3 = { instancePath: instancePath + "/code", schemaPath: "#/properties/code/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.message !== void 0) {
+      if (typeof data.message !== "string") {
+        const err4 = { instancePath: instancePath + "/message", schemaPath: "#/properties/message/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+    if (data.fatal !== void 0) {
+      if (typeof data.fatal !== "boolean") {
+        const err5 = { instancePath: instancePath + "/fatal", schemaPath: "#/properties/fatal/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+    if (data.recoverable_via !== void 0) {
+      let data3 = data.recoverable_via;
+      if (typeof data3 !== "string" && data3 !== null) {
+        const err6 = { instancePath: instancePath + "/recoverable_via", schemaPath: "#/properties/recoverable_via/type", keyword: "type", params: { type: schema38.properties.recoverable_via.type }, message: "must be string,null" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+      if (!(data3 === "reload" || data3 === "new_session" || data3 === null)) {
+        const err7 = { instancePath: instancePath + "/recoverable_via", schemaPath: "#/properties/recoverable_via/enum", keyword: "enum", params: { allowedValues: schema38.properties.recoverable_via.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err7];
+        } else {
+          vErrors.push(err7);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err8 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err8];
+    } else {
+      vErrors.push(err8);
+    }
+    errors++;
+  }
+  validate27.errors = vErrors;
+  return errors === 0;
+}
+validate27.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/consent/deadline.js
+var deadline_default = validate26;
+var schema37 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/consent/deadline.json", "title": "consent DEADLINE payload", "type": "object", "additionalProperties": true, "required": ["remaining_seconds", "level", "deadline_at"], "properties": { "remaining_seconds": { "type": "integer", "minimum": 0 }, "level": { "type": "string", "enum": ["warning", "expired"] }, "deadline_at": { "type": "string", "format": "date-time" } } };
+var formats04 = require_formats().fullFormats["date-time"];
+function validate26(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate26.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.remaining_seconds === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "remaining_seconds" }, message: "must have required property 'remaining_seconds'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.level === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "level" }, message: "must have required property 'level'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.deadline_at === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "deadline_at" }, message: "must have required property 'deadline_at'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.remaining_seconds !== void 0) {
+      let data0 = data.remaining_seconds;
+      if (!(typeof data0 == "number" && (!(data0 % 1) && !isNaN(data0)))) {
+        const err3 = { instancePath: instancePath + "/remaining_seconds", schemaPath: "#/properties/remaining_seconds/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+      if (typeof data0 == "number") {
+        if (data0 < 0 || isNaN(data0)) {
+          const err4 = { instancePath: instancePath + "/remaining_seconds", schemaPath: "#/properties/remaining_seconds/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+          if (vErrors === null) {
+            vErrors = [err4];
+          } else {
+            vErrors.push(err4);
+          }
+          errors++;
+        }
+      }
+    }
+    if (data.level !== void 0) {
+      let data1 = data.level;
+      if (typeof data1 !== "string") {
+        const err5 = { instancePath: instancePath + "/level", schemaPath: "#/properties/level/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+      if (!(data1 === "warning" || data1 === "expired")) {
+        const err6 = { instancePath: instancePath + "/level", schemaPath: "#/properties/level/enum", keyword: "enum", params: { allowedValues: schema37.properties.level.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+    }
+    if (data.deadline_at !== void 0) {
+      let data2 = data.deadline_at;
+      if (typeof data2 === "string") {
+        if (!formats04.validate(data2)) {
+          const err7 = { instancePath: instancePath + "/deadline_at", schemaPath: "#/properties/deadline_at/format", keyword: "format", params: { format: "date-time" }, message: 'must match format "date-time"' };
+          if (vErrors === null) {
+            vErrors = [err7];
+          } else {
+            vErrors.push(err7);
+          }
+          errors++;
+        }
+      } else {
+        const err8 = { instancePath: instancePath + "/deadline_at", schemaPath: "#/properties/deadline_at/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err9 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err9];
+    } else {
+      vErrors.push(err9);
+    }
+    errors++;
+  }
+  validate26.errors = vErrors;
+  return errors === 0;
+}
+validate26.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/approval/state.js
+var state_default2 = validate23;
+var schema34 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/approval/state.json", "title": "approval STATE payload", "type": "object", "additionalProperties": true, "required": ["from", "to", "kind_payload"], "properties": { "from": { "type": ["string", "null"] }, "to": { "type": "string", "enum": ["pending", "opened", "in_progress", "approved", "denied", "expired"] }, "kind_payload": { "type": "object", "additionalProperties": true, "required": ["agent_id", "action_class", "scope_invoked"], "properties": { "agent_id": { "type": "string" }, "action_class": { "type": "string" }, "bounded_authority": { "type": "object", "additionalProperties": true }, "scope_invoked": { "type": "string" }, "value_invoked": { "type": ["object", "null"], "additionalProperties": true } } } } };
+function validate23(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate23.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.from === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "from" }, message: "must have required property 'from'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.to === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "to" }, message: "must have required property 'to'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.kind_payload === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "kind_payload" }, message: "must have required property 'kind_payload'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.from !== void 0) {
+      let data0 = data.from;
+      if (typeof data0 !== "string" && data0 !== null) {
+        const err3 = { instancePath: instancePath + "/from", schemaPath: "#/properties/from/type", keyword: "type", params: { type: schema34.properties.from.type }, message: "must be string,null" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.to !== void 0) {
+      let data1 = data.to;
+      if (typeof data1 !== "string") {
+        const err4 = { instancePath: instancePath + "/to", schemaPath: "#/properties/to/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+      if (!(data1 === "pending" || data1 === "opened" || data1 === "in_progress" || data1 === "approved" || data1 === "denied" || data1 === "expired")) {
+        const err5 = { instancePath: instancePath + "/to", schemaPath: "#/properties/to/enum", keyword: "enum", params: { allowedValues: schema34.properties.to.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+    if (data.kind_payload !== void 0) {
+      let data2 = data.kind_payload;
+      if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
+        if (data2.agent_id === void 0) {
+          const err6 = { instancePath: instancePath + "/kind_payload", schemaPath: "#/properties/kind_payload/required", keyword: "required", params: { missingProperty: "agent_id" }, message: "must have required property 'agent_id'" };
+          if (vErrors === null) {
+            vErrors = [err6];
+          } else {
+            vErrors.push(err6);
+          }
+          errors++;
+        }
+        if (data2.action_class === void 0) {
+          const err7 = { instancePath: instancePath + "/kind_payload", schemaPath: "#/properties/kind_payload/required", keyword: "required", params: { missingProperty: "action_class" }, message: "must have required property 'action_class'" };
+          if (vErrors === null) {
+            vErrors = [err7];
+          } else {
+            vErrors.push(err7);
+          }
+          errors++;
+        }
+        if (data2.scope_invoked === void 0) {
+          const err8 = { instancePath: instancePath + "/kind_payload", schemaPath: "#/properties/kind_payload/required", keyword: "required", params: { missingProperty: "scope_invoked" }, message: "must have required property 'scope_invoked'" };
+          if (vErrors === null) {
+            vErrors = [err8];
+          } else {
+            vErrors.push(err8);
+          }
+          errors++;
+        }
+        if (data2.agent_id !== void 0) {
+          if (typeof data2.agent_id !== "string") {
+            const err9 = { instancePath: instancePath + "/kind_payload/agent_id", schemaPath: "#/properties/kind_payload/properties/agent_id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err9];
+            } else {
+              vErrors.push(err9);
+            }
+            errors++;
+          }
+        }
+        if (data2.action_class !== void 0) {
+          if (typeof data2.action_class !== "string") {
+            const err10 = { instancePath: instancePath + "/kind_payload/action_class", schemaPath: "#/properties/kind_payload/properties/action_class/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err10];
+            } else {
+              vErrors.push(err10);
+            }
+            errors++;
+          }
+        }
+        if (data2.bounded_authority !== void 0) {
+          let data5 = data2.bounded_authority;
+          if (data5 && typeof data5 == "object" && !Array.isArray(data5)) {
+          } else {
+            const err11 = { instancePath: instancePath + "/kind_payload/bounded_authority", schemaPath: "#/properties/kind_payload/properties/bounded_authority/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+              vErrors = [err11];
+            } else {
+              vErrors.push(err11);
+            }
+            errors++;
+          }
+        }
+        if (data2.scope_invoked !== void 0) {
+          if (typeof data2.scope_invoked !== "string") {
+            const err12 = { instancePath: instancePath + "/kind_payload/scope_invoked", schemaPath: "#/properties/kind_payload/properties/scope_invoked/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err12];
+            } else {
+              vErrors.push(err12);
+            }
+            errors++;
+          }
+        }
+        if (data2.value_invoked !== void 0) {
+          let data7 = data2.value_invoked;
+          if (!(data7 && typeof data7 == "object" && !Array.isArray(data7)) && data7 !== null) {
+            const err13 = { instancePath: instancePath + "/kind_payload/value_invoked", schemaPath: "#/properties/kind_payload/properties/value_invoked/type", keyword: "type", params: { type: schema34.properties.kind_payload.properties.value_invoked.type }, message: "must be object,null" };
+            if (vErrors === null) {
+              vErrors = [err13];
+            } else {
+              vErrors.push(err13);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err14 = { instancePath: instancePath + "/kind_payload", schemaPath: "#/properties/kind_payload/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err14];
+        } else {
+          vErrors.push(err14);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err15 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err15];
+    } else {
+      vErrors.push(err15);
+    }
+    errors++;
+  }
+  validate23.errors = vErrors;
+  return errors === 0;
+}
+validate23.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/approval/complete.js
+var complete_default2 = validate20;
+var schema31 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/approval/complete.json", "title": "approval COMPLETE payload", "type": "object", "additionalProperties": true, "required": ["outcome", "completed_at"], "properties": { "outcome": { "type": "string", "enum": ["approved", "denied"] }, "exchange_token": { "type": ["string", "null"], "description": "Approval-decision exchange token; host calls POST /api/v1/decisions/:token/exchange" }, "completed_at": { "type": "string", "format": "date-time" } } };
+var formats05 = require_formats().fullFormats["date-time"];
+function validate20(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate20.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.outcome === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "outcome" }, message: "must have required property 'outcome'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.completed_at === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "completed_at" }, message: "must have required property 'completed_at'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.outcome !== void 0) {
+      let data0 = data.outcome;
+      if (typeof data0 !== "string") {
+        const err2 = { instancePath: instancePath + "/outcome", schemaPath: "#/properties/outcome/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err2];
+        } else {
+          vErrors.push(err2);
+        }
+        errors++;
+      }
+      if (!(data0 === "approved" || data0 === "denied")) {
+        const err3 = { instancePath: instancePath + "/outcome", schemaPath: "#/properties/outcome/enum", keyword: "enum", params: { allowedValues: schema31.properties.outcome.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.exchange_token !== void 0) {
+      let data1 = data.exchange_token;
+      if (typeof data1 !== "string" && data1 !== null) {
+        const err4 = { instancePath: instancePath + "/exchange_token", schemaPath: "#/properties/exchange_token/type", keyword: "type", params: { type: schema31.properties.exchange_token.type }, message: "must be string,null" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+    if (data.completed_at !== void 0) {
+      let data2 = data.completed_at;
+      if (typeof data2 === "string") {
+        if (!formats05.validate(data2)) {
+          const err5 = { instancePath: instancePath + "/completed_at", schemaPath: "#/properties/completed_at/format", keyword: "format", params: { format: "date-time" }, message: 'must match format "date-time"' };
+          if (vErrors === null) {
+            vErrors = [err5];
+          } else {
+            vErrors.push(err5);
+          }
+          errors++;
+        }
+      } else {
+        const err6 = { instancePath: instancePath + "/completed_at", schemaPath: "#/properties/completed_at/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err7 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err7];
+    } else {
+      vErrors.push(err7);
+    }
+    errors++;
+  }
+  validate20.errors = vErrors;
+  return errors === 0;
+}
+validate20.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/approval/error.js
+var error_default2 = validate22;
+var schema33 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/approval/error.json", "title": "approval ERROR payload", "type": "object", "additionalProperties": true, "required": ["code", "message", "fatal"], "properties": { "code": { "type": "string" }, "message": { "type": "string" }, "fatal": { "type": "boolean" }, "recoverable_via": { "type": ["string", "null"], "enum": ["reload", "new_session", null] } } };
+function validate22(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate22.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.code === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "code" }, message: "must have required property 'code'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.message === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "message" }, message: "must have required property 'message'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.fatal === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "fatal" }, message: "must have required property 'fatal'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.code !== void 0) {
+      if (typeof data.code !== "string") {
+        const err3 = { instancePath: instancePath + "/code", schemaPath: "#/properties/code/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.message !== void 0) {
+      if (typeof data.message !== "string") {
+        const err4 = { instancePath: instancePath + "/message", schemaPath: "#/properties/message/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+    if (data.fatal !== void 0) {
+      if (typeof data.fatal !== "boolean") {
+        const err5 = { instancePath: instancePath + "/fatal", schemaPath: "#/properties/fatal/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+    if (data.recoverable_via !== void 0) {
+      let data3 = data.recoverable_via;
+      if (typeof data3 !== "string" && data3 !== null) {
+        const err6 = { instancePath: instancePath + "/recoverable_via", schemaPath: "#/properties/recoverable_via/type", keyword: "type", params: { type: schema33.properties.recoverable_via.type }, message: "must be string,null" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+      if (!(data3 === "reload" || data3 === "new_session" || data3 === null)) {
+        const err7 = { instancePath: instancePath + "/recoverable_via", schemaPath: "#/properties/recoverable_via/enum", keyword: "enum", params: { allowedValues: schema33.properties.recoverable_via.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err7];
+        } else {
+          vErrors.push(err7);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err8 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err8];
+    } else {
+      vErrors.push(err8);
+    }
+    errors++;
+  }
+  validate22.errors = vErrors;
+  return errors === 0;
+}
+validate22.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/approval/deadline.js
+var deadline_default2 = validate21;
+var schema32 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/approval/deadline.json", "title": "approval DEADLINE payload", "type": "object", "additionalProperties": true, "required": ["remaining_seconds", "level", "deadline_at"], "properties": { "remaining_seconds": { "type": "integer", "minimum": 0 }, "level": { "type": "string", "enum": ["warning", "expired"] }, "deadline_at": { "type": "string", "format": "date-time" } } };
+var formats06 = require_formats().fullFormats["date-time"];
+function validate21(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate21.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.remaining_seconds === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "remaining_seconds" }, message: "must have required property 'remaining_seconds'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.level === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "level" }, message: "must have required property 'level'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.deadline_at === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "deadline_at" }, message: "must have required property 'deadline_at'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.remaining_seconds !== void 0) {
+      let data0 = data.remaining_seconds;
+      if (!(typeof data0 == "number" && (!(data0 % 1) && !isNaN(data0)))) {
+        const err3 = { instancePath: instancePath + "/remaining_seconds", schemaPath: "#/properties/remaining_seconds/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+      if (typeof data0 == "number") {
+        if (data0 < 0 || isNaN(data0)) {
+          const err4 = { instancePath: instancePath + "/remaining_seconds", schemaPath: "#/properties/remaining_seconds/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+          if (vErrors === null) {
+            vErrors = [err4];
+          } else {
+            vErrors.push(err4);
+          }
+          errors++;
+        }
+      }
+    }
+    if (data.level !== void 0) {
+      let data1 = data.level;
+      if (typeof data1 !== "string") {
+        const err5 = { instancePath: instancePath + "/level", schemaPath: "#/properties/level/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+      if (!(data1 === "warning" || data1 === "expired")) {
+        const err6 = { instancePath: instancePath + "/level", schemaPath: "#/properties/level/enum", keyword: "enum", params: { allowedValues: schema32.properties.level.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+    }
+    if (data.deadline_at !== void 0) {
+      let data2 = data.deadline_at;
+      if (typeof data2 === "string") {
+        if (!formats06.validate(data2)) {
+          const err7 = { instancePath: instancePath + "/deadline_at", schemaPath: "#/properties/deadline_at/format", keyword: "format", params: { format: "date-time" }, message: 'must match format "date-time"' };
+          if (vErrors === null) {
+            vErrors = [err7];
+          } else {
+            vErrors.push(err7);
+          }
+          errors++;
+        }
+      } else {
+        const err8 = { instancePath: instancePath + "/deadline_at", schemaPath: "#/properties/deadline_at/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err9 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err9];
+    } else {
+      vErrors.push(err9);
+    }
+    errors++;
+  }
+  validate21.errors = vErrors;
+  return errors === 0;
+}
+validate21.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/signature/state.js
+var state_default3 = validate35;
+var schema46 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/signature/state.json", "title": "signature STATE payload", "type": "object", "additionalProperties": true, "required": ["from", "to", "kind_payload"], "properties": { "from": { "type": ["string", "null"] }, "to": { "type": "string", "enum": ["pending", "opened", "in_progress", "signed", "declined", "expired"] }, "kind_payload": { "type": "object", "additionalProperties": true, "required": ["required_assurance_level"], "properties": { "required_assurance_level": { "type": "string", "enum": ["integrity_proof", "advanced", "qualified"] }, "participant_role": { "type": ["string", "null"] } } } } };
+function validate35(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate35.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.from === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "from" }, message: "must have required property 'from'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.to === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "to" }, message: "must have required property 'to'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.kind_payload === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "kind_payload" }, message: "must have required property 'kind_payload'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.from !== void 0) {
+      let data0 = data.from;
+      if (typeof data0 !== "string" && data0 !== null) {
+        const err3 = { instancePath: instancePath + "/from", schemaPath: "#/properties/from/type", keyword: "type", params: { type: schema46.properties.from.type }, message: "must be string,null" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.to !== void 0) {
+      let data1 = data.to;
+      if (typeof data1 !== "string") {
+        const err4 = { instancePath: instancePath + "/to", schemaPath: "#/properties/to/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+      if (!(data1 === "pending" || data1 === "opened" || data1 === "in_progress" || data1 === "signed" || data1 === "declined" || data1 === "expired")) {
+        const err5 = { instancePath: instancePath + "/to", schemaPath: "#/properties/to/enum", keyword: "enum", params: { allowedValues: schema46.properties.to.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+    if (data.kind_payload !== void 0) {
+      let data2 = data.kind_payload;
+      if (data2 && typeof data2 == "object" && !Array.isArray(data2)) {
+        if (data2.required_assurance_level === void 0) {
+          const err6 = { instancePath: instancePath + "/kind_payload", schemaPath: "#/properties/kind_payload/required", keyword: "required", params: { missingProperty: "required_assurance_level" }, message: "must have required property 'required_assurance_level'" };
+          if (vErrors === null) {
+            vErrors = [err6];
+          } else {
+            vErrors.push(err6);
+          }
+          errors++;
+        }
+        if (data2.required_assurance_level !== void 0) {
+          let data3 = data2.required_assurance_level;
+          if (typeof data3 !== "string") {
+            const err7 = { instancePath: instancePath + "/kind_payload/required_assurance_level", schemaPath: "#/properties/kind_payload/properties/required_assurance_level/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err7];
+            } else {
+              vErrors.push(err7);
+            }
+            errors++;
+          }
+          if (!(data3 === "integrity_proof" || data3 === "advanced" || data3 === "qualified")) {
+            const err8 = { instancePath: instancePath + "/kind_payload/required_assurance_level", schemaPath: "#/properties/kind_payload/properties/required_assurance_level/enum", keyword: "enum", params: { allowedValues: schema46.properties.kind_payload.properties.required_assurance_level.enum }, message: "must be equal to one of the allowed values" };
+            if (vErrors === null) {
+              vErrors = [err8];
+            } else {
+              vErrors.push(err8);
+            }
+            errors++;
+          }
+        }
+        if (data2.participant_role !== void 0) {
+          let data4 = data2.participant_role;
+          if (typeof data4 !== "string" && data4 !== null) {
+            const err9 = { instancePath: instancePath + "/kind_payload/participant_role", schemaPath: "#/properties/kind_payload/properties/participant_role/type", keyword: "type", params: { type: schema46.properties.kind_payload.properties.participant_role.type }, message: "must be string,null" };
+            if (vErrors === null) {
+              vErrors = [err9];
+            } else {
+              vErrors.push(err9);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err10 = { instancePath: instancePath + "/kind_payload", schemaPath: "#/properties/kind_payload/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err10];
+        } else {
+          vErrors.push(err10);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err11 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err11];
+    } else {
+      vErrors.push(err11);
+    }
+    errors++;
+  }
+  validate35.errors = vErrors;
+  return errors === 0;
+}
+validate35.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/signature/complete.js
+var complete_default3 = validate32;
+var schema43 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/signature/complete.json", "title": "signature COMPLETE payload", "type": "object", "additionalProperties": true, "required": ["outcome", "completed_at"], "properties": { "outcome": { "type": "string", "enum": ["signed", "declined", "countered"] }, "assurance_level": { "type": ["string", "null"], "enum": ["integrity_proof", "advanced", "qualified", null], "description": "The signature assurance level recorded on the agreement." }, "completed_at": { "type": "string", "format": "date-time" } } };
+var formats07 = require_formats().fullFormats["date-time"];
+function validate32(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate32.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.outcome === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "outcome" }, message: "must have required property 'outcome'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.completed_at === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "completed_at" }, message: "must have required property 'completed_at'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.outcome !== void 0) {
+      let data0 = data.outcome;
+      if (typeof data0 !== "string") {
+        const err2 = { instancePath: instancePath + "/outcome", schemaPath: "#/properties/outcome/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err2];
+        } else {
+          vErrors.push(err2);
+        }
+        errors++;
+      }
+      if (!(data0 === "signed" || data0 === "declined" || data0 === "countered")) {
+        const err3 = { instancePath: instancePath + "/outcome", schemaPath: "#/properties/outcome/enum", keyword: "enum", params: { allowedValues: schema43.properties.outcome.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.assurance_level !== void 0) {
+      let data1 = data.assurance_level;
+      if (typeof data1 !== "string" && data1 !== null) {
+        const err4 = { instancePath: instancePath + "/assurance_level", schemaPath: "#/properties/assurance_level/type", keyword: "type", params: { type: schema43.properties.assurance_level.type }, message: "must be string,null" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+      if (!(data1 === "integrity_proof" || data1 === "advanced" || data1 === "qualified" || data1 === null)) {
+        const err5 = { instancePath: instancePath + "/assurance_level", schemaPath: "#/properties/assurance_level/enum", keyword: "enum", params: { allowedValues: schema43.properties.assurance_level.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+    if (data.completed_at !== void 0) {
+      let data2 = data.completed_at;
+      if (typeof data2 === "string") {
+        if (!formats07.validate(data2)) {
+          const err6 = { instancePath: instancePath + "/completed_at", schemaPath: "#/properties/completed_at/format", keyword: "format", params: { format: "date-time" }, message: 'must match format "date-time"' };
+          if (vErrors === null) {
+            vErrors = [err6];
+          } else {
+            vErrors.push(err6);
+          }
+          errors++;
+        }
+      } else {
+        const err7 = { instancePath: instancePath + "/completed_at", schemaPath: "#/properties/completed_at/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err7];
+        } else {
+          vErrors.push(err7);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err8 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err8];
+    } else {
+      vErrors.push(err8);
+    }
+    errors++;
+  }
+  validate32.errors = vErrors;
+  return errors === 0;
+}
+validate32.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/signature/error.js
+var error_default3 = validate34;
+var schema45 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/signature/error.json", "title": "signature ERROR payload", "type": "object", "additionalProperties": true, "required": ["code", "message", "fatal"], "properties": { "code": { "type": "string" }, "message": { "type": "string" }, "fatal": { "type": "boolean" }, "recoverable_via": { "type": ["string", "null"], "enum": ["reload", "new_session", null] } } };
+function validate34(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate34.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.code === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "code" }, message: "must have required property 'code'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.message === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "message" }, message: "must have required property 'message'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.fatal === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "fatal" }, message: "must have required property 'fatal'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.code !== void 0) {
+      if (typeof data.code !== "string") {
+        const err3 = { instancePath: instancePath + "/code", schemaPath: "#/properties/code/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.message !== void 0) {
+      if (typeof data.message !== "string") {
+        const err4 = { instancePath: instancePath + "/message", schemaPath: "#/properties/message/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+    if (data.fatal !== void 0) {
+      if (typeof data.fatal !== "boolean") {
+        const err5 = { instancePath: instancePath + "/fatal", schemaPath: "#/properties/fatal/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+    if (data.recoverable_via !== void 0) {
+      let data3 = data.recoverable_via;
+      if (typeof data3 !== "string" && data3 !== null) {
+        const err6 = { instancePath: instancePath + "/recoverable_via", schemaPath: "#/properties/recoverable_via/type", keyword: "type", params: { type: schema45.properties.recoverable_via.type }, message: "must be string,null" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+      if (!(data3 === "reload" || data3 === "new_session" || data3 === null)) {
+        const err7 = { instancePath: instancePath + "/recoverable_via", schemaPath: "#/properties/recoverable_via/enum", keyword: "enum", params: { allowedValues: schema45.properties.recoverable_via.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err7];
+        } else {
+          vErrors.push(err7);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err8 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err8];
+    } else {
+      vErrors.push(err8);
+    }
+    errors++;
+  }
+  validate34.errors = vErrors;
+  return errors === 0;
+}
+validate34.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/generated/postmessage-v2/signature/deadline.js
+var deadline_default3 = validate33;
+var schema44 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://schemas.overturo.com/postmessage-v2/signature/deadline.json", "title": "signature DEADLINE payload", "type": "object", "additionalProperties": true, "required": ["remaining_seconds", "level", "deadline_at"], "properties": { "remaining_seconds": { "type": "integer", "minimum": 0 }, "level": { "type": "string", "enum": ["warning", "expired"] }, "deadline_at": { "type": "string", "format": "date-time" } } };
+var formats08 = require_formats().fullFormats["date-time"];
+function validate33(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate33.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.remaining_seconds === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "remaining_seconds" }, message: "must have required property 'remaining_seconds'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.level === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "level" }, message: "must have required property 'level'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.deadline_at === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "deadline_at" }, message: "must have required property 'deadline_at'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.remaining_seconds !== void 0) {
+      let data0 = data.remaining_seconds;
+      if (!(typeof data0 == "number" && (!(data0 % 1) && !isNaN(data0)))) {
+        const err3 = { instancePath: instancePath + "/remaining_seconds", schemaPath: "#/properties/remaining_seconds/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+      if (typeof data0 == "number") {
+        if (data0 < 0 || isNaN(data0)) {
+          const err4 = { instancePath: instancePath + "/remaining_seconds", schemaPath: "#/properties/remaining_seconds/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+          if (vErrors === null) {
+            vErrors = [err4];
+          } else {
+            vErrors.push(err4);
+          }
+          errors++;
+        }
+      }
+    }
+    if (data.level !== void 0) {
+      let data1 = data.level;
+      if (typeof data1 !== "string") {
+        const err5 = { instancePath: instancePath + "/level", schemaPath: "#/properties/level/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+      if (!(data1 === "warning" || data1 === "expired")) {
+        const err6 = { instancePath: instancePath + "/level", schemaPath: "#/properties/level/enum", keyword: "enum", params: { allowedValues: schema44.properties.level.enum }, message: "must be equal to one of the allowed values" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+    }
+    if (data.deadline_at !== void 0) {
+      let data2 = data.deadline_at;
+      if (typeof data2 === "string") {
+        if (!formats08.validate(data2)) {
+          const err7 = { instancePath: instancePath + "/deadline_at", schemaPath: "#/properties/deadline_at/format", keyword: "format", params: { format: "date-time" }, message: 'must match format "date-time"' };
+          if (vErrors === null) {
+            vErrors = [err7];
+          } else {
+            vErrors.push(err7);
+          }
+          errors++;
+        }
+      } else {
+        const err8 = { instancePath: instancePath + "/deadline_at", schemaPath: "#/properties/deadline_at/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err9 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err9];
+    } else {
+      vErrors.push(err9);
+    }
+    errors++;
+  }
+  validate33.errors = vErrors;
+  return errors === 0;
+}
+validate33.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": false };
+
+// src/postmessage_v2.ts
+var VALIDATORS = {
+  [MESSAGE_TYPES_V2.READY]: { _agnostic: ready_default },
+  [MESSAGE_TYPES_V2.RESIZE]: { _agnostic: resize_default },
+  [MESSAGE_TYPES_V2.CANCEL]: { _agnostic: cancel_default },
+  [MESSAGE_TYPES_V2.STATE]: {
+    consent: state_default,
+    approval: state_default2,
+    signature_request: state_default3
+  },
+  [MESSAGE_TYPES_V2.COMPLETE]: {
+    consent: complete_default,
+    approval: complete_default2,
+    signature_request: complete_default3
+  },
+  [MESSAGE_TYPES_V2.ERROR]: {
+    consent: error_default,
+    approval: error_default2,
+    signature_request: error_default3
+  },
+  [MESSAGE_TYPES_V2.DEADLINE]: {
+    consent: deadline_default,
+    approval: deadline_default2,
+    signature_request: deadline_default3
+  }
+};
+var envelopeFn = envelope_default;
+function validateEnvelope(message) {
+  const valid = envelopeFn(message);
+  return { valid, errors: valid ? null : envelopeFn.errors ?? null };
+}
+function validatePayload(message) {
+  const typeMap = VALIDATORS[message.type];
+  if (!typeMap) {
+    return { valid: false, errors: [{ message: `Unknown type ${message.type}` }] };
+  }
+  const validator = typeMap._agnostic ?? typeMap[message.kind];
+  if (!validator) {
+    return {
+      valid: false,
+      errors: [{ message: `No validator for ${message.type}/${message.kind}` }]
+    };
+  }
+  const valid = validator(message.payload);
+  return { valid, errors: valid ? null : validator.errors ?? null };
+}
+function validate(message) {
+  const envelopeResult = validateEnvelope(message);
+  if (!envelopeResult.valid) return envelopeResult;
+  return validatePayload(message);
+}
+
+// src/decisions.ts
+var _api3, _flowBaseUrl, _debug, _liveHandles, _Decisions_instances, dispatch_fn;
+var Decisions = class {
+  constructor(config) {
+    __privateAdd(this, _Decisions_instances);
+    __privateAdd(this, _api3);
+    __privateAdd(this, _flowBaseUrl);
+    __privateAdd(this, _debug);
+    __privateAdd(this, _liveHandles, /* @__PURE__ */ new Set());
+    __privateSet(this, _api3, config.api);
+    __privateSet(this, _flowBaseUrl, config.flowBaseUrl);
+    __privateSet(this, _debug, config.debug);
+  }
+  /**
+   * Returns the canonical decisions URL for a token. `mode="embed"`
+   * gets the `/embed` suffix; `popup` and `redirect` use the bare
+   * path (the server-rendered page handles both).
+   */
+  url(opts) {
+    const tail = opts.mode === "embed" ? "/embed" : "";
+    return `${__privateGet(this, _flowBaseUrl)}${DECISIONS_FLOW_PATH}/${opts.token}${tail}`;
+  }
+  /**
+   * Creates a new decisions session via `POST /api/v1/decisions`.
+   * Wraps the legacy v0 API client's snake-case helpers so existing
+   * tests around case conversion keep working.
+   */
+  async createSession(input) {
+    if (!input.subjectRef) {
+      throw new OverturoValidationError("subjectRef is required");
+    }
+    const embedOrigin = input.embedOrigin ?? (typeof window !== "undefined" ? window.location.origin : void 0);
+    const body = {
+      kind: input.kind,
+      subjectRef: input.subjectRef,
+      deliveryMode: input.mode ?? "embed",
+      embedOrigin,
+      state: input.state,
+      redirectUri: input.redirectUri
+    };
+    if (input.kind === "consent") {
+      body.scope = input.scope;
+      body.nonce = input.nonce;
+    }
+    const envelope = await __privateGet(this, _api3).post(DECISIONS_API_PATH, body);
+    const raw = envelope.decision;
+    if (__privateGet(this, _debug)) {
+      console.debug("[overturo:sdk]", "session_created", {
+        kind: raw.kind,
+        mode: raw.mode
+      });
+    }
+    return {
+      token: raw.sessionToken,
+      kind: raw.kind,
+      mode: raw.mode,
+      expiresAt: raw.deadlineAt ?? "",
+      embedUrl: raw.embedUrl
+    };
+  }
+  /**
+   * pre-flight disclosure discovery. Fetches what the decision screen
+   * will present for a flow, BEFORE any session exists: purposes, fields,
+   * steps, the action label, expiry, and application branding, in public
+   * vocabulary and the requested locale. The recommended first call in the
+   * embed flow: discover -> createSession -> (SDK reads config).
+   *
+   * Publishable-key authenticated — the ApiClient already sends
+   * `X-Publishable-Key` (api.ts); the server ignores any bearer header on this
+   * endpoint. An unknown / foreign / non-consent flow answers a uniform 404
+   * (OverturoApiError, status 404).
+   */
+  async discover(opts) {
+    if (!opts.flowId) {
+      throw new OverturoValidationError("flowId is required");
+    }
+    const qs = opts.locale ? `?locale=${encodeURIComponent(opts.locale)}` : "";
+    const envelope = await __privateGet(this, _api3).get(
+      `${DECISIONS_API_PATH}/flows/${encodeURIComponent(opts.flowId)}/disclosures${qs}`
+    );
+    if (!envelope || typeof envelope !== "object" || !("flow" in envelope)) {
+      throw new OverturoApiError("Malformed discovery response: missing 'flow'", 200, envelope);
+    }
+    return envelope.flow;
+  }
+  /**
+   * Mounts the decisions flow inside an iframe under `opts.container`.
+   * Validates inbound v2 envelopes; drops on origin mismatch /
+   * schema-invalid. Returns a handle whose `.destroy()` tears down
+   * the iframe + listener.
+   */
+  embed(opts) {
+    if (!opts.token) {
+      throw new OverturoValidationError("token is required");
+    }
+    const url = this.url({ token: opts.token, mode: "embed" });
+    const expectedOrigin = new URL(url).origin;
+    const container = resolveContainer(opts.container);
+    container.innerHTML = "";
+    if (opts.loading) {
+      const loadingEl = document.createElement("div");
+      loadingEl.setAttribute("data-overturo-loading", "");
+      if (typeof opts.loading === "string") {
+        loadingEl.innerHTML = opts.loading;
+      } else {
+        loadingEl.appendChild(opts.loading);
+      }
+      container.appendChild(loadingEl);
+    }
+    const iframe = document.createElement("iframe");
+    iframe.src = url;
+    iframe.setAttribute("sandbox", "allow-scripts allow-forms allow-same-origin allow-popups");
+    applyStyle(iframe, { ...EMBED_DEFAULTS }, opts.style);
+    const clearLoading = () => {
+      const loadingChild = container.querySelector("[data-overturo-loading]");
+      if (loadingChild) container.removeChild(loadingChild);
+    };
+    iframe.addEventListener("load", clearLoading);
+    iframe.addEventListener("error", () => {
+      clearLoading();
+      opts.onError?.({
+        code: "iframe_load_failed",
+        message: "The trust-host iframe failed to load."
+      });
+    });
+    const ac = new AbortController();
+    const onMessage = (event) => {
+      if (event.origin !== expectedOrigin || isForeignEnvelope(event.data)) return;
+      const result = validate(event.data);
+      if (!result.valid) {
+        opts.onError?.({
+          code: "protocol_violation",
+          errors: result.errors
+        });
+        if (__privateGet(this, _debug)) {
+          console.debug("[overturo:sdk]", "envelope_dropped", {
+            reason: "schema_invalid"
+          });
+        }
+        return;
+      }
+      __privateMethod(this, _Decisions_instances, dispatch_fn).call(this, event.data, opts, iframe);
+    };
+    window.addEventListener("message", onMessage, { signal: ac.signal });
+    container.appendChild(iframe);
+    const handle = {
+      token: opts.token,
+      mode: "embed",
+      destroy: async () => {
+        ac.abort();
+        if (iframe.parentNode) iframe.parentNode.removeChild(iframe);
+        __privateGet(this, _liveHandles).delete(handle);
+        if (__privateGet(this, _debug)) {
+          console.debug("[overturo:sdk]", "iframe_destroyed", {});
+        }
+      }
+    };
+    __privateGet(this, _liveHandles).add(handle);
+    if (__privateGet(this, _debug)) {
+      console.debug("[overturo:sdk]", "iframe_mounted", {
+        sandboxAttr: iframe.getAttribute("sandbox")
+      });
+    }
+    return handle;
+  }
+  /**
+   * Opens the decisions flow in a popup window. Caller MUST invoke this
+   * synchronously from a user-action handler or browsers will block.
+   */
+  popup(opts) {
+    if (!opts.token) {
+      throw new OverturoValidationError("token is required");
+    }
+    const url = this.url({ token: opts.token, mode: "popup" });
+    const expectedOrigin = new URL(url).origin;
+    const width = opts.width ?? POPUP_DEFAULTS.width;
+    const height = opts.height ?? POPUP_DEFAULTS.height;
+    const left = Math.round((screen.width - width) / 2);
+    const top = Math.round((screen.height - height) / 2);
+    const features = `width=${width},height=${height},left=${left},top=${top},scrollbars=yes,status=yes`;
+    const win = window.open(url, "_blank", features);
+    if (!win) {
+      if (__privateGet(this, _debug)) {
+        console.debug("[overturo:sdk]", "popup_blocked", {});
+      }
+      throw new OverturoError("Popup was blocked by the browser. Allow popups for this site and try again.");
+    }
+    if (__privateGet(this, _debug)) {
+      console.debug("[overturo:sdk]", "popup_opened", { features });
+    }
+    const ac = new AbortController();
+    const onMessage = (event) => {
+      if (event.origin !== expectedOrigin || isForeignEnvelope(event.data)) return;
+      const result = validate(event.data);
+      if (!result.valid) {
+        opts.onError?.({ code: "protocol_violation" });
+        return;
+      }
+      const envelope = event.data;
+      switch (envelope.type) {
+        case MESSAGE_TYPES_V2.COMPLETE:
+          opts.onComplete?.(buildOutcome(envelope.kind, envelope.payload));
+          handle.destroy();
+          break;
+        case MESSAGE_TYPES_V2.CANCEL:
+          opts.onCancel?.(envelope.payload);
+          handle.destroy();
+          break;
+        case MESSAGE_TYPES_V2.ERROR:
+          opts.onError?.(envelope.payload);
+          break;
+      }
+    };
+    window.addEventListener("message", onMessage, { signal: ac.signal });
+    let closeTimer = setInterval(() => {
+      if (win.closed) {
+        if (closeTimer) {
+          clearInterval(closeTimer);
+          closeTimer = null;
+        }
+        opts.onCancel?.({ reason: "user_closed_popup" });
+        handle.destroy();
+      }
+    }, 500);
+    const handle = {
+      token: opts.token,
+      mode: "popup",
+      destroy: async () => {
+        if (closeTimer) {
+          clearInterval(closeTimer);
+          closeTimer = null;
+        }
+        ac.abort();
+        if (win && !win.closed) win.close();
+        __privateGet(this, _liveHandles).delete(handle);
+      }
+    };
+    __privateGet(this, _liveHandles).add(handle);
+    return handle;
+  }
+  /**
+   * Exchanges a completed decision's token for the per-kind receipt.
+   * Server returns a discriminated union; the SDK preserves the
+   * discriminator so consumers using strict TypeScript get narrowing.
+   */
+  async exchange(input) {
+    if (!input.token || !input.exchangeToken) {
+      throw new OverturoValidationError("token and exchangeToken are required for exchange");
+    }
+    const path = `${DECISIONS_API_PATH}/${input.token}/exchange`;
+    const raw = await __privateGet(this, _api3).post(path, {
+      exchangeToken: input.exchangeToken
+    });
+    return raw;
+  }
+  /**
+   * Asks the server to mark a session as cancelled. Idempotent on
+   * already-terminal sessions.
+   */
+  async cancel(token) {
+    if (!token) {
+      throw new OverturoValidationError("token is required for cancel");
+    }
+    await __privateGet(this, _api3).post(`${DECISIONS_API_PATH}/${token}/cancel`, {});
+  }
+  /**
+   * Tears down every live handle (embed or popup) this client created.
+   * Called by `Overturo#destroy()`. Errors during destroy are swallowed
+   * — we want best-effort cleanup, not a half-destroyed state.
+   */
+  async destroyAll() {
+    const handles = [...__privateGet(this, _liveHandles)];
+    await Promise.allSettled(handles.map((h) => h.destroy()));
+    __privateGet(this, _liveHandles).clear();
+  }
+};
+_api3 = new WeakMap();
+_flowBaseUrl = new WeakMap();
+_debug = new WeakMap();
+_liveHandles = new WeakMap();
+_Decisions_instances = new WeakSet();
+dispatch_fn = function(envelope, opts, iframe) {
+  const isCounterState = envelope.type === MESSAGE_TYPES_V2.STATE && envelope.kind === "approval" && envelope.payload?.phase === "countered";
+  switch (envelope.type) {
+    case MESSAGE_TYPES_V2.READY:
+      opts.onReady?.(envelope.payload);
+      break;
+    case MESSAGE_TYPES_V2.STATE:
+      if (isCounterState) {
+        opts.onCounter?.(envelope.payload);
+      } else {
+        opts.onState?.(envelope.kind, envelope.payload);
+      }
+      break;
+    case MESSAGE_TYPES_V2.RESIZE: {
+      const height = envelope.payload.height;
+      if (typeof height === "number") {
+        iframe.style.height = `${height}px`;
+        opts.onResize?.(height);
+      }
+      break;
+    }
+    case MESSAGE_TYPES_V2.COMPLETE:
+      opts.onComplete?.(buildOutcome(envelope.kind, envelope.payload));
+      break;
+    case MESSAGE_TYPES_V2.CANCEL:
+      opts.onCancel?.(envelope.payload);
+      break;
+    case MESSAGE_TYPES_V2.ERROR:
+      opts.onError?.(envelope.payload);
+      break;
+    case MESSAGE_TYPES_V2.DEADLINE:
+      opts.onDeadline?.(envelope.payload);
+      break;
+  }
+  if (__privateGet(this, _debug)) {
+    console.debug("[overturo:sdk]", "envelope_received", {
+      type: envelope.type,
+      kind: envelope.kind
+    });
+  }
+};
+function buildOutcome(kind, payload) {
+  const p = payload ?? {};
+  if (kind === "consent") {
+    return {
+      kind: "consent",
+      result: p.outcome ?? p.result ?? "granted",
+      consentToken: p.exchange_token ?? p.consentToken,
+      purposesGranted: p.purposesGranted,
+      purposesDeclined: p.purposesDeclined
+    };
+  }
+  if (kind === "signature_request") {
+    return {
+      kind: "signature_request",
+      result: p.outcome ?? p.result ?? "signed",
+      assuranceLevel: p.assurance_level ?? p.assuranceLevel,
+      completedAt: p.completed_at ?? p.completedAt
+    };
+  }
+  return {
+    kind: "approval",
+    result: p.outcome ?? p.result ?? "approved",
+    escalationToken: p.exchange_token ?? p.escalationToken,
+    counterProposal: p.counterProposal
+  };
+}
+
+// src/embed.ts
+function createEmbed(baseUrl, options) {
+  const container = resolveContainer(options.container);
+  const expectedOrigin = new URL(baseUrl).origin;
+  const embedUrl = `${baseUrl}/accord/embed/${options.sessionToken}`;
+  container.innerHTML = "";
+  if (options.loading) {
+    const loadingEl = document.createElement("div");
+    loadingEl.setAttribute("data-overturo-loading", "");
+    if (typeof options.loading === "string") {
+      loadingEl.innerHTML = options.loading;
+    } else {
+      loadingEl.appendChild(options.loading);
+    }
+    container.appendChild(loadingEl);
+  }
+  const iframe = document.createElement("iframe");
+  iframe.src = embedUrl;
+  iframe.setAttribute("sandbox", "allow-scripts allow-forms allow-same-origin allow-popups");
+  applyStyle(iframe, { ...EMBED_DEFAULTS }, options.style);
+  iframe.addEventListener("load", () => {
+    const loadingChild = container.querySelector("[data-overturo-loading]");
+    if (loadingChild) container.removeChild(loadingChild);
+  });
+  const ac = new AbortController();
+  function handleMessage(event) {
+    if (event.origin !== expectedOrigin) return;
+    const result = validate(event.data);
+    if (!result.valid) return;
+    const envelope = event.data;
+    switch (envelope.type) {
+      case MESSAGE_TYPES_V2.READY:
+        options.onReady?.(envelope.payload);
+        break;
+      case MESSAGE_TYPES_V2.RESIZE: {
+        const height = envelope.payload.height;
+        if (typeof height === "number") {
+          iframe.style.height = `${height}px`;
+          options.onResize?.(height);
+        }
+        break;
+      }
+      case MESSAGE_TYPES_V2.STATE:
+        options.onState?.(envelope.kind, envelope.payload);
+        break;
+      case MESSAGE_TYPES_V2.DEADLINE:
+        options.onDeadline?.(envelope.payload);
+        break;
+      case MESSAGE_TYPES_V2.COMPLETE:
+        options.onComplete?.(envelope.kind, envelope.payload);
+        break;
+      case MESSAGE_TYPES_V2.CANCEL:
+        options.onCancel?.(envelope.payload);
+        break;
+      case MESSAGE_TYPES_V2.ERROR:
+        options.onError?.(envelope.payload);
+        break;
+    }
+  }
+  window.addEventListener("message", handleMessage, { signal: ac.signal });
+  container.appendChild(iframe);
+  return {
+    iframe,
+    destroy() {
+      ac.abort();
+      if (iframe.parentNode) {
+        iframe.parentNode.removeChild(iframe);
+      }
+    }
+  };
+}
+
+// src/popup.ts
+var popupCounter = 0;
+function createPopup(baseUrl, options) {
+  if (!options.sessionToken) {
+    throw new OverturoValidationError("sessionToken is required for popup mode");
+  }
+  const embedUrl = `${baseUrl}/accord/embed/${options.sessionToken}`;
+  const width = options.width ?? POPUP_DEFAULTS.width;
+  const height = options.height ?? POPUP_DEFAULTS.height;
+  const left = Math.round((screen.width - width) / 2);
+  const top = Math.round((screen.height - height) / 2);
+  const windowName = `overturo_decision_${++popupCounter}`;
+  const popup = window.open(
+    embedUrl,
+    windowName,
+    `width=${width},height=${height},left=${left},top=${top},scrollbars=yes,status=yes`
+  );
+  if (!popup) {
+    throw new OverturoError("Popup was blocked by the browser. Allow popups for this site and try again.");
+  }
+  const expectedOrigin = new URL(baseUrl).origin;
+  const ac = new AbortController();
+  function handleMessage(event) {
+    if (event.origin !== expectedOrigin) return;
+    const result = validate(event.data);
+    if (!result.valid) return;
+    const envelope = event.data;
+    switch (envelope.type) {
+      case MESSAGE_TYPES_V2.COMPLETE:
+        options.onComplete?.(envelope.kind, envelope.payload);
+        cleanup();
+        break;
+      case MESSAGE_TYPES_V2.CANCEL:
+        options.onCancel?.(envelope.payload);
+        cleanup();
+        break;
+      case MESSAGE_TYPES_V2.ERROR:
+        options.onError?.(envelope.payload);
+        break;
+    }
+  }
+  function cleanup() {
+    ac.abort();
+    if (popup && !popup.closed) popup.close();
+  }
+  window.addEventListener("message", handleMessage, { signal: ac.signal });
+  return { close: cleanup };
+}
+
+// src/preview.ts
+var VIEWPORTS = {
+  mobile: { width: 375, height: 667 },
+  tablet: { width: 768, height: 1024 },
+  desktop: { width: null, height: 800 }
+};
+function renderPreview(previewUrl, options) {
+  const container = resolveContainer2(options.container);
+  let currentDevice = options.device || "desktop";
+  let currentTheme = options.theme || "default";
+  let currentLocale = options.locale;
+  const url = buildUrl(previewUrl, currentTheme, currentDevice, currentLocale);
+  if (options.loading) {
+    showLoading(container, options.loading);
+  }
+  const iframe = document.createElement("iframe");
+  iframe.src = url;
+  iframe.sandbox.add("allow-scripts", "allow-same-origin");
+  iframe.style.border = "none";
+  iframe.title = "Preview";
+  applyViewport(iframe, currentDevice);
+  applyStyle2(iframe, options.style);
+  iframe.addEventListener(
+    "load",
+    () => {
+      const loader = container.querySelector("[data-preview-loading]");
+      if (loader) loader.remove();
+    },
+    { once: true }
+  );
+  container.appendChild(iframe);
+  const handle = {
+    iframe,
+    setDevice(device) {
+      currentDevice = device;
+      applyViewport(iframe, device);
+      iframe.src = buildUrl(previewUrl, currentTheme, currentDevice, currentLocale);
+    },
+    setTheme(theme) {
+      currentTheme = theme;
+      iframe.src = buildUrl(previewUrl, currentTheme, currentDevice, currentLocale);
+    },
+    destroy() {
+      iframe.remove();
+    }
+  };
+  return handle;
+}
+function resolveContainer2(target) {
+  if (typeof target === "string") {
+    const el = document.querySelector(target);
+    if (!el) throw new Error(`Preview container not found: ${target}`);
+    return el;
+  }
+  return target;
+}
+function buildUrl(base, theme, device, locale) {
+  const url = new URL(base, window.location.origin);
+  url.searchParams.set("theme", theme);
+  url.searchParams.set("device", device);
+  if (locale) url.searchParams.set("locale", locale);
+  return url.toString();
+}
+function applyViewport(iframe, device) {
+  const vp = VIEWPORTS[device] || VIEWPORTS.desktop;
+  if (vp.width) {
+    iframe.style.width = `${vp.width}px`;
+    iframe.style.maxWidth = "100%";
+  } else {
+    iframe.style.width = "100%";
+    iframe.style.maxWidth = "none";
+  }
+  iframe.style.height = `${vp.height}px`;
+}
+function applyStyle2(iframe, style) {
+  if (!style) return;
+  if (style.width) iframe.style.width = style.width;
+  if (style.minHeight) iframe.style.minHeight = style.minHeight;
+  if (style.maxHeight) iframe.style.maxHeight = style.maxHeight;
+  if (style.borderRadius) iframe.style.borderRadius = style.borderRadius;
+  if (style.border) iframe.style.border = style.border;
+  if (style.background) iframe.style.background = style.background;
+}
+function showLoading(container, loading) {
+  const wrapper = document.createElement("div");
+  wrapper.setAttribute("data-preview-loading", "");
+  if (typeof loading === "string") {
+    wrapper.textContent = loading;
+  } else {
+    wrapper.appendChild(loading);
+  }
+  container.appendChild(wrapper);
+}
+
+// src/redirect.ts
+function performRedirect(baseUrl, options) {
+  if (!options.flowId) {
+    throw new OverturoValidationError("flowId is required for redirect mode");
+  }
+  if (!options.redirectUri) {
+    throw new OverturoValidationError("redirectUri is required for redirect mode");
+  }
+  const url = new URL(`${baseUrl}/accord/${options.flowId}`);
+  const params = new URLSearchParams();
+  params.set("redirect_uri", options.redirectUri);
+  if (options.state) params.set("state", options.state);
+  if (options.nonce) params.set("nonce", options.nonce);
+  if (options.scope) params.set("scope", options.scope);
+  url.search = params.toString();
+  window.location.href = url.toString();
+}
+
+// src/setup.ts
+function createSetupEmbed(baseUrl, options) {
+  const container = resolveContainer(options.container);
+  const expectedOrigin = new URL(baseUrl).origin;
+  const embedUrl = `${baseUrl}/accord_setup/embed/${options.sessionToken}`;
+  container.innerHTML = "";
+  if (options.loading) {
+    const loadingEl = document.createElement("div");
+    loadingEl.setAttribute("data-overturo-loading", "");
+    if (typeof options.loading === "string") {
+      loadingEl.innerHTML = options.loading;
+    } else {
+      loadingEl.appendChild(options.loading);
+    }
+    container.appendChild(loadingEl);
+  }
+  const iframe = document.createElement("iframe");
+  iframe.src = embedUrl;
+  iframe.setAttribute("allow", "popups");
+  iframe.setAttribute("sandbox", "allow-scripts allow-forms allow-same-origin allow-popups");
+  applyStyle(iframe, { ...EMBED_DEFAULTS }, options.style);
+  iframe.addEventListener("load", () => {
+    const loadingChild = container.querySelector("[data-overturo-loading]");
+    if (loadingChild) container.removeChild(loadingChild);
+  });
+  const ac = new AbortController();
+  function handleMessage(event) {
+    if (event.origin !== expectedOrigin) return;
+    const data = event.data;
+    if (!data || !data.type) return;
+    switch (data.type) {
+      case SETUP_MESSAGE_TYPES.READY:
+        options.onReady?.();
+        break;
+      case SETUP_MESSAGE_TYPES.RESIZE:
+        if (data.height) {
+          iframe.style.height = `${data.height}px`;
+          options.onResize?.(data.height);
+        }
+        break;
+      case SETUP_MESSAGE_TYPES.STEP:
+        options.onStep?.({
+          key: data.step,
+          index: data.stepIndex,
+          total: data.totalSteps
+        });
+        break;
+      case SETUP_MESSAGE_TYPES.CREATED:
+        options.onCreated?.({
+          accordId: data.accordId,
+          flowId: data.flowId
+        });
+        break;
+      case SETUP_MESSAGE_TYPES.CANCEL:
+        options.onCancel?.();
+        break;
+      case SETUP_MESSAGE_TYPES.ERROR:
+        options.onError?.(data.error);
+        break;
+    }
+  }
+  window.addEventListener("message", handleMessage, { signal: ac.signal });
+  container.appendChild(iframe);
+  return {
+    iframe,
+    destroy() {
+      ac.abort();
+      if (iframe.parentNode) {
+        iframe.parentNode.removeChild(iframe);
+      }
+    }
+  };
+}
+function createSetupPopup(baseUrl, options) {
+  const embedUrl = `${baseUrl}/accord_setup/embed/${options.sessionToken}`;
+  const expectedOrigin = new URL(baseUrl).origin;
+  const w = options.width ?? SETUP_POPUP_DEFAULTS.width;
+  const h = options.height ?? SETUP_POPUP_DEFAULTS.height;
+  const left = Math.round((screen.width - w) / 2);
+  const top = Math.round((screen.height - h) / 2);
+  const popup = window.open(
+    embedUrl,
+    "accord_setup_popup",
+    `width=${w},height=${h},left=${left},top=${top},scrollbars=yes`
+  );
+  const ac = new AbortController();
+  let pollTimer = null;
+  function handleMessage(event) {
+    if (event.origin !== expectedOrigin) return;
+    const data = event.data;
+    if (!data || !data.type) return;
+    switch (data.type) {
+      case SETUP_MESSAGE_TYPES.CREATED:
+        options.onCreated?.({
+          accordId: data.accordId,
+          flowId: data.flowId
+        });
+        cleanup();
+        break;
+      case SETUP_MESSAGE_TYPES.CANCEL:
+        options.onCancel?.();
+        cleanup();
+        break;
+      case SETUP_MESSAGE_TYPES.ERROR:
+        options.onError?.(data.error);
+        break;
+    }
+  }
+  function cleanup() {
+    ac.abort();
+    if (pollTimer) clearInterval(pollTimer);
+  }
+  window.addEventListener("message", handleMessage, { signal: ac.signal });
+  pollTimer = setInterval(() => {
+    if (popup && popup.closed) {
+      options.onCancel?.();
+      cleanup();
+    }
+  }, 500);
+  return {
+    close() {
+      popup?.close();
+      cleanup();
+    }
+  };
+}
+function setupRedirect(baseUrl, options) {
+  const embedUrl = `${baseUrl}/accord_setup/embed/${options.sessionToken}`;
+  window.location.href = embedUrl;
+}
+
+// src/overturo.ts
+var Overturo = class {
+  constructor(options) {
+    if (!options.publishableKey) {
+      throw new OverturoValidationError("publishableKey is required");
+    }
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.flowBaseUrl = (options.flowBaseUrl ?? this.baseUrl).replace(/\/+$/, "");
+    this.debugFlag = options.debug === true;
+    this.api = new ApiClient({
+      baseUrl: this.baseUrl,
+      publishableKey: options.publishableKey,
+      apiKey: options.apiKey,
+      timeout: options.timeout
+    });
+    this.decisions = new Decisions({
+      api: this.api,
+      flowBaseUrl: this.flowBaseUrl,
+      debug: this.debugFlag
+    });
+    this.consent = new ConsentFacade(this.decisions);
+    this.approvals = new ApprovalsFacade(this.decisions, this.api);
+    this.signing = new SigningFacade(this.decisions, this.api);
+    this.forms = new FormsFacade(this.api, this.decisions, this.flowBaseUrl, options.publishableKey);
+    if (this.debugFlag && typeof window !== "undefined") {
+      const url = new URL(this.baseUrl);
+      const devHosts = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "lvh.me" || url.hostname.endsWith(".lvh.me") || url.hostname.endsWith(".localhost");
+      if (url.protocol === "http:" && !devHosts) {
+        console.warn(
+          "[overturo:sdk]",
+          "OVERTURO_INSECURE_HOST",
+          `API host ${url.host} is not HTTPS; treat this as dev-only.`
+        );
+      }
+    }
+  }
+  /**
+   * Tears down every live decisions handle (embed iframes + popups).
+   * Best-effort: errors during teardown are swallowed.
+   *
+   * @since 1.0.0
+   */
+  async destroy() {
+    await this.decisions.destroyAll();
+  }
+  // v0's `Overturo#consent({...})` method is REPLACED
+  // by the `consent` facade property declared above. Consumers must
+  // migrate `client.consent({...})` → `client.consent.open({...})`.
+  // The migration is documented in CHANGELOG.md and the developer
+  // portal. Calling `client.consent(...)`
+  // as a function now raises `TypeError` (consent is an object, not
+  // a function); we accept this surprise per the spec's "v0 callers
+  // break" pre-production stance.
+  /**
+   * Creates a new consent session.
+   * The flowId is sent as accord_id to the server (automatic parameter aliasing).
+   */
+  async createSession(params) {
+    return this.api.post(API_PATH, {
+      accordId: params.flowId,
+      deliveryMode: params.deliveryMode,
+      embedOrigin: params.embedOrigin,
+      redirectUri: params.redirectUri,
+      state: params.state,
+      nonce: params.nonce,
+      scope: params.scope,
+      skipSteps: params.skipSteps
+    });
+  }
+  /**
+   * Retrieves the status of an existing consent session.
+   */
+  async getSession(sessionToken) {
+    return this.api.get(`${API_PATH}/${sessionToken}`);
+  }
+  /**
+   * This participant's consent status for ONE meeting (the meeting's own
+   * window and platform ride along). Identified by the participant's own
+   * session token — never lists other participants.
+   */
+  async getMeetingParticipantStatus(meetingId, sessionToken) {
+    if (!meetingId) throw new OverturoValidationError("meetingId is required");
+    if (!sessionToken) throw new OverturoValidationError("sessionToken is required");
+    const response = await this.api.rawGet(
+      `${MEETING_CONSENTS_API_PATH}/${encodeURIComponent(meetingId)}/status?session_token=${encodeURIComponent(sessionToken)}`
+    );
+    return this.decodeParticipantStatus(response);
+  }
+  /**
+   * Withdraws this participant's consent for ONE meeting. The host is told;
+   * the record keeps the withdrawal.
+   */
+  async withdrawMeetingConsent(meetingId, sessionToken) {
+    if (!meetingId) throw new OverturoValidationError("meetingId is required");
+    if (!sessionToken) throw new OverturoValidationError("sessionToken is required");
+    const response = await this.api.rawPost(`${MEETING_CONSENTS_API_PATH}/${encodeURIComponent(meetingId)}/revoke`, {
+      sessionToken
+    });
+    return this.decodeParticipantStatus(response);
+  }
+  // Purpose names are data, not keys: everything camelCases except `purposes`.
+  async decodeParticipantStatus(response) {
+    if (!response.ok) {
+      let responseBody;
+      try {
+        responseBody = await response.json();
+      } catch {
+        responseBody = null;
+      }
+      throw new OverturoApiError(extractErrorMessage(responseBody, response.status), response.status, responseBody);
+    }
+    const raw = JSON.parse(await response.text());
+    const purposes = raw.purposes ?? {};
+    const decoded = toCamelCase({ ...raw, purposes: {} });
+    return { ...decoded, purposes: { ...purposes } };
+  }
+  /**
+   * Embeds a consent flow in an iframe.
+   * Requires a sessionToken from createSession().
+   */
+  embed(options) {
+    return createEmbed(this.flowBaseUrl, options);
+  }
+  /**
+   * Opens a consent flow in a popup window.
+   * Requires a sessionToken from createSession().
+   *
+   * @throws {OverturoError} If the browser blocks the popup.
+   */
+  popup(options) {
+    return createPopup(this.flowBaseUrl, options);
+  }
+  /**
+   * Redirects to a consent flow (full-page navigation).
+   * No session token needed — the server creates one on arrival.
+   */
+  redirect(options) {
+    performRedirect(this.flowBaseUrl, options);
+  }
+  /**
+   * Exchanges a consent token for claims, attestations, credentials, and tokens.
+   * Best used server-side with apiKey set.
+   *
+   * Handles HTTP 202 (fulfillment pending) transparently by retrying with
+   * the Retry-After interval until the server returns the full result.
+   */
+  async exchange(params) {
+    const maxRetries = 5;
+    const path = `${API_PATH}/${params.sessionToken}/exchange`;
+    const body = { consentToken: params.consentToken };
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const response = await this.api.rawPost(path, body);
+      if (response.status === 202) {
+        if (attempt === maxRetries) {
+          throw new OverturoApiError("Exchange timeout: fulfillment still pending", 202, null);
+        }
+        const retryAfter = parseInt(response.headers.get("Retry-After") || "1", 10);
+        await new Promise((resolve) => setTimeout(resolve, retryAfter * 1e3));
+        continue;
+      }
+      if (!response.ok) {
+        let responseBody;
+        try {
+          responseBody = await response.json();
+        } catch {
+          responseBody = null;
+        }
+        const message = extractErrorMessage(responseBody, response.status);
+        throw new OverturoApiError(
+          message === `HTTP ${response.status}` ? `Exchange failed: HTTP ${response.status}` : message,
+          response.status,
+          responseBody
+        );
+      }
+      const text = await response.text();
+      return toCamelCase(JSON.parse(text));
+    }
+    throw new OverturoApiError("Exchange failed: max retries exceeded", 202, null);
+  }
+  // ── AccordSetup Methods ──────────────────────────────
+  /**
+   * Creates a new AccordSetup session via the API.
+   * Lower-level than accordSetup() — use when you need manual control.
+   */
+  async createSetupSession(params) {
+    return this.api.post(SETUP_API_PATH, {
+      solution: params.solution,
+      vertical: params.vertical,
+      archetype: params.archetype,
+      templateKey: params.templateKey,
+      deliveryMode: params.deliveryMode || "embed",
+      embedOrigin: params.embedOrigin || (typeof window !== "undefined" ? window.location.origin : void 0),
+      redirectUri: params.redirectUri,
+      state: params.state,
+      locale: params.locale || (typeof navigator !== "undefined" ? navigator.language : void 0),
+      constraints: params.constraints,
+      presetId: params.presetId
+    });
+  }
+  /**
+   * High-level: creates a setup session and embeds the wizard in an iframe.
+   *
+   * @example
+   * ```ts
+   * const handle = await overturo.accordSetup({
+   *   solution: "meetings",
+   *   container: "#setup",
+   *   onCreated: ({ flowId }) => console.log("Created:", flowId),
+   * });
+   * ```
+   */
+  async accordSetup(options) {
+    const session = await this.createSetupSession(this.buildSetupParams(options, "embed"));
+    return createSetupEmbed(this.flowBaseUrl, {
+      ...options,
+      sessionToken: session.sessionToken
+    });
+  }
+  /**
+   * Creates a setup session and opens the wizard in a popup window.
+   */
+  async accordSetupPopup(options) {
+    const session = await this.createSetupSession(this.buildSetupParams(options, "popup"));
+    return createSetupPopup(this.flowBaseUrl, {
+      ...options,
+      sessionToken: session.sessionToken
+    });
+  }
+  /**
+   * Creates a setup session and redirects to the wizard (full-page navigation).
+   * On completion, the user is redirected back to `redirectUri` with query params.
+   */
+  async accordSetupRedirect(options) {
+    const session = await this.createSetupSession({
+      ...this.buildSetupParams(options, "redirect"),
+      redirectUri: options.redirectUri,
+      state: options.state
+    });
+    setupRedirect(this.flowBaseUrl, {
+      ...options,
+      sessionToken: session.sessionToken
+    });
+  }
+  // ── Preview ────────────────────────────────────────────────────────
+  /**
+   * Preview a template in an iframe.
+   *
+   * Creates a preview token via the API, then renders the preview in the
+   * specified container. Returns a handle for controlling the preview.
+   *
+   * @example
+   * ```ts
+   * const preview = await overturo.previewTemplate({
+   *   templateId: "tpl_abc123",
+   *   container: "#preview",
+   *   device: "mobile",
+   *   theme: "corporate",
+   * });
+   * preview.setDevice("desktop");
+   * preview.destroy();
+   * ```
+   */
+  async previewTemplate(options) {
+    if (!options.templateId) throw new OverturoValidationError("templateId is required");
+    if (!options.container) throw new OverturoValidationError("container is required");
+    const response = await this.api.post(
+      PREVIEW_TOKENS_PATH,
+      {
+        previewable_type: "template",
+        previewable_id: options.templateId,
+        theme: options.theme,
+        device: options.device,
+        locale: options.locale
+      }
+    );
+    return renderPreview(response.preview_url, options);
+  }
+  /**
+   * Preview a setup session in an iframe.
+   *
+   * Creates a preview token via the API for the specified setup session,
+   * then renders the preview in the specified container.
+   *
+   * @example
+   * ```ts
+   * const preview = await overturo.previewSetup({
+   *   sessionToken: "acs_abc123",
+   *   container: "#preview",
+   * });
+   * preview.setTheme("dark");
+   * preview.destroy();
+   * ```
+   */
+  async previewSetup(options) {
+    if (!options.sessionToken) throw new OverturoValidationError("sessionToken is required");
+    if (!options.container) throw new OverturoValidationError("container is required");
+    const response = await this.api.post(
+      PREVIEW_TOKENS_PATH,
+      {
+        previewable_type: "setup_session",
+        previewable_id: options.sessionToken,
+        theme: options.theme,
+        device: options.device,
+        locale: options.locale
+      }
+    );
+    return renderPreview(response.preview_url, options);
+  }
+  /**
+   * Builds common CreateSetupSessionParams from any setup options variant.
+   */
+  buildSetupParams(options, deliveryMode) {
+    return {
+      solution: options.solution,
+      vertical: options.vertical,
+      archetype: options.archetype,
+      templateKey: options.templateKey,
+      deliveryMode,
+      locale: options.locale,
+      constraints: options.constraints,
+      presetId: options.presetId
+    };
+  }
+};
+
+// src/elements/decision_element.ts
+var ELEMENT_NAME = "overturo-decision";
+var ALREADY_DEFINED_CODE = "OVERTURO_ELEMENT_ALREADY_DEFINED";
+var _shadow, _iframe, _ac, _errorRegion, _DecisionElement_instances, mount_fn, renderClickToOpen_fn, handleEnvelope_fn, emitError_fn, teardown_fn, _onKey;
+var DecisionElement = class extends HTMLElement {
+  constructor() {
+    super();
+    __privateAdd(this, _DecisionElement_instances);
+    __privateAdd(this, _shadow);
+    __privateAdd(this, _iframe, null);
+    __privateAdd(this, _ac, null);
+    __privateAdd(this, _errorRegion, null);
+    __privateAdd(this, _onKey, (event) => {
+      if (event.key === "Escape") {
+        this.dispatchEvent(
+          new CustomEvent("decision:cancel", {
+            detail: { reason: "user_pressed_esc" },
+            bubbles: true,
+            composed: true
+          })
+        );
+        __privateMethod(this, _DecisionElement_instances, teardown_fn).call(this);
+      }
+    });
+    __privateSet(this, _shadow, this.attachShadow({ mode: "open" }));
+  }
+  connectedCallback() {
+    if (!this.hasAttribute("role")) this.setAttribute("role", "region");
+    if (!this.hasAttribute("aria-label")) {
+      this.setAttribute("aria-label", "Loading decision");
+    }
+    this.setAttribute("aria-busy", "true");
+    if (!this.hasAttribute("tabindex")) this.setAttribute("tabindex", "0");
+    this.addEventListener("keydown", __privateGet(this, _onKey));
+    __privateMethod(this, _DecisionElement_instances, mount_fn).call(this);
+  }
+  disconnectedCallback() {
+    this.removeEventListener("keydown", __privateGet(this, _onKey));
+    __privateMethod(this, _DecisionElement_instances, teardown_fn).call(this);
+  }
+  attributeChangedCallback(name, oldValue, newValue) {
+    if (oldValue === newValue) return;
+    if (!this.isConnected) return;
+    if (name === "token" || name === "mode" || name === "flow-base-url" || name === "theme") {
+      __privateMethod(this, _DecisionElement_instances, teardown_fn).call(this);
+      __privateMethod(this, _DecisionElement_instances, mount_fn).call(this);
+    }
+  }
+};
+_shadow = new WeakMap();
+_iframe = new WeakMap();
+_ac = new WeakMap();
+_errorRegion = new WeakMap();
+_DecisionElement_instances = new WeakSet();
+mount_fn = function() {
+  const token = this.getAttribute("token");
+  if (!token) return;
+  const mode = this.getAttribute("mode") ?? "embed";
+  const flowBaseUrl = this.getAttribute("flow-base-url") ?? defaultFlowBaseUrl();
+  if (mode !== "embed") {
+    __privateMethod(this, _DecisionElement_instances, renderClickToOpen_fn).call(this, flowBaseUrl, token, mode);
+    return;
+  }
+  const themeAttr = this.getAttribute("theme");
+  const baseUrl = `${flowBaseUrl.replace(/\/+$/, "")}/decisions/${token}/embed`;
+  const url = themeAttr ? `${baseUrl}?theme=${encodeURIComponent(themeAttr)}` : baseUrl;
+  const expectedOrigin = new URL(url).origin;
+  const iframe = document.createElement("iframe");
+  iframe.src = url;
+  iframe.title = "Overturo decision form";
+  iframe.setAttribute("allow", "popups");
+  iframe.setAttribute("sandbox", "allow-scripts allow-forms allow-same-origin allow-popups");
+  iframe.style.cssText = "width:100%;min-height:400px;border:0;background:transparent;";
+  if (themeAttr) iframe.dataset.theme = themeAttr;
+  const nonce = readCspNonce();
+  if (nonce) iframe.setAttribute("nonce", nonce);
+  iframe.addEventListener("error", () => {
+    this.dispatchEvent(
+      new CustomEvent("decision:error", {
+        detail: {
+          code: "iframe_load_failed",
+          message: "The trust-host iframe failed to load."
+        },
+        bubbles: true,
+        composed: true
+      })
+    );
+    this.setAttribute("aria-busy", "false");
+  });
+  __privateSet(this, _ac, new AbortController());
+  const onMessage = (event) => {
+    if (event.origin !== expectedOrigin || isForeignEnvelope(event.data)) return;
+    const result = validate(event.data);
+    if (!result.valid) {
+      __privateMethod(this, _DecisionElement_instances, emitError_fn).call(this, { code: "protocol_violation" });
+      return;
+    }
+    __privateMethod(this, _DecisionElement_instances, handleEnvelope_fn).call(this, event.data, iframe);
+  };
+  window.addEventListener("message", onMessage, { signal: __privateGet(this, _ac).signal });
+  __privateSet(this, _iframe, iframe);
+  __privateGet(this, _shadow).appendChild(iframe);
+};
+renderClickToOpen_fn = function(flowBaseUrl, token, mode) {
+  const a = document.createElement("a");
+  a.href = `${flowBaseUrl.replace(/\/+$/, "")}/decisions/${token}`;
+  a.target = mode === "popup" ? "_blank" : "_self";
+  a.rel = "noopener noreferrer";
+  a.textContent = "Open decision";
+  a.style.cssText = "display:inline-block;padding:0.5em 1em;text-decoration:none;";
+  __privateGet(this, _shadow).appendChild(a);
+  this.setAttribute("aria-busy", "false");
+};
+handleEnvelope_fn = function(envelope, iframe) {
+  switch (envelope.type) {
+    case MESSAGE_TYPES_V2.READY: {
+      this.setAttribute("aria-busy", "false");
+      const payload = envelope.payload ?? {};
+      const labelSource = (typeof payload.title === "string" ? payload.title : null) ?? payload.branding?.application_name ?? null;
+      if (labelSource) {
+        this.setAttribute("aria-label", labelSource);
+      }
+      this.dispatchEvent(new CustomEvent("decision:ready", { detail: envelope.payload }));
+      break;
+    }
+    case MESSAGE_TYPES_V2.STATE:
+      this.dispatchEvent(
+        new CustomEvent("decision:state", {
+          detail: { kind: envelope.kind, payload: envelope.payload }
+        })
+      );
+      break;
+    case MESSAGE_TYPES_V2.RESIZE: {
+      const height = envelope.payload.height;
+      if (typeof height === "number") iframe.style.height = `${height}px`;
+      break;
+    }
+    case MESSAGE_TYPES_V2.COMPLETE:
+      this.dispatchEvent(
+        new CustomEvent("decision:complete", {
+          detail: { kind: envelope.kind, payload: envelope.payload },
+          bubbles: true,
+          composed: true
+        })
+      );
+      break;
+    case MESSAGE_TYPES_V2.CANCEL:
+      this.dispatchEvent(
+        new CustomEvent("decision:cancel", {
+          detail: envelope.payload,
+          bubbles: true,
+          composed: true
+        })
+      );
+      break;
+    case MESSAGE_TYPES_V2.ERROR:
+      __privateMethod(this, _DecisionElement_instances, emitError_fn).call(this, envelope.payload);
+      break;
+    case MESSAGE_TYPES_V2.DEADLINE:
+      this.dispatchEvent(new CustomEvent("decision:deadline", { detail: envelope.payload }));
+      break;
+  }
+};
+emitError_fn = function(payload) {
+  this.dispatchEvent(new CustomEvent("decision:error", { detail: payload, bubbles: true }));
+  if (!__privateGet(this, _errorRegion)) {
+    __privateSet(this, _errorRegion, document.createElement("div"));
+    __privateGet(this, _errorRegion).setAttribute("role", "alert");
+    __privateGet(this, _errorRegion).setAttribute("aria-live", "assertive");
+    __privateGet(this, _errorRegion).style.cssText = "position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);";
+    __privateGet(this, _shadow).appendChild(__privateGet(this, _errorRegion));
+  }
+  const msg = typeof payload.message === "string" ? payload.message : "An error occurred. Please try again.";
+  __privateGet(this, _errorRegion).textContent = msg;
+  window.setTimeout(() => {
+    if (__privateGet(this, _errorRegion)) __privateGet(this, _errorRegion).textContent = "";
+  }, 3e4);
+};
+teardown_fn = function() {
+  if (__privateGet(this, _ac)) {
+    __privateGet(this, _ac).abort();
+    __privateSet(this, _ac, null);
+  }
+  if (__privateGet(this, _iframe) && __privateGet(this, _iframe).parentNode) {
+    __privateGet(this, _iframe).parentNode.removeChild(__privateGet(this, _iframe));
+  }
+  __privateSet(this, _iframe, null);
+  if (__privateGet(this, _errorRegion)) {
+    __privateGet(this, _errorRegion).textContent = "";
+  }
+  this.setAttribute("aria-busy", "true");
+};
+_onKey = new WeakMap();
+DecisionElement.observedAttributes = ["token", "mode", "theme", "flow-base-url"];
+function readCspNonce() {
+  if (typeof document === "undefined") return null;
+  const meta = document.querySelector('meta[name="csp-nonce"]');
+  return meta?.getAttribute("content") ?? null;
+}
+function defaultFlowBaseUrl() {
+  if (typeof window !== "undefined") return window.location.origin;
+  return "https://overturo.com";
+}
+function registerDecisionElement() {
+  if (typeof customElements === "undefined") return;
+  if (customElements.get(ELEMENT_NAME)) {
+    console.warn("[overturo:sdk]", ALREADY_DEFINED_CODE, `<${ELEMENT_NAME}> already registered; skipping.`);
+    return;
+  }
+  customElements.define(ELEMENT_NAME, DecisionElement);
+}
+
+// src/elements/index.ts
+registerDecisionElement();
+export {
+  ALREADY_DEFINED_CODE,
+  DecisionElement,
+  ELEMENT_NAME,
+  OapAuthorizationDenied,
+  OapDenied,
+  OapIntentDenied,
+  OapSequenceDenied,
+  OapTrajectoryDenied,
+  Overturo,
+  OverturoApiError,
+  OverturoError,
+  OverturoNetworkError,
+  OverturoTimeoutError,
+  OverturoValidationError,
+  createSetupEmbed,
+  createSetupPopup,
+  Overturo as default,
+  registerDecisionElement,
+  setupRedirect
+};
+//# sourceMappingURL=index.js.map