@supertokens-plugins/rownd-nodejs 0.2.0 → 0.3.0-beta.0

package/dist/index.js

@@ -0,0 +1,2752 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/supertokens-js-override/lib/build/getProxyObject.js
+var require_getProxyObject = __commonJS({
+  "../../node_modules/supertokens-js-override/lib/build/getProxyObject.js"(exports2) {
+    "use strict";
+    var __assign = exports2 && exports2.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getProxyObject = void 0;
+    function getProxyObject(orig) {
+      var ret = __assign(__assign({}, orig), { _call: function(_, __) {
+        throw new Error("This function should only be called through the recipe object");
+      } });
+      var keys = Object.keys(ret);
+      var _loop_1 = function(k2) {
+        if (k2 !== "_call") {
+          ret[k2] = function() {
+            var args = [];
+            for (var _i2 = 0; _i2 < arguments.length; _i2++) {
+              args[_i2] = arguments[_i2];
+            }
+            return this._call(k2, args);
+          };
+        }
+      };
+      for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+        var k = keys_1[_i];
+        _loop_1(k);
+      }
+      return ret;
+    }
+    exports2.getProxyObject = getProxyObject;
+  }
+});
+
+// ../../node_modules/supertokens-js-override/lib/build/index.js
+var require_build = __commonJS({
+  "../../node_modules/supertokens-js-override/lib/build/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.OverrideableBuilder = void 0;
+    var getProxyObject_1 = require_getProxyObject();
+    var OverrideableBuilder2 = (
+      /** @class */
+      (function() {
+        function OverrideableBuilder3(originalImplementation) {
+          this.layers = [originalImplementation];
+          this.proxies = [];
+        }
+        OverrideableBuilder3.prototype.override = function(overrideFunc) {
+          var proxy = (0, getProxyObject_1.getProxyObject)(this.layers[0]);
+          var layer = overrideFunc(proxy, this);
+          for (var _i = 0, _a = Object.keys(this.layers[0]); _i < _a.length; _i++) {
+            var key = _a[_i];
+            if (layer[key] === proxy[key] || key === "_call") {
+              delete layer[key];
+            } else if (layer[key] === void 0) {
+              layer[key] = null;
+            }
+          }
+          this.layers.push(layer);
+          this.proxies.push(proxy);
+          return this;
+        };
+        OverrideableBuilder3.prototype.build = function() {
+          var _this = this;
+          if (this.result) {
+            return this.result;
+          }
+          this.result = {};
+          for (var _i = 0, _a = this.layers; _i < _a.length; _i++) {
+            var layer = _a[_i];
+            for (var _b = 0, _c = Object.keys(layer); _b < _c.length; _b++) {
+              var key = _c[_b];
+              var override = layer[key];
+              if (override !== void 0) {
+                if (override === null) {
+                  this.result[key] = void 0;
+                } else if (typeof override === "function") {
+                  this.result[key] = override.bind(this.result);
+                } else {
+                  this.result[key] = override;
+                }
+              }
+            }
+          }
+          var _loop_1 = function(proxyInd2) {
+            var proxy = this_1.proxies[proxyInd2];
+            proxy._call = function(fname, args) {
+              for (var i = proxyInd2; i >= 0; --i) {
+                var func = _this.layers[i][fname];
+                if (func !== void 0 && func !== null) {
+                  return func.bind(_this.result).apply(void 0, args);
+                }
+              }
+            };
+          };
+          var this_1 = this;
+          for (var proxyInd = 0; proxyInd < this.proxies.length; ++proxyInd) {
+            _loop_1(proxyInd);
+          }
+          return this.result;
+        };
+        return OverrideableBuilder3;
+      })()
+    );
+    exports2.OverrideableBuilder = OverrideableBuilder2;
+    exports2.default = OverrideableBuilder2;
+  }
+});
+
+// ../../node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "../../node_modules/has-flag/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (flag, argv = process.argv) => {
+      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+      const position = argv.indexOf(prefix + flag);
+      const terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+    };
+  }
+});
+
+// ../../node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+  "../../node_modules/supports-color/index.js"(exports2, module2) {
+    "use strict";
+    var os = require("os");
+    var tty = require("tty");
+    var hasFlag = require_has_flag();
+    var { env } = process;
+    var forceColor;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      forceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      forceColor = 1;
+    }
+    if ("FORCE_COLOR" in env) {
+      if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+      } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+      } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+      }
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(haveStream, streamIsTTY) {
+      if (forceColor === 0) {
+        return 0;
+      }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
+      }
+      if (haveStream && !streamIsTTY && forceColor === void 0) {
+        return 0;
+      }
+      const min = forceColor || 0;
+      if (env.TERM === "dumb") {
+        return min;
+      }
+      if (process.platform === "win32") {
+        const osRelease = os.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if (env.COLORTERM === "truecolor") {
+        return 3;
+      }
+      if ("TERM_PROGRAM" in env) {
+        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version >= 3 ? 3 : 2;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env) {
+        return 1;
+      }
+      return min;
+    }
+    function getSupportLevel(stream) {
+      const level = supportsColor(stream, stream && stream.isTTY);
+      return translateLevel(level);
+    }
+    module2.exports = {
+      supportsColor: getSupportLevel,
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ANONYMOUS_AUTH_METHOD_ID: () => ANONYMOUS_AUTH_METHOD_ID,
+  DEFAULT_ROWND_SCHEMA: () => DEFAULT_ROWND_SCHEMA,
+  GUEST_AUTH_METHOD_ID: () => GUEST_AUTH_METHOD_ID,
+  HANDLE_BASE_PATH: () => HANDLE_BASE_PATH,
+  PLUGIN_ID: () => PLUGIN_ID,
+  PLUGIN_SDK_VERSION: () => PLUGIN_SDK_VERSION,
+  PUBLIC_TENANT_ID: () => PUBLIC_TENANT_ID,
+  ROWND_JWT_CLAIMS: () => ROWND_JWT_CLAIMS,
+  ROWND_PLUGIN_ERROR_MESSAGES: () => ROWND_PLUGIN_ERROR_MESSAGES,
+  RowndPluginError: () => RowndPluginError,
+  default: () => index_default,
+  getRowndClient: () => getRowndClient,
+  init: () => init,
+  setRowndClient: () => setRowndClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../../shared/js/src/createPluginInit.ts
+var import_supertokens_js_override = __toESM(require_build());
+var createPluginInitFunction = (init2, getImplementation, getNormalisedConfig = (config2) => config2) => {
+  const getNormalizedImplementation = typeof getImplementation === "function" ? getImplementation : (_config) => getImplementation || {};
+  return (inputConfig) => {
+    const config2 = getNormalisedConfig(inputConfig || {});
+    const baseImplementation = getNormalizedImplementation(config2);
+    const overrideBuilder = new import_supertokens_js_override.OverrideableBuilder(baseImplementation);
+    if (inputConfig?.override) {
+      overrideBuilder.override(inputConfig.override);
+    }
+    const actualImplementation = overrideBuilder.build();
+    return init2(config2, actualImplementation);
+  };
+};
+
+// ../../shared/nodejs/src/pluginUserMetadata.ts
+var import_usermetadata = __toESM(require("supertokens-node/recipe/usermetadata"));
+
+// ../../shared/nodejs/src/withRequestHandler.ts
+var withRequestHandler = (fn) => {
+  return async (req, res, session, userContext) => {
+    const result = await fn(req, res, session, userContext);
+    if (result.status === "OK") {
+      res.setStatusCode(200);
+    } else {
+      res.setStatusCode(Number(result.code) || 400);
+    }
+    res.sendJSONResponse(result);
+    return null;
+  };
+};
+
+// ../../shared/nodejs/src/log/logger.ts
+var import_util = __toESM(require("util"));
+
+// ../../shared/nodejs/src/log/common.ts
+function setup(env) {
+  createDebug.debug = createDebug;
+  createDebug.default = createDebug;
+  createDebug.coerce = coerce;
+  createDebug.disable = disable;
+  createDebug.enable = enable;
+  createDebug.enabled = enabled;
+  createDebug.humanize = env.humanize;
+  createDebug.destroy = destroy;
+  Object.keys(env).forEach((key) => {
+    createDebug[key] = env[key];
+  });
+  createDebug.names = [];
+  createDebug.skips = [];
+  createDebug.formatters = {};
+  function selectColor(namespace) {
+    let hash = 0;
+    for (let i = 0; i < namespace.length; i++) {
+      hash = (hash << 5) - hash + namespace.charCodeAt(i);
+      hash |= 0;
+    }
+    return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+  }
+  createDebug.selectColor = selectColor;
+  function createDebug(namespace) {
+    let prevTime;
+    let enableOverride = null;
+    let namespacesCache;
+    let enabledCache;
+    function debug(...args) {
+      if (!debug.enabled) {
+        return;
+      }
+      const self = debug;
+      const curr = Number(/* @__PURE__ */ new Date());
+      const ms = curr - (prevTime || curr);
+      self.diff = ms;
+      self.prev = prevTime;
+      self.curr = curr;
+      prevTime = curr;
+      args[0] = createDebug.coerce(args[0]);
+      if (typeof args[0] !== "string") {
+        args.unshift("%O");
+      }
+      let index = 0;
+      args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+        if (match === "%%") {
+          return "%";
+        }
+        index++;
+        const formatter = createDebug.formatters[format];
+        if (typeof formatter === "function") {
+          const val = args[index];
+          match = formatter.call(self, val);
+          args.splice(index, 1);
+          index--;
+        }
+        return match;
+      });
+      createDebug.formatArgs.call(self, args);
+      const logFn = self.log || createDebug.log;
+      logFn.apply(self, args);
+    }
+    debug.namespace = namespace;
+    debug.useColors = createDebug.useColors();
+    debug.color = createDebug.selectColor(namespace);
+    debug.extend = extend;
+    debug.destroy = createDebug.destroy;
+    Object.defineProperty(debug, "enabled", {
+      enumerable: true,
+      configurable: false,
+      get: () => {
+        if (enableOverride !== null) {
+          return enableOverride;
+        }
+        if (namespacesCache !== createDebug.namespaces) {
+          namespacesCache = createDebug.namespaces;
+          enabledCache = createDebug.enabled(namespace);
+        }
+        return enabledCache;
+      },
+      set: (v) => {
+        enableOverride = v;
+      }
+    });
+    if (typeof createDebug.init === "function") {
+      createDebug.init(debug);
+    }
+    return debug;
+  }
+  function extend(namespace, delimiter) {
+    const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+    newDebug.log = this.log;
+    return newDebug;
+  }
+  function enable(namespaces) {
+    createDebug.save(namespaces);
+    createDebug.namespaces = namespaces;
+    createDebug.names = [];
+    createDebug.skips = [];
+    const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+    for (const ns of split) {
+      if (ns[0] === "-") {
+        createDebug.skips.push(ns.slice(1));
+      } else {
+        createDebug.names.push(ns);
+      }
+    }
+  }
+  function matchesTemplate(search, template) {
+    let searchIndex = 0;
+    let templateIndex = 0;
+    let starIndex = -1;
+    let matchIndex = 0;
+    while (searchIndex < search.length) {
+      if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+        if (template[templateIndex] === "*") {
+          starIndex = templateIndex;
+          matchIndex = searchIndex;
+          templateIndex++;
+        } else {
+          searchIndex++;
+          templateIndex++;
+        }
+      } else if (starIndex !== -1) {
+        templateIndex = starIndex + 1;
+        matchIndex++;
+        searchIndex = matchIndex;
+      } else {
+        return false;
+      }
+    }
+    while (templateIndex < template.length && template[templateIndex] === "*") {
+      templateIndex++;
+    }
+    return templateIndex === template.length;
+  }
+  function disable() {
+    const namespaces = [...createDebug.names, ...createDebug.skips.map((namespace) => "-" + namespace)].join(",");
+    createDebug.enable("");
+    return namespaces;
+  }
+  function enabled(name) {
+    for (const skip of createDebug.skips) {
+      if (matchesTemplate(name, skip)) {
+        return false;
+      }
+    }
+    for (const ns of createDebug.names) {
+      if (matchesTemplate(name, ns)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function coerce(val) {
+    if (val instanceof Error) {
+      return val.stack || val.message;
+    }
+    return val;
+  }
+  function destroy() {
+    console.warn(
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
+  }
+  createDebug.enable(createDebug.load());
+  return createDebug;
+}
+var common_default = setup;
+
+// ../../shared/nodejs/src/log/logger.ts
+var BASIC_COLORS = [6, 2, 3, 4, 5, 1];
+var EXTENDED_COLORS = [
+  20,
+  21,
+  26,
+  27,
+  32,
+  33,
+  38,
+  39,
+  40,
+  41,
+  42,
+  43,
+  44,
+  45,
+  56,
+  57,
+  62,
+  63,
+  68,
+  69,
+  74,
+  75,
+  76,
+  77,
+  78,
+  79,
+  80,
+  81,
+  92,
+  93,
+  98,
+  99,
+  112,
+  113,
+  128,
+  129,
+  134,
+  135,
+  148,
+  149,
+  160,
+  161,
+  162,
+  163,
+  164,
+  165,
+  166,
+  167,
+  168,
+  169,
+  170,
+  171,
+  172,
+  173,
+  178,
+  179,
+  184,
+  185,
+  196,
+  197,
+  198,
+  199,
+  200,
+  201,
+  202,
+  203,
+  204,
+  205,
+  206,
+  207,
+  208,
+  209,
+  214,
+  215,
+  220,
+  221
+];
+function supportsExtendedColors() {
+  try {
+    const supportsColor = require_supports_color();
+    return supportsColor && (supportsColor.stderr || supportsColor).level >= 2;
+  } catch {
+    return false;
+  }
+}
+function shouldUseColors() {
+  return false;
+}
+function formatArgs(args) {
+  const { namespace, useColors, color } = this;
+  if (useColors) {
+    const colorCode = color < 8 ? `3${color}` : `38;5;${color}`;
+    const prefix = `\x1B[${colorCode};1m${namespace}\x1B[0m`;
+    args[0] = `${prefix} ${args[0]}`.split("\n").join(`
+${prefix} `);
+    args.push(`\x1B[${colorCode}m+${humanizeTime(this.diff)}\x1B[0m`);
+  } else {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    args[0] = `${timestamp} ${namespace} ${args[0]}`;
+  }
+}
+function writeOutput(...args) {
+  process.stderr.write(import_util.default.format(...args) + "\n");
+}
+function saveConfig(namespaces) {
+  if (namespaces) {
+    process.env.DEBUG = namespaces;
+  } else {
+    delete process.env.DEBUG;
+  }
+}
+function loadConfig() {
+  return process.env.DEBUG;
+}
+function humanizeTime(milliseconds) {
+  if (milliseconds >= 1e3) {
+    const seconds = Math.round(milliseconds / 1e3);
+    return `${seconds}s`;
+  }
+  return `${milliseconds}ms`;
+}
+function createLoggerConfig() {
+  const colors = supportsExtendedColors() ? EXTENDED_COLORS : BASIC_COLORS;
+  return {
+    colors,
+    useColors: shouldUseColors,
+    formatArgs,
+    log: writeOutput,
+    save: saveConfig,
+    load: loadConfig,
+    humanize: humanizeTime
+  };
+}
+var config = createLoggerConfig();
+var logger = common_default(config);
+if (logger.formatters) {
+  logger.formatters.o = function(value) {
+    return import_util.default.inspect(value, { colors: this.useColors, compact: true }).split("\n").map((line) => line.trim()).join(" ");
+  };
+  logger.formatters.O = function(value) {
+    return import_util.default.inspect(value, { colors: this.useColors, compact: false });
+  };
+}
+var logger_default = logger;
+
+// ../../shared/nodejs/src/log/index.ts
+var log_default = logger_default;
+
+// ../../shared/nodejs/src/logger.ts
+var getFileLocation = () => {
+  let errorObject = new Error();
+  if (errorObject.stack === void 0) {
+    return "N/A";
+  }
+  let errorStack = errorObject.stack.split("\n");
+  for (let i = 1; i < errorStack.length; i++) {
+    if (!errorStack[i]?.includes("logger.js")) {
+      return errorStack[i]?.match(/(?<=\().+?(?=\))/g);
+    }
+  }
+  return "N/A";
+};
+var buildLogger = (pluginId, version, { fileLocation = true } = {}) => {
+  const namespace = `com.supertokens.plugin.${pluginId}`;
+  function logDebugMessage2(message) {
+    if (log_default.enabled(namespace)) {
+      log_default(namespace)(
+        `{t: "${(/* @__PURE__ */ new Date()).toISOString()}", message: "${message}", file: "${fileLocation ? getFileLocation() : "N/A"}" version: "${version}"}`
+      );
+      console.log();
+    }
+  }
+  function enableDebugLogs2() {
+    log_default.enable(namespace);
+  }
+  return {
+    logDebugMessage: logDebugMessage2,
+    enableDebugLogs: enableDebugLogs2
+  };
+};
+
+// src/plugin.ts
+var import_node = require("@rownd/node");
+var import_supertokens_node2 = __toESM(require("supertokens-node"));
+
+// src/constants.ts
+var PLUGIN_ID = "supertokens-plugin-rownd";
+var PLUGIN_SDK_VERSION = ["23.0.0", "23.0.1", ">=23.0.1"];
+var HANDLE_BASE_PATH = "/plugin/rownd";
+var PUBLIC_TENANT_ID = "public";
+var GUEST_AUTH_METHOD_ID = "guest";
+var ANONYMOUS_AUTH_METHOD_ID = "anonymous";
+var ROWND_JWT_CLAIMS = {
+  AppUserId: "https://auth.rownd.io/app_user_id",
+  IsVerifiedUser: "https://auth.rownd.io/is_verified_user",
+  IsAnonymous: "https://auth.rownd.io/is_anonymous",
+  IssuedOffline: "https://auth.rownd.io/issued_offline",
+  JwtType: "https://auth.rownd.io/jwt_type",
+  PlatformJwt: "https://auth.rownd.io/platform_jwt",
+  AuthLevel: "https://auth.rownd.io/auth_level"
+};
+var DEFAULT_ROWND_SCHEMA = {
+  zip_code: {
+    display_name: "Zip code",
+    type: "string",
+    user_visible: true
+  },
+  last_name: {
+    display_name: "Last name",
+    type: "string",
+    user_visible: true
+  },
+  nick_name: {
+    display_name: "Nick name",
+    type: "string",
+    user_visible: true
+  },
+  first_name: {
+    display_name: "First name",
+    type: "string",
+    user_visible: true
+  }
+};
+
+// src/logger.ts
+var { logDebugMessage, enableDebugLogs } = buildLogger(
+  PLUGIN_ID,
+  PLUGIN_SDK_VERSION
+);
+
+// src/telemetry/axiomTelemetryClient.ts
+var DEFAULT_AXIOM_URL = "https://api.axiom.co/v1/datasets";
+var AxiomTelemetryClient = class {
+  constructor(token, dataset, endpoint) {
+    this.token = token;
+    this.dataset = dataset;
+    const baseUrl = (endpoint ?? DEFAULT_AXIOM_URL).replace(/\/$/, "");
+    this.url = `${baseUrl}/${dataset}/ingest`;
+  }
+  token;
+  dataset;
+  url;
+  async recordEvent(event) {
+    await fetch(this.url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify([
+        {
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          plugin: PLUGIN_ID,
+          ...event
+        }
+      ])
+    });
+  }
+};
+
+// src/telemetry/openTelemetryClient.ts
+var import_api = require("@opentelemetry/api");
+var OpenTelemetryClient = class {
+  recordEvent(event) {
+    const tracer = import_api.trace.getTracer("supertokens-plugin-rownd", "0.1.0");
+    const span = tracer.startSpan("rownd.migrate");
+    span.setAttributes({
+      "rownd.outcome": event.outcome,
+      "rownd.duration_ms": event.durationMs,
+      "rownd.tenant_id": event.tenantId ?? "",
+      "rownd.rownd_user_id": event.rowndUserId ?? "",
+      "rownd.supertokens_user_id": event.superTokensUserId ?? ""
+    });
+    if (event.outcome === "error") {
+      const err = new Error(event.error.message);
+      if (event.error.name) {
+        err.name = event.error.name;
+      }
+      span.recordException(err);
+      span.setStatus({
+        code: import_api.SpanStatusCode.ERROR,
+        message: event.error.message
+      });
+    } else {
+      span.setStatus({ code: import_api.SpanStatusCode.OK });
+    }
+    span.end();
+  }
+};
+
+// src/telemetry/createTelemetryClient.ts
+function createClient(telemetryConfig) {
+  let client;
+  if (telemetryConfig?.provider === "opentelemetry") {
+    client = new OpenTelemetryClient();
+  } else if (telemetryConfig?.provider === "axiom") {
+    client = new AxiomTelemetryClient(
+      telemetryConfig.token,
+      telemetryConfig.dataset,
+      telemetryConfig.url
+    );
+  } else if (telemetryConfig?.provider === "custom") {
+    client = telemetryConfig.factory();
+  }
+  return {
+    recordSuccess: (event) => {
+      if (!client) {
+        return;
+      }
+      safeRecordEvent(client, event, "success");
+    },
+    recordError: (input) => {
+      if (!client) {
+        return;
+      }
+      const event = {
+        outcome: "error",
+        durationMs: Date.now() - input.startedAt,
+        tenantId: input.tenantId,
+        rowndUserId: input.rowndUserId,
+        superTokensUserId: input.superTokensUserId,
+        error: {
+          message: input.error instanceof Error ? input.error.message : "Unknown error",
+          name: input.error instanceof Error ? input.error.name : void 0
+        }
+      };
+      safeRecordEvent(client, event, "error");
+    }
+  };
+}
+function safeRecordEvent(client, event, outcome) {
+  try {
+    Promise.resolve(client.recordEvent(event)).catch((error) => {
+      logDebugMessage(
+        `Failed to record telemetry ${outcome} event. Error: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    });
+  } catch (error) {
+    logDebugMessage(
+      `Failed to record telemetry ${outcome} event. Error: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+
+// src/pluginImplementation.ts
+var import_crypto = require("crypto");
+var import_supertokens_node = __toESM(require("supertokens-node"));
+var import_accountlinking = __toESM(require("supertokens-node/recipe/accountlinking"));
+var import_emailverification = __toESM(require("supertokens-node/recipe/emailverification"));
+var import_passwordless = __toESM(require("supertokens-node/recipe/passwordless"));
+var import_session = __toESM(require("supertokens-node/recipe/session"));
+var import_claims = require("supertokens-node/recipe/session/claims");
+var import_thirdparty = __toESM(require("supertokens-node/recipe/thirdparty"));
+var import_usermetadata2 = __toESM(require("supertokens-node/recipe/usermetadata"));
+
+// src/errors.ts
+var ROWND_PLUGIN_ERROR_MESSAGES = {
+  MISSING_AUTHORIZATION_HEADER: "Missing authorization header",
+  INVALID_TOKEN: "Invalid token",
+  ROWND_USER_NOT_FOUND: "User not found in Rownd"
+};
+var RowndPluginError = class extends Error {
+  constructor(type) {
+    super(ROWND_PLUGIN_ERROR_MESSAGES[type]);
+  }
+};
+
+// src/pluginImplementation.ts
+function rewriteLinkPath(inputUrl, targetPath, searchParams) {
+  try {
+    const url = new URL(inputUrl);
+    url.pathname = `/${targetPath.replace(/^\//, "")}`;
+    for (const [key, value] of Object.entries(searchParams ?? {})) {
+      url.searchParams.set(key, value);
+    }
+    return url.toString();
+  } catch {
+    const [path = inputUrl, query = ""] = inputUrl.replace(/auth\/verify[^?]*/, targetPath).split("?");
+    const params = new URLSearchParams(query);
+    for (const [key, value] of Object.entries(searchParams ?? {})) {
+      params.set(key, value);
+    }
+    const queryString = params.toString();
+    return queryString ? `${path}?${queryString}` : path;
+  }
+}
+var rowndClient;
+var pluginConfig;
+function setRowndClient(client) {
+  rowndClient = client;
+}
+function getRowndClient() {
+  if (!rowndClient) {
+    throw new Error("Rownd client not initialized");
+  }
+  return rowndClient;
+}
+function setPluginConfig(config2) {
+  pluginConfig = config2;
+}
+async function parseRequest(req) {
+  const authHeader = req.getHeaderValue("authorization");
+  if (!authHeader) {
+    throw new RowndPluginError("MISSING_AUTHORIZATION_HEADER");
+  }
+  const token = authHeader.replace(/^Bearer /i, "");
+  if (!token) {
+    throw new RowndPluginError("INVALID_TOKEN");
+  }
+  return {
+    token
+  };
+}
+function handleGetAppConfig(deps) {
+  return async (req) => {
+    const appVariantId = getRequestedAppVariantIdFromRequest(req);
+    const appConfig = buildAppConfig(
+      deps.pluginConfig,
+      deps.stConfig,
+      appVariantId
+    );
+    if (!appConfig) {
+      return {
+        status: "ERROR",
+        message: `Unknown Rownd app variant: ${appVariantId}`
+      };
+    }
+    return {
+      status: "OK",
+      ...appConfig
+    };
+  };
+}
+function handleGuestLogin(deps) {
+  return async (req, res, _session, userContext) => {
+    const startedAt = Date.now();
+    const guestId = `guest_${(0, import_crypto.randomUUID)()}`;
+    try {
+      const body = parseGuestBody(await getJsonBody(req));
+      const appVariantId = getRequestedAppVariantIdFromRequest(req);
+      assertRowndAppVariantIsConfigured(appVariantId);
+      const thirdPartyId = body.authLevel === ANONYMOUS_AUTH_METHOD_ID ? ANONYMOUS_AUTH_METHOD_ID : GUEST_AUTH_METHOD_ID;
+      const thirdPartyUserId = thirdPartyId === ANONYMOUS_AUTH_METHOD_ID ? `anon_${(0, import_crypto.randomUUID)()}` : guestId;
+      const response = await import_thirdparty.default.manuallyCreateOrUpdateUser(
+        PUBLIC_TENANT_ID,
+        thirdPartyId,
+        thirdPartyUserId,
+        `${thirdPartyUserId}@anonymous.local`,
+        false,
+        void 0,
+        userContext
+      );
+      if (response.status !== "OK") {
+        throw new Error(
+          `Guest user creation failed with status: ${response.status}`
+        );
+      }
+      await import_session.default.createNewSession(
+        req,
+        res,
+        PUBLIC_TENANT_ID,
+        response.recipeUserId,
+        {
+          ...buildRowndAudience({}, appVariantId),
+          auth_level: GUEST_AUTH_METHOD_ID,
+          is_anonymous: true,
+          app_user_id: response.user.id
+        },
+        {},
+        userContext
+      );
+      logDebugMessage(`Guest session created for user: ${response.user.id}`);
+      deps.telemetryClient.recordSuccess({
+        outcome: "success",
+        durationMs: Date.now() - startedAt,
+        tenantId: PUBLIC_TENANT_ID,
+        superTokensUserId: response.user.id
+      });
+      return {
+        status: "OK",
+        createdNewRecipeUser: response.createdNewRecipeUser
+      };
+    } catch (error) {
+      logDebugMessage(`Guest login failed. Error: ${getErrorMessage(error)}`);
+      deps.telemetryClient.recordError({
+        error,
+        startedAt,
+        tenantId: PUBLIC_TENANT_ID
+      });
+      return {
+        status: "ERROR",
+        message: "Guest login failed"
+      };
+    }
+  };
+}
+function handleMigrate(deps) {
+  return async (req, res, _session, userContext) => {
+    const startedAt = Date.now();
+    let tenantId = PUBLIC_TENANT_ID;
+    let rowndUserId;
+    let superTokensUserId;
+    let user;
+    let recipeUserId;
+    try {
+      if (!deps.stConfig.supertokens) {
+        throw new Error("Supertokens config not found");
+      }
+      const parsed = await parseRequest(req);
+      const appVariantId = getRequestedAppVariantIdFromRequest(req);
+      assertRowndAppVariantIsConfigured(appVariantId);
+      rowndUserId = await validateRowndToken(parsed.token);
+      user = await import_supertokens_node.default.getUser(rowndUserId, userContext);
+      if (!user) {
+        const rowndUser = await fetchRowndUserInfo(rowndUserId);
+        const stUserImport = mapRowndUserToSuperTokens(rowndUser);
+        try {
+          const importedUser = await importUser(
+            stUserImport,
+            deps.stConfig.supertokens
+          );
+          superTokensUserId = importedUser.id;
+          if (importedUser.loginMethods[0]?.recipeUserId) {
+            recipeUserId = import_supertokens_node.default.convertToRecipeUserId(
+              importedUser.loginMethods[0].recipeUserId
+            );
+          }
+        } catch (err) {
+          user = await import_supertokens_node.default.getUser(rowndUserId, userContext);
+          if (!user) {
+            throw err;
+          }
+          superTokensUserId = user.id;
+          recipeUserId = user.loginMethods[0]?.recipeUserId;
+          logDebugMessage(
+            `User already migrated (race condition). tenantId: ${PUBLIC_TENANT_ID}, rowndUserId: ${rowndUserId}`
+          );
+        }
+        logDebugMessage(
+          `User migrated successfully. tenantId: ${PUBLIC_TENANT_ID}, rowndUserId: ${rowndUserId}`
+        );
+      } else {
+        superTokensUserId = user.id;
+        recipeUserId = user.loginMethods[0]?.recipeUserId;
+        logDebugMessage(
+          `User already migrated. tenantId: ${PUBLIC_TENANT_ID}, rowndUserId: ${rowndUserId}`
+        );
+      }
+      if (superTokensUserId) {
+        await recordRowndAppVariantForUser(superTokensUserId, appVariantId);
+      }
+      if (!recipeUserId) {
+        throw new Error("User not found or has no login methods");
+      }
+      await import_session.default.createNewSession(
+        req,
+        res,
+        PUBLIC_TENANT_ID,
+        recipeUserId,
+        {
+          ...buildRowndAudience({}, appVariantId)
+        },
+        {},
+        userContext
+      );
+      logDebugMessage(
+        `Session migrated successfully. tenantId: ${PUBLIC_TENANT_ID}, userId: ${superTokensUserId}`
+      );
+      deps.telemetryClient.recordSuccess({
+        outcome: "success",
+        durationMs: Date.now() - startedAt,
+        tenantId,
+        rowndUserId,
+        superTokensUserId
+      });
+      return { status: "OK" };
+    } catch (error) {
+      logDebugMessage(`Migration failed. Error: ${getErrorMessage(error)}`);
+      deps.telemetryClient.recordError({
+        error,
+        startedAt,
+        tenantId,
+        rowndUserId,
+        superTokensUserId
+      });
+      return {
+        status: "ERROR",
+        message: error instanceof RowndPluginError ? error.message : "Migration failed"
+      };
+    }
+  };
+}
+function handleGetUser() {
+  return async (_req, _res, maybeSession) => {
+    const session = requireSession(maybeSession);
+    return {
+      status: "OK",
+      ...await getUserById(session.getUserId())
+    };
+  };
+}
+function handleUpdateUser() {
+  return async (req, _res, maybeSession, userContext) => {
+    const session = requireSession(maybeSession);
+    const appVariantId = getRequestedAppVariantIdFromRequest(req);
+    assertRowndAppVariantIsConfigured(appVariantId);
+    const payload = parseUpdateUserBody(await getJsonBody(req));
+    const inputData = payload.data ?? {};
+    const requestUserContext = {
+      ...userContext,
+      ...payload.context
+    };
+    const { email, ...dataWithoutEmail } = inputData;
+    const hasEmailUpdate = hasOwn(inputData, "email") && typeof email === "string";
+    const permissionError = validateWritableFields(
+      Object.keys(dataWithoutEmail)
+    );
+    if (permissionError) {
+      return permissionError;
+    }
+    if (Object.keys(dataWithoutEmail).length > 0) {
+      await updateUserData(session.getUserId(), dataWithoutEmail);
+    }
+    if (hasEmailUpdate) {
+      return {
+        status: "OK",
+        ...await startPendingEmailVerification({
+          userId: session.getUserId(),
+          recipeUserId: session.getRecipeUserId(),
+          tenantId: session.getTenantId(),
+          email,
+          pendingVerificationId: (0, import_crypto.randomUUID)(),
+          userContext: appVariantId ? { ...requestUserContext, rowndAppVariantId: appVariantId } : requestUserContext
+        })
+      };
+    }
+    return {
+      status: "OK",
+      ...await getUserById(session.getUserId())
+    };
+  };
+}
+function handleDeleteUser() {
+  return async (_req, _res, maybeSession) => {
+    const session = requireSession(maybeSession);
+    await import_supertokens_node.default.deleteUser(session.getUserId(), true);
+    return { status: "OK" };
+  };
+}
+function handleSignOut() {
+  return async (_req, _res, maybeSession, userContext) => {
+    const session = requireSession(maybeSession);
+    await import_session.default.revokeAllSessionsForUser(
+      session.getUserId(),
+      true,
+      session.getTenantId(),
+      userContext
+    );
+    return { status: "OK" };
+  };
+}
+function handleGetUserMeta() {
+  return async (_req, _res, maybeSession) => {
+    const session = requireSession(maybeSession);
+    const metadata = await getUserMetadata(session.getUserId());
+    return {
+      status: "OK",
+      id: session.getUserId(),
+      meta: Object.fromEntries(
+        Object.entries(metadata).filter(
+          ([key]) => !isInternalMetadataField(key)
+        )
+      )
+    };
+  };
+}
+function handleUpdateUserMeta() {
+  return async (req, _res, maybeSession) => {
+    const session = requireSession(maybeSession);
+    const payload = parseUpdateMetaBody(await getJsonBody(req));
+    const internalField = Object.keys(payload.meta ?? {}).find(
+      isInternalMetadataField
+    );
+    if (internalField) {
+      return {
+        status: "ERROR",
+        code: 403,
+        message: `field is not writable: ${internalField}`
+      };
+    }
+    return {
+      status: "OK",
+      ...await updateUserMetadata(session.getUserId(), payload.meta ?? {})
+    };
+  };
+}
+function handleGetUserField() {
+  return async (req, _res, maybeSession) => {
+    const session = requireSession(maybeSession);
+    const field = req.getKeyValueFromQuery("field");
+    if (!field) {
+      return missingFieldResponse();
+    }
+    const user = await getUserById(session.getUserId());
+    return {
+      status: "OK",
+      value: user.data[field]
+    };
+  };
+}
+function handleUpdateUserField() {
+  return async (req, _res, maybeSession, userContext) => {
+    const session = requireSession(maybeSession);
+    const appVariantId = getRequestedAppVariantIdFromRequest(req);
+    assertRowndAppVariantIsConfigured(appVariantId);
+    const field = req.getKeyValueFromQuery("field");
+    if (!field) {
+      return missingFieldResponse();
+    }
+    const payload = parseUpdateFieldBody(await getJsonBody(req));
+    if (field === "email" && typeof payload.value === "string") {
+      return {
+        status: "OK",
+        ...await startPendingEmailVerification({
+          userId: session.getUserId(),
+          recipeUserId: session.getRecipeUserId(),
+          tenantId: session.getTenantId(),
+          email: payload.value,
+          pendingVerificationId: (0, import_crypto.randomUUID)(),
+          userContext: appVariantId ? { ...userContext, rowndAppVariantId: appVariantId } : userContext
+        })
+      };
+    }
+    const permissionError = validateWritableFields([field]);
+    if (permissionError) {
+      return permissionError;
+    }
+    return {
+      status: "OK",
+      ...await updateUserData(session.getUserId(), {
+        [field]: payload.value
+      })
+    };
+  };
+}
+function requireSession(session) {
+  if (!session) {
+    throw new Error("Session not found");
+  }
+  return session;
+}
+async function getJsonBody(req) {
+  return req.getJSONBody();
+}
+function parseGuestBody(value) {
+  if (!isJsonRecord(value)) {
+    return {};
+  }
+  return {
+    authLevel: typeof value.auth_level === "string" ? value.auth_level : void 0
+  };
+}
+function parseUpdateUserBody(value) {
+  if (!isJsonRecord(value) || !isJsonRecord(value.data)) {
+    return {};
+  }
+  return {
+    data: value.data,
+    ...isJsonRecord(value.context) ? { context: value.context } : {}
+  };
+}
+function parseUpdateMetaBody(value) {
+  if (!isJsonRecord(value) || !isJsonRecord(value.meta)) {
+    return {};
+  }
+  return { meta: value.meta };
+}
+function parseUpdateFieldBody(value) {
+  if (!isJsonRecord(value) || !hasOwn(value, "value")) {
+    return {};
+  }
+  return { value: value.value };
+}
+function validateWritableFields(fields) {
+  const readOnlyField = fields.find((field) => !canUpdateUserDataField(field));
+  if (!readOnlyField) {
+    return void 0;
+  }
+  return {
+    status: "ERROR",
+    code: 403,
+    message: `field is not writable: ${readOnlyField}`
+  };
+}
+function missingFieldResponse() {
+  return {
+    status: "ERROR",
+    code: 400,
+    message: "field is required"
+  };
+}
+function isJsonRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+function mapRowndUserToSuperTokens(rowndUser) {
+  const loginMethods = [];
+  const rowndUserData = rowndUser.data || {};
+  const rowndUserVerifiedData = rowndUser.verified_data || {};
+  if (!rowndUserData.user_id) {
+    throw new Error("Rownd user has no user_id");
+  }
+  if (rowndUserData.google_id) {
+    if (!rowndUserData.email) {
+      throw new Error("Rownd Google user is missing email");
+    }
+    loginMethods.push({
+      recipeId: "thirdparty",
+      thirdPartyId: "google",
+      thirdPartyUserId: rowndUserData.google_id,
+      email: rowndUserData.email,
+      isVerified: !!rowndUserVerifiedData.google_id
+    });
+  }
+  if (rowndUserData.apple_id) {
+    if (!rowndUserData.email) {
+      throw new Error("Rownd Apple user is missing email");
+    }
+    loginMethods.push({
+      recipeId: "thirdparty",
+      thirdPartyId: "apple",
+      thirdPartyUserId: rowndUserData.apple_id,
+      email: rowndUserData.email,
+      isVerified: !!rowndUserVerifiedData.apple_id
+    });
+  }
+  if (rowndUserData.phone_number) {
+    loginMethods.push({
+      recipeId: "passwordless",
+      phoneNumber: rowndUserData.phone_number,
+      isVerified: !!rowndUserVerifiedData.phone_number
+    });
+  }
+  if (rowndUserData.email && !rowndUserData.google_id && !rowndUserData.apple_id) {
+    loginMethods.push({
+      recipeId: "passwordless",
+      email: rowndUserData.email,
+      isVerified: !!rowndUserVerifiedData.email
+    });
+  }
+  let authLevel = rowndUser.auth_level;
+  if (loginMethods.length === 0) {
+    const thirdPartyId = authLevel === GUEST_AUTH_METHOD_ID ? GUEST_AUTH_METHOD_ID : ANONYMOUS_AUTH_METHOD_ID;
+    if (!authLevel) authLevel = thirdPartyId;
+    loginMethods.push({
+      recipeId: "thirdparty",
+      thirdPartyId,
+      thirdPartyUserId: rowndUserData.user_id,
+      email: `${rowndUserData.user_id}@anonymous.local`,
+      isVerified: false
+    });
+  }
+  const userMetadata = buildRowndUserMetadata(rowndUser);
+  return {
+    externalUserId: rowndUserData.user_id,
+    loginMethods,
+    userMetadata
+  };
+}
+async function importUser(stUser, config2) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config2.apiKey) {
+    headers["api-key"] = config2.apiKey;
+  }
+  const response = await fetch(`${config2.connectionURI}/bulk-import/import`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(stUser)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Bulk import failed with status ${response.status}: ${errorText}`
+    );
+  }
+  const importResponse = await response.json();
+  if (importResponse.status !== "OK" || !importResponse.user) {
+    throw new Error(
+      `Bulk import failed: ${importResponse.message || "Missing user in response"}`
+    );
+  }
+  return importResponse.user;
+}
+async function validateRowndToken(token) {
+  const client = getRowndClient();
+  const tokenInfo = await client.validateToken(token);
+  return tokenInfo.user_id;
+}
+async function fetchRowndUserInfo(userId) {
+  const client = getRowndClient();
+  const rowndUser = await client.fetchUserInfo({ user_id: userId });
+  if (!rowndUser) {
+    throw new RowndPluginError("ROWND_USER_NOT_FOUND");
+  }
+  return rowndUser;
+}
+var IDENTITY_USER_DATA_FIELDS = /* @__PURE__ */ new Set([
+  "user_id",
+  "email",
+  "phone_number",
+  "google_id",
+  "apple_id"
+]);
+var INTERNAL_METADATA_FIELDS = /* @__PURE__ */ new Set([
+  "original_rownd_user",
+  "rownd_pending_verification"
+]);
+function isIdentityField(field) {
+  return IDENTITY_USER_DATA_FIELDS.has(field);
+}
+function isInternalMetadataField(field) {
+  return INTERNAL_METADATA_FIELDS.has(field);
+}
+function getStringList(value) {
+  if (Array.isArray(value)) {
+    return value.filter((entry) => typeof entry === "string");
+  }
+  return typeof value === "string" ? [value] : [];
+}
+function getRequestedAppVariantIdFromRequest(req) {
+  return req.getKeyValueFromQuery("app_variant_id");
+}
+function getRequestedDisplayContextFromRequest(req) {
+  const displayContext = req.getKeyValueFromQuery("rownd_display_context");
+  return displayContext === "browser" || displayContext === "mobile_app" || displayContext === "customer_web_view" ? displayContext : void 0;
+}
+function getRequestedRedirectToPathFromRequest(req) {
+  const redirectToPath = req.getKeyValueFromQuery("rownd_redirect_to_path");
+  return typeof redirectToPath === "string" && redirectToPath.length > 0 ? redirectToPath : void 0;
+}
+function assertRowndAppVariantIsConfigured(appVariantId) {
+  if (!appVariantId) {
+    return;
+  }
+  if (pluginConfig?.subBrands && !pluginConfig.subBrands[appVariantId]) {
+    throw new Error(`Unknown Rownd app variant: ${appVariantId}`);
+  }
+}
+async function recordRowndAppVariantForUser(userId, appVariantId) {
+  if (!appVariantId) {
+    return;
+  }
+  assertRowndAppVariantIsConfigured(appVariantId);
+  const metadata = await getUserMetadata(userId);
+  const originalRowndUser = isJsonRecord(metadata.original_rownd_user) ? metadata.original_rownd_user : {};
+  const attributes = isJsonRecord(originalRowndUser.attributes) ? originalRowndUser.attributes : {};
+  const appVariants = getStringList(attributes["rownd:app_variants"]);
+  if (appVariants.includes(appVariantId)) {
+    return;
+  }
+  await import_usermetadata2.default.updateUserMetadata(userId, {
+    ...metadata,
+    original_rownd_user: {
+      ...originalRowndUser,
+      data: isJsonRecord(originalRowndUser.data) ? originalRowndUser.data : { user_id: userId },
+      verified_data: isJsonRecord(originalRowndUser.verified_data) ? originalRowndUser.verified_data : {},
+      attributes: {
+        ...attributes,
+        "rownd:app_variants": [...appVariants, appVariantId]
+      }
+    }
+  });
+}
+function buildRowndUserMetadata(rowndUser) {
+  const metadata = {
+    ...rowndUser.meta || {},
+    original_rownd_user: rowndUser
+  };
+  for (const [key, value] of Object.entries(rowndUser.data || {})) {
+    if (!isIdentityField(key) && value !== void 0) {
+      metadata[key] = value;
+    }
+  }
+  return metadata;
+}
+var RowndIsAnonymousClaim = new import_claims.BooleanClaim({
+  key: "is_anonymous",
+  fetchValue: async (userId) => {
+    const user = await import_supertokens_node.default.getUser(userId);
+    const effectiveAuthLevel = getEffectiveAuthLevel(user);
+    return effectiveAuthLevel === GUEST_AUTH_METHOD_ID;
+  }
+});
+async function buildRowndSessionClaims(userId, currentPayload = {}, appVariantId) {
+  const user = await import_supertokens_node.default.getUser(userId);
+  const metadata = user ? await getUserMetadata(user.id) : void 0;
+  const originalRowndUser = metadata?.original_rownd_user;
+  const verifiedData = originalRowndUser?.verified_data;
+  const authLevel = getEffectiveAuthLevel(
+    user,
+    originalRowndUser?.auth_level,
+    verifiedData
+  );
+  const appUserId = getRowndAppUserId(userId, user, currentPayload, metadata);
+  const isAnonymous = authLevel === GUEST_AUTH_METHOD_ID;
+  const anonymousId = getAnonymousId(userId, user, metadata);
+  const isVerifiedUser = authLevel !== "unverified";
+  const audience = buildRowndAudience(currentPayload, appVariantId);
+  const configuredClaims = buildConfiguredSessionClaims(metadata);
+  return {
+    ...audience,
+    ...configuredClaims,
+    app_user_id: appUserId,
+    auth_level: authLevel,
+    is_verified_user: isVerifiedUser,
+    [ROWND_JWT_CLAIMS.AppUserId]: appUserId,
+    [ROWND_JWT_CLAIMS.AuthLevel]: authLevel,
+    [ROWND_JWT_CLAIMS.IsVerifiedUser]: isVerifiedUser,
+    [ROWND_JWT_CLAIMS.IsAnonymous]: isAnonymous,
+    ...anonymousId ? { anonymous_id: anonymousId } : {}
+  };
+}
+function buildConfiguredSessionClaims(metadata) {
+  if (!metadata) {
+    return {};
+  }
+  const schema = pluginConfig?.schema || DEFAULT_ROWND_SCHEMA;
+  const claims = {};
+  for (const [key, field] of Object.entries(schema)) {
+    if (field.include_in_session_claims !== true) {
+      continue;
+    }
+    const value = metadata.original_rownd_user?.data?.[key] ?? metadata[key];
+    if (value !== void 0) {
+      claims[field.session_claim_name || key] = value;
+    }
+  }
+  return claims;
+}
+function getRowndAppUserId(userId, user, currentPayload, metadata) {
+  const originalUserId = metadata?.original_rownd_user?.data?.user_id;
+  if (typeof originalUserId === "string") {
+    return originalUserId;
+  }
+  if (typeof currentPayload.app_user_id === "string") {
+    return currentPayload.app_user_id;
+  }
+  return user?.id || userId;
+}
+function buildRowndAudience(currentPayload, appVariantId) {
+  const audience = getStringList(currentPayload.aud);
+  const appId = pluginConfig?.appConfig?.id;
+  if (appId) {
+    audience.push(`app:${appId}`);
+  }
+  if (appVariantId) {
+    audience.push(`app_variant:${appVariantId}`);
+  }
+  return audience.length > 0 ? { aud: [...new Set(audience)] } : {};
+}
+function getAnonymousId(userId, user, metadata) {
+  const originalAnonymousId = metadata?.original_rownd_user?.data?.anonymous_id;
+  if (typeof originalAnonymousId === "string") {
+    return originalAnonymousId;
+  }
+  const anonymousMethod = user?.loginMethods.find((loginMethod) => {
+    return loginMethod.recipeId === "thirdparty" && getThirdPartyId(loginMethod) === ANONYMOUS_AUTH_METHOD_ID;
+  });
+  const thirdPartyUserId = anonymousMethod ? getThirdPartyUserId(anonymousMethod) : void 0;
+  return thirdPartyUserId || (hasAnonymousLoginMethod(user) ? `anon_${userId}` : void 0);
+}
+async function shouldLinkRowndAccounts(input) {
+  const [newAccountInfo, , session] = input;
+  if (!session) {
+    return void 0;
+  }
+  const currentUser = await import_supertokens_node.default.getUser(session.getUserId());
+  if (hasOnlyGuestLoginMethods(currentUser)) {
+    return {
+      shouldAutomaticallyLink: true,
+      shouldRequireVerification: false
+    };
+  }
+  if (!currentUser || isGuestAccountInfo(newAccountInfo)) {
+    return void 0;
+  }
+  if (doesAccountInfoMatchAuthMethod(currentUser, newAccountInfo)) {
+    return {
+      shouldAutomaticallyLink: true,
+      shouldRequireVerification: true
+    };
+  }
+  return void 0;
+}
+async function getUserMetadata(userId) {
+  const metadata = await import_usermetadata2.default.getUserMetadata(userId);
+  return metadata.metadata || {};
+}
+function getPendingVerifications(metadata) {
+  const pendingVerification = metadata.rownd_pending_verification;
+  if (Array.isArray(pendingVerification)) {
+    return pendingVerification.filter(isPendingVerification);
+  }
+  return [];
+}
+function isPendingVerification(value) {
+  return isRecord(value) && typeof value.id === "string" && typeof value.field === "string" && typeof value.value === "string" && typeof value.created_at === "string";
+}
+async function getUserById(userId) {
+  const metadata = await getUserMetadata(userId);
+  const stUser = await import_supertokens_node.default.getUser(userId);
+  if (!stUser) {
+    throw new RowndPluginError("ROWND_USER_NOT_FOUND");
+  }
+  const originalRowndUser = metadata.original_rownd_user;
+  const rowndUser = originalRowndUser?.data?.user_id || userId;
+  const state = originalRowndUser?.state || "enabled";
+  const dataFieldKeys = /* @__PURE__ */ new Set();
+  const data = {
+    user_id: userId
+  };
+  for (const [key, value] of Object.entries(originalRowndUser?.data || {})) {
+    if (!isIdentityField(key)) {
+      data[key] = value;
+      dataFieldKeys.add(key);
+    }
+  }
+  const schema = pluginConfig?.schema || DEFAULT_ROWND_SCHEMA;
+  for (const key of Object.keys(schema)) {
+    dataFieldKeys.add(key);
+    if (!isInternalMetadataField(key) && !isIdentityField(key) && metadata[key] !== void 0) {
+      data[key] = metadata[key];
+    }
+  }
+  const verifiedData = {
+    ...originalRowndUser?.verified_data || {}
+  };
+  let lastUsedAt = stUser.timeJoined;
+  for (const method of stUser.loginMethods) {
+    if (typeof method.lastUsed === "number" && method.lastUsed > lastUsedAt) {
+      lastUsedAt = method.lastUsed;
+    }
+    if (method.recipeId === "passwordless") {
+      if (method.email) {
+        verifiedData.email = method.email;
+        if (data.email === void 0) data.email = method.email;
+      }
+      if (method.phoneNumber) {
+        verifiedData.phone_number = method.phoneNumber;
+        if (data.phone_number === void 0)
+          data.phone_number = method.phoneNumber;
+      }
+    } else if (method.recipeId === "thirdparty") {
+      const thirdPartyId = getThirdPartyId(method);
+      const thirdPartyUserId = getThirdPartyUserId(method);
+      if (method.verified && method.email) {
+        verifiedData.email = method.email;
+      }
+      if (method.email && data.email === void 0) {
+        data.email = method.email;
+      }
+      if (thirdPartyId === "google" && thirdPartyUserId) {
+        data.google_id = thirdPartyUserId;
+        verifiedData.google_id = thirdPartyUserId;
+      }
+      if (thirdPartyId === "apple" && thirdPartyUserId) {
+        data.apple_id = thirdPartyUserId;
+        verifiedData.apple_id = thirdPartyUserId;
+      }
+    } else if (method.recipeId === "emailpassword") {
+      if (method.email && data.email === void 0) {
+        data.email = method.email;
+      }
+    }
+  }
+  if (verifiedData.email === true && typeof data.email === "string") {
+    verifiedData.email = data.email;
+  }
+  if (verifiedData.phone_number === true && typeof data.phone_number === "string") {
+    verifiedData.phone_number = data.phone_number;
+  }
+  const anonymousId = getAnonymousId(stUser.id, stUser, metadata);
+  if (anonymousId && data.anonymous_id === void 0) {
+    data.anonymous_id = anonymousId;
+  }
+  const authLevel = getEffectiveAuthLevel(
+    stUser,
+    originalRowndUser?.auth_level,
+    verifiedData
+  );
+  for (const [key, field] of Object.entries(schema)) {
+    if (data[key] === void 0 && field.type === "string") {
+      data[key] = "";
+    }
+  }
+  const mapMethod = (method) => {
+    if (method.recipeId === "thirdparty") {
+      if (getThirdPartyId(method) === "google") return "google";
+      if (getThirdPartyId(method) === "apple") return "apple";
+    } else if (method.recipeId === "passwordless") {
+      if (method.email) return "email";
+      if (method.phoneNumber) return "phone";
+    } else if (method.recipeId === "emailpassword") {
+      return "email";
+    }
+    return "email";
+  };
+  const sortedByJoined = [...stUser.loginMethods].sort(
+    (a, b) => a.timeJoined - b.timeJoined
+  );
+  const sortedByLastUsed = [
+    ...stUser.loginMethods
+  ].sort((a, b) => (b.lastUsed || b.timeJoined) - (a.lastUsed || a.timeJoined));
+  const firstMethod = sortedByJoined[0];
+  const lastMethod = sortedByLastUsed[0];
+  const metadataMeta = Object.fromEntries(
+    Object.entries(metadata).filter(
+      ([key]) => !isInternalMetadataField(key) && !dataFieldKeys.has(key)
+    )
+  );
+  const meta = {
+    ...metadataMeta,
+    created: new Date(stUser.timeJoined).toISOString(),
+    first_sign_in: new Date(stUser.timeJoined).toISOString(),
+    last_sign_in: new Date(lastUsedAt).toISOString(),
+    last_active: new Date(lastUsedAt).toISOString(),
+    first_sign_in_method: firstMethod ? mapMethod(firstMethod) : "email",
+    last_sign_in_method: lastMethod ? mapMethod(lastMethod) : "email"
+  };
+  return {
+    rownd_user: rowndUser,
+    data,
+    meta,
+    verified_data: verifiedData,
+    state,
+    auth_level: authLevel,
+    redacted: [],
+    groups: originalRowndUser?.groups || [],
+    attributes: originalRowndUser?.attributes || {}
+  };
+}
+async function updateUserData(userId, inputData) {
+  const metadata = await getUserMetadata(userId);
+  const updatedMetadata = {
+    ...metadata,
+    ...inputData
+  };
+  await import_usermetadata2.default.updateUserMetadata(userId, updatedMetadata);
+  return getUserById(userId);
+}
+async function startPendingEmailVerification(input) {
+  const metadata = await getUserMetadata(input.userId);
+  const currentEmail = (await getUserById(input.userId)).data.email;
+  if (currentEmail === input.email) {
+    return getUserById(input.userId);
+  }
+  const pendingVerifications = getPendingVerifications(metadata);
+  const pendingEmailVerifications = pendingVerifications.filter(
+    (pendingVerification2) => pendingVerification2.field === "email"
+  );
+  for (const pendingVerification2 of pendingEmailVerifications) {
+    await import_emailverification.default.revokeEmailVerificationTokens(
+      input.tenantId,
+      input.recipeUserId,
+      pendingVerification2.value,
+      input.userContext
+    );
+  }
+  const pendingVerification = {
+    id: input.pendingVerificationId,
+    field: "email",
+    value: input.email,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await import_usermetadata2.default.updateUserMetadata(input.userId, {
+    ...metadata,
+    rownd_pending_verification: [
+      ...pendingVerifications.filter(
+        (pendingVerification2) => pendingVerification2.field !== "email"
+      ),
+      pendingVerification
+    ]
+  });
+  const response = await import_emailverification.default.sendEmailVerificationEmail(
+    input.tenantId,
+    input.userId,
+    input.recipeUserId,
+    input.email,
+    {
+      ...input.userContext,
+      rowndPendingVerificationId: pendingVerification.id
+    }
+  );
+  if (response.status === "EMAIL_ALREADY_VERIFIED_ERROR") {
+    await completePendingEmailVerification({
+      recipeUserId: input.recipeUserId,
+      email: input.email,
+      userContext: input.userContext
+    });
+  }
+  return getUserById(input.userId);
+}
+async function completePendingEmailVerification(input) {
+  const user = await import_supertokens_node.default.getUser(
+    input.recipeUserId.getAsString(),
+    input.userContext
+  );
+  const userId = user?.id ?? input.recipeUserId.getAsString();
+  const metadata = await getUserMetadata(userId);
+  const pendingVerifications = getPendingVerifications(metadata);
+  const pendingVerification = pendingVerifications.find(
+    (pendingVerification2) => pendingVerification2.field === "email" && pendingVerification2.value === input.email
+  );
+  if (!pendingVerification) {
+    return;
+  }
+  let metadataUserId = userId;
+  const passwordlessEmailMethod = getPasswordlessEmailLoginMethod(user);
+  if (passwordlessEmailMethod) {
+    const updateResult = await import_passwordless.default.updateUser({
+      recipeUserId: passwordlessEmailMethod.recipeUserId,
+      email: input.email,
+      userContext: input.userContext
+    });
+    if (updateResult.status !== "OK") {
+      throw new Error(
+        `Failed to update verified email method: ${updateResult.status}`
+      );
+    }
+  } else if (hasOnlyGuestLoginMethods(user)) {
+    const isPasswordlessSignUpAllowed = await import_accountlinking.default.isSignUpAllowed(
+      PUBLIC_TENANT_ID,
+      {
+        recipeId: "passwordless",
+        email: input.email
+      },
+      true,
+      void 0,
+      input.userContext
+    );
+    if (!isPasswordlessSignUpAllowed) {
+      throw new Error("Passwordless sign up is not allowed for this email");
+    }
+    const passwordlessUser = await import_passwordless.default.signInUp({
+      email: input.email,
+      tenantId: PUBLIC_TENANT_ID,
+      userContext: input.userContext
+    });
+    const primaryUserResult = await import_accountlinking.default.createPrimaryUser(
+      passwordlessUser.recipeUserId,
+      input.userContext
+    );
+    const primaryUserId = primaryUserResult.status === "OK" ? primaryUserResult.user.id : primaryUserResult.status === "RECIPE_USER_ID_ALREADY_LINKED_WITH_PRIMARY_USER_ID_ERROR" ? primaryUserResult.primaryUserId : passwordlessUser.user.id;
+    if (userId !== primaryUserId) {
+      const linkResult = await import_accountlinking.default.linkAccounts(
+        input.recipeUserId,
+        primaryUserId,
+        input.userContext
+      );
+      if (linkResult.status !== "OK") {
+        throw new Error(
+          `Failed to link verified email method: ${linkResult.status}`
+        );
+      }
+    }
+    metadataUserId = primaryUserId;
+  }
+  const updatedMetadata = {
+    ...metadata,
+    ...metadata.original_rownd_user ? {
+      original_rownd_user: {
+        ...metadata.original_rownd_user,
+        data: {
+          ...metadata.original_rownd_user.data,
+          email: input.email
+        },
+        verified_data: {
+          ...metadata.original_rownd_user.verified_data,
+          email: input.email
+        }
+      }
+    } : {},
+    rownd_pending_verification: pendingVerifications.filter(
+      (verification) => verification !== pendingVerification
+    )
+  };
+  await import_usermetadata2.default.updateUserMetadata(metadataUserId, updatedMetadata);
+}
+async function updateUserMetadata(userId, inputMeta) {
+  const metadata = await getUserMetadata(userId);
+  const updatedMetadata = {
+    ...metadata,
+    ...inputMeta
+  };
+  await import_usermetadata2.default.updateUserMetadata(userId, updatedMetadata);
+  return {
+    id: userId,
+    meta: Object.fromEntries(
+      Object.entries(updatedMetadata).filter(
+        ([key]) => !isInternalMetadataField(key)
+      )
+    )
+  };
+}
+function getThirdPartyId(method) {
+  return method.thirdPartyId || method.thirdParty?.id;
+}
+function getThirdPartyUserId(method) {
+  return method.thirdPartyUserId || method.thirdParty?.userId;
+}
+function getGuestAuthLevel(user) {
+  const guestMethod = user?.loginMethods.find(isGuestLoginMethod);
+  return guestMethod ? GUEST_AUTH_METHOD_ID : void 0;
+}
+function hasAnonymousLoginMethod(user) {
+  return !!user?.loginMethods.some((loginMethod) => {
+    return loginMethod.recipeId === "thirdparty" && getThirdPartyId(loginMethod) === ANONYMOUS_AUTH_METHOD_ID;
+  });
+}
+function getPasswordlessEmailLoginMethod(user) {
+  return user?.loginMethods.find((method) => {
+    return method.recipeId === "passwordless" && !!method.email;
+  });
+}
+function hasOnlyGuestLoginMethods(user) {
+  return !!user?.loginMethods.length && user.loginMethods.every(isGuestLoginMethod);
+}
+function isGuestLoginMethod(method) {
+  const thirdPartyId = getThirdPartyId(method);
+  return method.recipeId === "thirdparty" && (thirdPartyId === GUEST_AUTH_METHOD_ID || thirdPartyId === ANONYMOUS_AUTH_METHOD_ID);
+}
+function isGuestAccountInfo(input) {
+  return input?.recipeId === "thirdparty" && (input.thirdParty?.id === GUEST_AUTH_METHOD_ID || input.thirdParty?.id === ANONYMOUS_AUTH_METHOD_ID);
+}
+function doesAccountInfoMatchAuthMethod(user, accountInfo) {
+  if (!user) {
+    return false;
+  }
+  const normalizedEmail = accountInfo.email?.toLowerCase();
+  if (normalizedEmail) {
+    return user.loginMethods.some((method) => {
+      if (isGuestLoginMethod(method) || !method.email) {
+        return false;
+      }
+      return method.email.toLowerCase() === normalizedEmail;
+    });
+  }
+  if (accountInfo.phoneNumber) {
+    return user.loginMethods.some((method) => {
+      return !isGuestLoginMethod(method) && method.phoneNumber === accountInfo.phoneNumber;
+    });
+  }
+  return false;
+}
+function hasVerifiedRealLoginMethod(user) {
+  return !!user?.loginMethods.some((method) => {
+    if (isGuestLoginMethod(method)) {
+      return false;
+    }
+    if (method.recipeId === "passwordless") {
+      return !!(method.email || method.phoneNumber);
+    }
+    if (method.recipeId === "thirdparty") {
+      return !!getThirdPartyUserId(method) && method.verified === true;
+    }
+    if (method.recipeId === "emailpassword") {
+      return !!method.email && method.verified === true;
+    }
+    return method.verified === true;
+  });
+}
+function getEffectiveAuthLevel(user, originalAuthLevel, verifiedData) {
+  if (hasVerifiedRealLoginMethod(user)) {
+    return "verified";
+  }
+  return getGuestAuthLevel(user) || originalAuthLevel || (verifiedData && Object.keys(verifiedData).length > 0 ? "verified" : "unverified");
+}
+function canUpdateUserDataField(field) {
+  const schema = pluginConfig?.schema || DEFAULT_ROWND_SCHEMA;
+  const schemaField = schema[field];
+  if (!schemaField) {
+    return false;
+  }
+  const ownedBy = field === "google_id" || field === "apple_id" ? "app" : schemaField.owned_by || "user";
+  return ownedBy !== "app" && schemaField.read_only !== true;
+}
+var BUILTIN_SIGN_IN_METHOD_KEYS = [
+  "email",
+  "phone",
+  "google",
+  "apple",
+  "anonymous"
+];
+function normalizeSchemaField(key, field) {
+  let ownedBy = field.owned_by;
+  if (key === "google_id" || key === "apple_id") {
+    ownedBy = "app";
+  } else if (!ownedBy) {
+    ownedBy = "user";
+  }
+  return {
+    display_name: field.display_name,
+    type: field.type,
+    owned_by: ownedBy,
+    user_visible: field.user_visible,
+    read_only: field.read_only ?? ownedBy === "app",
+    show_empty: field.show_empty ?? false
+  };
+}
+var DEFAULT_PRIMARY_COLOR = "#5b5bd6";
+function buildSignInMethodsConfig(methodsArray) {
+  const methods = (methodsArray ?? []).reduce(
+    (acc, curr) => {
+      acc[curr.method] = curr;
+      return acc;
+    },
+    {}
+  );
+  const customProviders = Object.fromEntries(
+    Object.entries(methods).filter(([key]) => !BUILTIN_SIGN_IN_METHOD_KEYS.includes(key)).map(([key, val]) => {
+      return val ? [
+        key,
+        {
+          enabled: true,
+          display_name: getStringMethodProperty(val, "displayName") ?? key,
+          icon_light_url: getStringMethodProperty(val, "iconLightUrl"),
+          icon_dark_url: getStringMethodProperty(val, "iconDarkUrl")
+        }
+      ] : [key, void 0];
+    }).filter(([, v]) => v !== void 0)
+  );
+  const googleMethod = methods.google;
+  const appleMethod = methods.apple;
+  const anonymousMethod = methods.anonymous;
+  const anonymousType = getAnonymousType(anonymousMethod);
+  const googleOneTap = getOneTapConfig(googleMethod);
+  return {
+    email: { enabled: !!methods.email },
+    phone: { enabled: !!methods.phone },
+    google: {
+      enabled: !!googleMethod,
+      client_id: getStringMethodProperty(googleMethod, "clientId") ?? "",
+      ios_client_id: getStringMethodProperty(googleMethod, "iosClientId") ?? "",
+      scopes: getStringArrayMethodProperty(googleMethod, "scopes") ?? [],
+      ...getSignInFasterWithGoogle(googleMethod) ? { sign_in_faster_with_google: getSignInFasterWithGoogle(googleMethod) } : {},
+      one_tap: {
+        browser: {
+          auto_prompt: googleOneTap?.browser?.autoPrompt ?? false,
+          delay: googleOneTap?.browser?.delay ?? 7e3
+        },
+        mobile_app: {
+          auto_prompt: googleOneTap?.mobileApp?.autoPrompt ?? false,
+          delay: googleOneTap?.mobileApp?.delay ?? 7e3
+        }
+      }
+    },
+    apple: {
+      enabled: !!appleMethod,
+      client_id: getStringMethodProperty(appleMethod, "clientId") ?? ""
+    },
+    anonymous: {
+      enabled: !!anonymousMethod && anonymousType !== "instant",
+      ...anonymousMethod && anonymousType !== "instant" ? { type: anonymousType } : {},
+      ...anonymousType !== "instant" && getStringMethodProperty(anonymousMethod, "displayName") !== void 0 ? {
+        display_name: getStringMethodProperty(
+          anonymousMethod,
+          "displayName"
+        )
+      } : {},
+      ...anonymousType !== "instant" && getStringMethodProperty(anonymousMethod, "iconLightUrl") !== void 0 ? {
+        icon_light_url: getStringMethodProperty(
+          anonymousMethod,
+          "iconLightUrl"
+        )
+      } : {},
+      ...anonymousType !== "instant" && getStringMethodProperty(anonymousMethod, "iconDarkUrl") !== void 0 ? {
+        icon_dark_url: getStringMethodProperty(
+          anonymousMethod,
+          "iconDarkUrl"
+        )
+      } : {}
+    },
+    ...customProviders
+  };
+}
+function isInstantAnonymousMethod(methods) {
+  return (methods ?? []).some(
+    (method) => method.method === "anonymous" && getAnonymousType(method) === "instant"
+  );
+}
+function getAnonymousType(method) {
+  const type = getStringMethodProperty(method, "type");
+  return type === "instant" ? "instant" : "guest";
+}
+function getSignInFasterWithGoogle(method) {
+  const value = getStringMethodProperty(method, "signInFasterWithGoogle");
+  return value === "enabled" || value === "disabled" ? value : void 0;
+}
+function getMethodProperty(method, property) {
+  if (!method) {
+    return void 0;
+  }
+  return method[property];
+}
+function getStringMethodProperty(method, property) {
+  const value = getMethodProperty(method, property);
+  return typeof value === "string" ? value : void 0;
+}
+function getStringArrayMethodProperty(method, property) {
+  const value = getMethodProperty(method, property);
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : void 0;
+}
+function getOneTapConfig(method) {
+  const oneTap = getMethodProperty(method, "oneTap");
+  if (!isRecord(oneTap)) {
+    return void 0;
+  }
+  return {
+    browser: parseOneTapPlatform(oneTap.browser),
+    mobileApp: parseOneTapPlatform(oneTap.mobileApp)
+  };
+}
+function parseOneTapPlatform(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  return {
+    autoPrompt: typeof value.autoPrompt === "boolean" ? value.autoPrompt : void 0,
+    delay: typeof value.delay === "number" ? value.delay : void 0
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getSubBrandVariant(app) {
+  if (isRecord(app) && isRecord(app.variant) && typeof app.variant.id === "string") {
+    return app.variant;
+  }
+  return void 0;
+}
+function mergeConfigInput(base, override) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    result[key] = isRecord(existing) && isRecord(value) ? mergeConfigInput(existing, value) : value;
+  }
+  return result;
+}
+function buildAppConfig(config2, stConfig, appVariantId) {
+  const userSchema = config2.schema ?? DEFAULT_ROWND_SCHEMA;
+  const baseApp = config2.appConfig ?? {};
+  const subBrand = appVariantId ? config2.subBrands?.[appVariantId] : void 0;
+  const app = appVariantId ? subBrand && mergeConfigInput(baseApp, subBrand) : baseApp;
+  if (!app) {
+    return void 0;
+  }
+  const branding = app.branding ?? {};
+  const auth = app.auth ?? {};
+  const signInMethods = buildSignInMethodsConfig(app.signInMethods);
+  const variant = getSubBrandVariant(app);
+  const finalSchema = { ...userSchema };
+  if (signInMethods.email.enabled && !finalSchema.email) {
+    finalSchema.email = {
+      display_name: "Email",
+      type: "string",
+      user_visible: true
+    };
+  }
+  if (signInMethods.phone.enabled && !finalSchema.phone_number) {
+    finalSchema.phone_number = {
+      display_name: "Phone number",
+      type: "string",
+      user_visible: true
+    };
+  }
+  if (signInMethods.google.enabled && !finalSchema.google_id) {
+    finalSchema.google_id = {
+      display_name: "Google ID",
+      type: "string",
+      user_visible: false
+    };
+  }
+  if (signInMethods.apple.enabled && !finalSchema.apple_id) {
+    finalSchema.apple_id = {
+      display_name: "Apple ID",
+      type: "string",
+      user_visible: false
+    };
+  }
+  return {
+    config_type: appVariantId ? "variant" : "app",
+    ...variant ? { variant } : {},
+    app: {
+      id: app.id ?? "",
+      name: app.name ?? stConfig.appInfo.appName,
+      icon: app.icon ?? "",
+      ...app.userVerificationFields ? { user_verification_fields: app.userVerificationFields } : {},
+      schema: Object.fromEntries(
+        Object.entries(finalSchema).map(([key, field]) => [
+          key,
+          normalizeSchemaField(key, field)
+        ])
+      ),
+      config: {
+        ...app.capabilities ? { capabilities: app.capabilities } : {},
+        ...app.web ? { web: app.web } : {},
+        ...app.bottomSheet ? { bottom_sheet: app.bottomSheet } : {},
+        ...app.profileStorageVersion ? { profile_storage_version: app.profileStorageVersion } : {},
+        customizations: {
+          primary_color: branding.primaryColor ?? DEFAULT_PRIMARY_COLOR,
+          ...branding.logo ? { logo: branding.logo } : {},
+          ...branding.logoDarkMode ? { logo_dark_mode: branding.logoDarkMode } : {},
+          ...branding.animations ? { animations: branding.animations } : {}
+        },
+        hub: {
+          ...app.allowedWebOrigins ? { allowed_web_origins: app.allowedWebOrigins } : {},
+          customizations: {
+            rounded_corners: branding.roundedCorners ?? true,
+            ...branding.containerBorderRadius !== void 0 ? { container_border_radius: branding.containerBorderRadius } : {},
+            ...branding.placement !== void 0 ? { placement: branding.placement } : {},
+            ...branding.hubPrimaryColor !== void 0 ? { primary_color: branding.hubPrimaryColor } : {},
+            ...branding.primaryColorDarkMode !== void 0 ? { primary_color_dark_mode: branding.primaryColorDarkMode } : {},
+            ...branding.backgroundColor !== void 0 ? { background_color: branding.backgroundColor } : {},
+            ...branding.fontFamily !== void 0 ? { font_family: branding.fontFamily } : {},
+            ...branding.hideVerificationIcons !== void 0 ? { hide_verification_icons: branding.hideVerificationIcons } : {},
+            visual_swoops: branding.visualSwoops ?? true,
+            blur_background: branding.blurBackground ?? true,
+            ...branding.blurBackgroundOpacity !== void 0 ? { blur_background_opacity: branding.blurBackgroundOpacity } : {},
+            ...branding.offsetX !== void 0 ? { offset_x: branding.offsetX } : {},
+            ...branding.offsetY !== void 0 ? { offset_y: branding.offsetY } : {},
+            ...branding.propertyOverrides ? { property_overrides: branding.propertyOverrides } : {},
+            dark_mode: branding.darkMode ?? "auto"
+          },
+          ...branding.customScripts ? { custom_scripts: branding.customScripts } : {},
+          ...branding.customStyles ? { custom_styles: branding.customStyles } : {},
+          auth: {
+            email: buildAuthEmailConfig(auth.email),
+            ...auth.mobile ? { mobile: buildAuthMobileConfig(auth.mobile) } : {},
+            sign_in_methods: signInMethods,
+            additional_fields: auth.additionalFields ?? [],
+            ...auth.rememberSignInMethod !== void 0 ? { remember_sign_in_method: auth.rememberSignInMethod } : {},
+            ...auth.useExplicitSignUpFlow !== void 0 ? { use_explicit_sign_up_flow: auth.useExplicitSignUpFlow } : {},
+            ...auth.allowUnverifiedUsers !== void 0 ? { allow_unverified_users: auth.allowUnverifiedUsers } : {},
+            ...auth.primarySignUpMethod ? { primary_sign_up_method: auth.primarySignUpMethod } : {},
+            ...auth.preferredMethod ? { preferred_method: auth.preferredMethod } : {},
+            ...auth.order ? { order: auth.order } : {},
+            ...isInstantAnonymousMethod(app.signInMethods) ? { instant_user: { enabled: true } } : {},
+            show_app_icon: branding.showAppIcon ?? false
+          },
+          legal: {
+            ...app.legal?.companyName ? { company_name: app.legal.companyName } : {},
+            ...app.legal?.privacyPolicyUrl ? { privacy_policy_url: app.legal.privacyPolicyUrl } : {},
+            ...app.legal?.termsConditionsUrl ? { terms_conditions_url: app.legal.termsConditionsUrl } : {},
+            ...app.legal?.supportEmail ? { support_email: app.legal.supportEmail } : {}
+          },
+          custom_content: {
+            ...app.customContent?.signInModal ? {
+              sign_in_modal: {
+                ...app.customContent.signInModal.title ? { title: app.customContent.signInModal.title } : {},
+                ...app.customContent.signInModal.subtitle ? { subtitle: app.customContent.signInModal.subtitle } : {},
+                ...app.customContent.signInModal.signInTitle ? {
+                  sign_in_title: app.customContent.signInModal.signInTitle
+                } : {},
+                ...app.customContent.signInModal.signUpTitle ? {
+                  sign_up_title: app.customContent.signInModal.signUpTitle
+                } : {},
+                ...app.customContent.signInModal.signInSubtitle ? {
+                  sign_in_subtitle: app.customContent.signInModal.signInSubtitle
+                } : {},
+                ...app.customContent.signInModal.signUpSubtitle ? {
+                  sign_up_subtitle: app.customContent.signInModal.signUpSubtitle
+                } : {},
+                ...app.customContent.signInModal.signInButton ? {
+                  sign_in_button: app.customContent.signInModal.signInButton
+                } : {},
+                ...app.customContent.signInModal.signUpButton ? {
+                  sign_up_button: app.customContent.signInModal.signUpButton
+                } : {}
+              }
+            } : {},
+            ...app.customContent?.profileModal ? { profile_modal: app.customContent.profileModal } : {},
+            ...app.customContent?.verificationModal ? {
+              verification_modal: {
+                ...app.customContent.verificationModal.title ? { title: app.customContent.verificationModal.title } : {},
+                ...app.customContent.verificationModal.subtitle ? { subtitle: app.customContent.verificationModal.subtitle } : {}
+              }
+            } : {},
+            ...app.customContent?.signInFailureModal ? {
+              sign_in_failure_modal: {
+                failure_message: app.customContent.signInFailureModal.failureMessage
+              }
+            } : {},
+            ...app.customContent?.noAccountMessage ? { no_account_message: app.customContent.noAccountMessage } : {},
+            ...app.customContent?.mobile ? { mobile: app.customContent.mobile } : {}
+          },
+          profile: {
+            ...app.profile?.accountInformation ? { account_information: app.profile.accountInformation } : {},
+            ...app.profile?.personalInformation ? { personal_information: app.profile.personalInformation } : {},
+            ...app.profile?.preferences ? { preferences: app.profile.preferences } : {},
+            ...app.profile?.signOutButton ? { sign_out_button: app.profile.signOutButton } : {},
+            ...app.profile?.deleteAccountButton ? { delete_account_button: app.profile.deleteAccountButton } : {},
+            ...app.profile?.addSignInMethodsButton ? { add_sign_in_methods_button: app.profile.addSignInMethodsButton } : {}
+          }
+        }
+      }
+    }
+  };
+}
+function buildAuthEmailConfig(authEmail) {
+  return {
+    from_address: authEmail?.fromAddress ?? "no-reply@rownd.io",
+    image: authEmail?.image ?? "",
+    ...authEmail?.subject ? { subject: authEmail.subject } : {},
+    ...authEmail?.callToActionText ? { call_to_action_text: authEmail.callToActionText } : {},
+    ...authEmail?.verifyTemplate ? { verify_template: authEmail.verifyTemplate } : {},
+    ...authEmail?.customContent ? { custom_content: authEmail.customContent } : {},
+    ...authEmail?.customClosingContent ? { custom_closing_content: authEmail.customClosingContent } : {}
+  };
+}
+function buildAuthMobileConfig(authMobile) {
+  return {
+    ...authMobile?.title ? { title: authMobile.title } : {},
+    ...authMobile?.image ? { image: authMobile.image } : {},
+    ...authMobile?.callToActionText ? { call_to_action_text: authMobile.callToActionText } : {},
+    ...authMobile?.hyperlinkText ? { hyperlink_text: authMobile.hyperlinkText } : {},
+    ...authMobile?.hyperlinkRedirectUrl ? { hyperlink_redirect_url: authMobile.hyperlinkRedirectUrl } : {},
+    ...authMobile?.customContent ? { custom_content: authMobile.customContent } : {}
+  };
+}
+
+// src/plugin.ts
+var init = createPluginInitFunction(
+  (pluginConfig2) => {
+    const rowndClient2 = (0, import_node.createInstance)({
+      app_key: pluginConfig2.rowndAppKey,
+      app_secret: pluginConfig2.rowndAppSecret
+    });
+    const telemetryClient = createClient(pluginConfig2.telemetry);
+    let hubBootstrapParams;
+    const addHubBootstrapParams = (input, linkKey, targetPath) => {
+      const appVariantId = input?.userContext?.rowndAppVariantId;
+      const displayContext = input?.userContext?.rowndDisplayContext;
+      const redirectToPath = input?.userContext?.rowndRedirectToPath;
+      const bootstrapParams = {
+        appKey: pluginConfig2.rowndAppKey,
+        ...hubBootstrapParams ?? {},
+        ...typeof appVariantId === "string" ? { appVariantId } : {},
+        ...typeof displayContext === "string" ? { displayContext } : {},
+        ...typeof redirectToPath === "string" ? { redirectToPath } : {}
+      };
+      return {
+        ...input,
+        [linkKey]: input[linkKey] ? rewriteLinkPath(input[linkKey], targetPath, bootstrapParams) : input[linkKey]
+      };
+    };
+    setRowndClient(rowndClient2);
+    setPluginConfig(pluginConfig2);
+    if (pluginConfig2.enableDebugLogs) {
+      enableDebugLogs();
+    }
+    logDebugMessage("Rownd plugin init complete");
+    return {
+      id: PLUGIN_ID,
+      compatibleSDKVersions: PLUGIN_SDK_VERSION,
+      init: async () => {
+        if (!import_supertokens_node2.default.isRecipeInitialized("session")) {
+          console.warn(
+            "RowndMigrationPlugin: Session recipe is not initialized. Session migration will fail."
+          );
+        }
+        if (!import_supertokens_node2.default.isRecipeInitialized("thirdparty")) {
+          console.warn(
+            "RowndMigrationPlugin: ThirdParty recipe is not initialized. Guest login will fail."
+          );
+        }
+        if (!import_supertokens_node2.default.isRecipeInitialized("emailverification")) {
+          console.warn(
+            "RowndMigrationPlugin: EmailVerification recipe is not initialized. Verified email profile updates will fail."
+          );
+        }
+      },
+      routeHandlers(stConfig) {
+        const apiBasePath = stConfig.appInfo.apiBasePath.getAsStringDangerous();
+        hubBootstrapParams = {
+          apiDomain: stConfig.appInfo.apiDomain.getAsStringDangerous(),
+          apiBasePath
+        };
+        const routeHandlerDeps = {
+          pluginConfig: pluginConfig2,
+          stConfig,
+          telemetryClient
+        };
+        return {
+          status: "OK",
+          routeHandlers: [
+            {
+              path: `${apiBasePath}${HANDLE_BASE_PATH}/app-config`,
+              method: "get",
+              handler: withRequestHandler(
+                handleGetAppConfig(routeHandlerDeps)
+              )
+            },
+            {
+              path: `${apiBasePath}${HANDLE_BASE_PATH}/guest`,
+              method: "post",
+              handler: withRequestHandler(handleGuestLogin(routeHandlerDeps))
+            },
+            {
+              path: `${apiBasePath}${HANDLE_BASE_PATH}/migrate`,
+              method: "post",
+              handler: withRequestHandler(handleMigrate(routeHandlerDeps))
+            },
+            {
+              path: `${apiBasePath}/plugin/migrate-session`,
+              method: "post",
+              handler: withRequestHandler(handleMigrate(routeHandlerDeps))
+            },
+            {
+              path: `${apiBasePath}${HANDLE_BASE_PATH}/signout`,
+              method: "post",
+              verifySessionOptions: {
+                sessionRequired: true,
+                checkDatabase: true
+              },
+              handler: withRequestHandler(handleSignOut())
+            },
+            {
+              path: `${apiBasePath}${HANDLE_BASE_PATH}/user`,
+              method: "get",
+              verifySessionOptions: { sessionRequired: true },
+              handler: withRequestHandler(handleGetUser())
+            },
+            {
+              path: `${apiBasePath}${HANDLE_BASE_PATH}/user`,
+              method: "put",
+              verifySessionOptions: { sessionRequired: true },
+              handler: withRequestHandler(handleUpdateUser())
+            },
+            {
+              path: `${apiBasePath}${HANDLE_BASE_PATH}/user`,
+              method: "delete",
+              verifySessionOptions: { sessionRequired: true },
+              handler: withRequestHandler(handleDeleteUser())
+            },
+            {
+              path: `${apiBasePath}${HANDLE_BASE_PATH}/user/meta`,
+              method: "get",
+              verifySessionOptions: { sessionRequired: true },
+              handler: withRequestHandler(handleGetUserMeta())
+            },
+            {
+              path: `${apiBasePath}${HANDLE_BASE_PATH}/user/meta`,
+              method: "put",
+              verifySessionOptions: { sessionRequired: true },
+              handler: withRequestHandler(handleUpdateUserMeta())
+            },
+            {
+              path: `${apiBasePath}${HANDLE_BASE_PATH}/user/field`,
+              method: "get",
+              verifySessionOptions: { sessionRequired: true },
+              handler: withRequestHandler(handleGetUserField())
+            },
+            {
+              path: `${apiBasePath}${HANDLE_BASE_PATH}/user/field`,
+              method: "put",
+              verifySessionOptions: { sessionRequired: true },
+              handler: withRequestHandler(handleUpdateUserField())
+            }
+          ]
+        };
+      },
+      overrideMap: {
+        passwordless: {
+          config: (config2) => {
+            const originalEmailDeliveryOverride = config2.emailDelivery?.override;
+            const originalSmsDeliveryOverride = config2.smsDelivery?.override;
+            return {
+              ...config2,
+              emailDelivery: {
+                ...config2.emailDelivery,
+                override: (originalImplementation, builder) => {
+                  const implementation = originalEmailDeliveryOverride ? originalEmailDeliveryOverride(
+                    originalImplementation,
+                    builder
+                  ) : originalImplementation;
+                  return {
+                    ...implementation,
+                    sendEmail: async function(input) {
+                      return implementation.sendEmail({
+                        ...addHubBootstrapParams(
+                          input,
+                          "urlWithLinkCode",
+                          "account/login"
+                        )
+                      });
+                    }
+                  };
+                }
+              },
+              smsDelivery: {
+                ...config2.smsDelivery,
+                override: (originalImplementation, builder) => {
+                  const implementation = originalSmsDeliveryOverride ? originalSmsDeliveryOverride(
+                    originalImplementation,
+                    builder
+                  ) : originalImplementation;
+                  return {
+                    ...implementation,
+                    sendSms: async function(input) {
+                      return implementation.sendSms({
+                        ...addHubBootstrapParams(
+                          input,
+                          "urlWithLinkCode",
+                          "account/login"
+                        )
+                      });
+                    }
+                  };
+                }
+              }
+            };
+          },
+          apis: (originalImplementation) => ({
+            ...originalImplementation,
+            createCodePOST: async (input) => {
+              if (originalImplementation.createCodePOST === void 0) {
+                throw new Error("Passwordless createCodePOST is unavailable");
+              }
+              const displayContext = getRequestedDisplayContextFromRequest(
+                input.options.req
+              );
+              const redirectToPath = getRequestedRedirectToPathFromRequest(
+                input.options.req
+              );
+              const appVariantId = getRequestedAppVariantIdFromRequest(
+                input.options.req
+              );
+              assertRowndAppVariantIsConfigured(appVariantId);
+              return originalImplementation.createCodePOST({
+                ...input,
+                userContext: displayContext || redirectToPath || appVariantId ? {
+                  ...input.userContext,
+                  ...appVariantId ? { rowndAppVariantId: appVariantId } : {},
+                  ...displayContext ? { rowndDisplayContext: displayContext } : {},
+                  ...redirectToPath ? { rowndRedirectToPath: redirectToPath } : {}
+                } : input.userContext
+              });
+            },
+            consumeCodePOST: async (input) => {
+              if (originalImplementation.consumeCodePOST === void 0) {
+                throw new Error(
+                  "Passwordless consumeCodePOST is unavailable"
+                );
+              }
+              const appVariantId = getRequestedAppVariantIdFromRequest(
+                input.options.req
+              );
+              assertRowndAppVariantIsConfigured(appVariantId);
+              const response = await originalImplementation.consumeCodePOST({
+                ...input,
+                userContext: appVariantId ? { ...input.userContext, rowndAppVariantId: appVariantId } : input.userContext
+              });
+              if (response.status === "OK") {
+                await recordRowndAppVariantForUser(
+                  response.user.id,
+                  appVariantId
+                );
+              }
+              return response;
+            }
+          })
+        },
+        thirdparty: {
+          apis: (originalImplementation) => ({
+            ...originalImplementation,
+            signInUpPOST: async (input) => {
+              if (originalImplementation.signInUpPOST === void 0) {
+                throw new Error("ThirdParty signInUpPOST is unavailable");
+              }
+              const appVariantId = getRequestedAppVariantIdFromRequest(
+                input.options.req
+              );
+              assertRowndAppVariantIsConfigured(appVariantId);
+              const response = await originalImplementation.signInUpPOST({
+                ...input,
+                userContext: appVariantId ? { ...input.userContext, rowndAppVariantId: appVariantId } : input.userContext
+              });
+              if (response.status === "OK") {
+                await recordRowndAppVariantForUser(
+                  response.user.id,
+                  appVariantId
+                );
+              }
+              return response;
+            }
+          })
+        },
+        accountlinking: {
+          recipeInitRequired: true,
+          config: (config2) => {
+            const originalShouldDoAutomaticAccountLinking = config2.shouldDoAutomaticAccountLinking;
+            return {
+              ...config2,
+              shouldDoAutomaticAccountLinking: async (...input) => {
+                const rowndLinkingDecision = await shouldLinkRowndAccounts(input);
+                if (rowndLinkingDecision) {
+                  return rowndLinkingDecision;
+                }
+                if (originalShouldDoAutomaticAccountLinking) {
+                  return originalShouldDoAutomaticAccountLinking(...input);
+                }
+                return {
+                  shouldAutomaticallyLink: false,
+                  shouldRequireVerification: false
+                };
+              }
+            };
+          }
+        },
+        session: {
+          recipeInitRequired: true,
+          functions: (originalImplementation) => ({
+            ...originalImplementation,
+            createNewSession: async (input) => {
+              input.accessTokenPayload = {
+                ...input.accessTokenPayload,
+                ...await buildRowndSessionClaims(
+                  input.userId,
+                  input.accessTokenPayload
+                ),
+                ...await RowndIsAnonymousClaim.build(
+                  input.userId,
+                  input.recipeUserId,
+                  input.tenantId,
+                  input.accessTokenPayload,
+                  input.userContext
+                )
+              };
+              return originalImplementation.createNewSession(input);
+            }
+          })
+        },
+        emailverification: {
+          recipeInitRequired: true,
+          config: (config2) => {
+            const originalEmailDeliveryOverride = config2.emailDelivery?.override;
+            return {
+              ...config2,
+              emailDelivery: {
+                ...config2.emailDelivery,
+                override: (originalImplementation, builder) => {
+                  const implementation = originalEmailDeliveryOverride ? originalEmailDeliveryOverride(
+                    originalImplementation,
+                    builder
+                  ) : originalImplementation;
+                  return {
+                    ...implementation,
+                    sendEmail: async (input) => {
+                      return implementation.sendEmail({
+                        ...addHubBootstrapParams(
+                          input,
+                          "emailVerifyLink",
+                          "account/verify-email"
+                        )
+                      });
+                    }
+                  };
+                }
+              }
+            };
+          },
+          apis: (originalImplementation) => ({
+            ...originalImplementation,
+            verifyEmailPOST: async (input) => {
+              if (originalImplementation.verifyEmailPOST === void 0) {
+                throw new Error(
+                  "EmailVerification verifyEmailPOST is unavailable"
+                );
+              }
+              const response = await originalImplementation.verifyEmailPOST(input);
+              if (response.status === "OK") {
+                await completePendingEmailVerification({
+                  recipeUserId: response.user.recipeUserId,
+                  email: response.user.email,
+                  userContext: input.userContext
+                });
+              }
+              return response;
+            }
+          })
+        }
+      }
+    };
+  },
+  () => ({}),
+  (config2) => {
+    if (!config2?.rowndAppKey || !config2?.rowndAppSecret) {
+      throw new Error(
+        "Missing rowndAppKey or rowndAppSecret in plugin config"
+      );
+    }
+    if (config2.telemetry?.provider === "axiom") {
+      if (!config2.telemetry.token || !config2.telemetry.dataset) {
+        throw new Error(
+          "Missing telemetry axiom token or dataset in plugin config"
+        );
+      }
+    }
+    if (config2.telemetry?.provider === "custom") {
+      if (typeof config2.telemetry.factory !== "function") {
+        throw new Error(
+          "Missing telemetry custom factory function in plugin config"
+        );
+      }
+    }
+    return {
+      rowndAppKey: config2.rowndAppKey,
+      rowndAppSecret: config2.rowndAppSecret,
+      enableDebugLogs: config2.enableDebugLogs,
+      telemetry: config2.telemetry,
+      schema: config2.schema,
+      appConfig: config2.appConfig,
+      subBrands: config2.subBrands
+    };
+  }
+);
+
+// src/index.ts
+var index_default = { init };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ANONYMOUS_AUTH_METHOD_ID,
+  DEFAULT_ROWND_SCHEMA,
+  GUEST_AUTH_METHOD_ID,
+  HANDLE_BASE_PATH,
+  PLUGIN_ID,
+  PLUGIN_SDK_VERSION,
+  PUBLIC_TENANT_ID,
+  ROWND_JWT_CLAIMS,
+  ROWND_PLUGIN_ERROR_MESSAGES,
+  RowndPluginError,
+  getRowndClient,
+  init,
+  setRowndClient
+});