@corbado/observe 1.7.2 → 1.8.0

package/dist/analysis/storage/migration.mjs

@@ -0,0 +1,56 @@
+// src/storage/migration.ts
+import { namespacedKey } from "./index.mjs";
+var STORAGE_SCHEMA_VERSION = 1;
+var STORAGE_SCHEMA_KEY = "cbo_storage_schema";
+var LOCAL_KEYS = [
+  "cbo_seq",
+  "cbo_sdk_config",
+  "cbo_experiments",
+  "cbo_client_env_handle",
+  "cbo_outbox",
+  "cbo_visibility_change_debug",
+  "cbo_pagehide_debug",
+  "cbo_session"
+];
+var SESSION_KEYS = ["cbo_session_id", "cbo_tab_id"];
+var COOKIE_KEYS = ["cbo_client_env_handle"];
+function writeVerified(storage, key, value) {
+  storage.setItem(key, value);
+  return JSON.stringify(storage.getItem(key)) === JSON.stringify(value);
+}
+function migrateArea(storage, projectId, keys) {
+  const schema = storage.getItem(STORAGE_SCHEMA_KEY);
+  if (schema !== null) {
+    if (schema.version !== STORAGE_SCHEMA_VERSION || schema.projectId !== projectId) return false;
+    if (schema.complete === true) return true;
+    if (schema.complete !== false) return false;
+  } else {
+    if (keys.some((key) => storage.getItem(namespacedKey(key, projectId)) !== null)) {
+      return writeVerified(storage, STORAGE_SCHEMA_KEY, { version: STORAGE_SCHEMA_VERSION, projectId, complete: true });
+    }
+    if (!writeVerified(storage, STORAGE_SCHEMA_KEY, { version: STORAGE_SCHEMA_VERSION, projectId, complete: false })) {
+      return false;
+    }
+  }
+  for (const key of keys) {
+    const target = namespacedKey(key, projectId);
+    if (storage.getItem(target) !== null) continue;
+    const legacy = storage.getItem(key);
+    if (legacy !== null && !writeVerified(storage, target, legacy)) return false;
+  }
+  return writeVerified(storage, STORAGE_SCHEMA_KEY, { version: STORAGE_SCHEMA_VERSION, projectId, complete: true });
+}
+function migrateLegacyStorage(projectId, local, session, cookie, logger) {
+  try {
+    if (!migrateArea(local, projectId, LOCAL_KEYS)) return;
+    migrateArea(session, projectId, SESSION_KEYS);
+    if (cookie) migrateArea(cookie, projectId, COOKIE_KEYS);
+  } catch (error) {
+    logger.error("Failed to migrate legacy Observe storage", error);
+  }
+}
+export {
+  STORAGE_SCHEMA_KEY,
+  STORAGE_SCHEMA_VERSION,
+  migrateLegacyStorage
+};

package/dist/analysis/store/event-store.mjs

@@ -0,0 +1,114 @@
+// src/store/event-store.ts
+import { withWebLock } from "../utils/web-lock.mjs";
+var OUTBOX_STORAGE_KEY = "cbo_outbox";
+var OUTBOX_LOCK_NAME = "cbo_outbox";
+var DEFAULT_MAX_ENTRIES = 500;
+var DEFAULT_MAX_SERIALIZED_LENGTH = 512 * 1024;
+function isOutboxEntry(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const entry = value;
+  return typeof entry.id === "string" && entry.id !== "" && typeof entry.sessionId === "string" && typeof entry.flushAfter === "number" && Number.isFinite(entry.flushAfter) && typeof entry.attempts === "number" && Number.isFinite(entry.attempts) && typeof entry.event === "object" && entry.event !== null;
+}
+var EventStore = class {
+  constructor(storage, logger, maxEntries = DEFAULT_MAX_ENTRIES, maxSerializedLength = DEFAULT_MAX_SERIALIZED_LENGTH, lockName = OUTBOX_LOCK_NAME, storageKey = OUTBOX_STORAGE_KEY) {
+    this.storage = storage;
+    this.logger = logger;
+    this.maxEntries = maxEntries;
+    this.maxSerializedLength = maxSerializedLength;
+    this.lockName = lockName;
+    this.storageKey = storageKey;
+    this.entries = this.read();
+  }
+  entries = [];
+  /** Malformed entries are dropped on every read; report only once per instance to avoid log spam. */
+  reportedMalformed = false;
+  read() {
+    const raw = this.storage.getItem(this.storageKey);
+    if (!Array.isArray(raw)) {
+      return [];
+    }
+    const valid = raw.filter(isOutboxEntry);
+    if (valid.length < raw.length && !this.reportedMalformed) {
+      this.reportedMalformed = true;
+      this.logger.error(`EventStore dropped ${raw.length - valid.length} malformed outbox entries`);
+      this.logger.reportTelemetry?.("error", "event store dropped malformed outbox entries");
+    }
+    return valid;
+  }
+  mutate(fn) {
+    return withWebLock(this.lockName, () => {
+      try {
+        let next = fn(this.read());
+        if (next.length > this.maxEntries) {
+          const evicted = next.length - this.maxEntries;
+          next = next.slice(next.length - this.maxEntries);
+          this.logger.error(`EventStore evicted ${evicted} oldest entries (cap ${this.maxEntries})`);
+          this.logger.reportTelemetry?.("error", "event store evicted entries (cap)");
+        }
+        next = this.enforceSizeBudget(next);
+        this.entries = next;
+        this.storage.setItem(this.storageKey, next);
+      } catch (error) {
+        this.logger.error("Failed to mutate event store", error);
+        this.logger.reportTelemetry?.("error", "failed to mutate event store");
+      }
+    });
+  }
+  /** Evict oldest entries until the serialized outbox fits {@link maxSerializedLength}. */
+  enforceSizeBudget(next) {
+    const sizes = next.map((entry) => JSON.stringify(entry).length);
+    let total = sizes.reduce((sum, size) => sum + size, next.length + 1);
+    let evict = 0;
+    while (total > this.maxSerializedLength && evict < next.length) {
+      total -= sizes[evict] + 1;
+      evict++;
+    }
+    if (evict === 0) {
+      return next;
+    }
+    this.logger.error(`EventStore evicted ${evict} oldest entries (size budget ${this.maxSerializedLength})`);
+    this.logger.reportTelemetry?.("error", "event store evicted entries (size budget)");
+    return next.slice(evict);
+  }
+  /** Append an entry. No-op if an entry with the same id already exists. */
+  add(entry) {
+    return this.mutate((current) => current.some((e) => e.id === entry.id) ? current : [...current, entry]);
+  }
+  /** Re-read from storage and return all entries (memory mirror refreshed). */
+  all() {
+    this.entries = this.read();
+    return this.entries;
+  }
+  /** Entries whose `flushAfter` has elapsed, in insertion order. */
+  getDue(now) {
+    return this.all().filter((entry) => entry.flushAfter <= now);
+  }
+  /** Remove entries by id (acknowledged or permanently dropped). */
+  remove(ids) {
+    if (ids.length === 0) {
+      return Promise.resolve();
+    }
+    const idSet = new Set(ids);
+    return this.mutate((current) => current.filter((entry) => !idSet.has(entry.id)));
+  }
+  /** Replace existing entries (matched by id) with updated copies, e.g. after bumping backoff. */
+  update(updated) {
+    if (updated.length === 0) {
+      return Promise.resolve();
+    }
+    const byId = new Map(updated.map((entry) => [entry.id, entry]));
+    return this.mutate((current) => current.map((entry) => byId.get(entry.id) ?? entry));
+  }
+  size() {
+    return this.all().length;
+  }
+};
+export {
+  DEFAULT_MAX_ENTRIES,
+  DEFAULT_MAX_SERIALIZED_LENGTH,
+  EventStore,
+  OUTBOX_LOCK_NAME,
+  OUTBOX_STORAGE_KEY
+};

package/dist/analysis/transports/fetch.mjs

@@ -0,0 +1,108 @@
+// src/transports/fetch.ts
+import { parseReliabilityConfig } from "../config.mjs";
+var MAX_KEEPALIVE_BODY_BYTES = 6e4;
+var FETCH_TIMEOUT_MS = 6e4;
+var FetchTransport = class {
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Error situations:
+   *  - JSON.stringify(batch) throws: log "Failed to send event" and return empty TransportMakeRequestResponse
+   *  - fetch throws or rejects: log "Failed to send event" and return empty TransportMakeRequestResponse
+   *  - Reading the response (e.g. status or headers) throws: log "Failed to send event" and return empty TransportMakeRequestResponse
+   *
+   * When `extraHeaders` requests the SDK config (HTTP 200 with a body), the parsed config is returned
+   * in `config`. A 204 (legacy/back-compat) carries no body and leaves `config` undefined.
+   */
+  async send(batch, extraHeaders) {
+    try {
+      batch.meta = {
+        ...batch.meta,
+        sent: Date.now(),
+        transport: "fetch"
+      };
+      const body = JSON.stringify(batch);
+      const controller = typeof AbortController !== "undefined" ? new AbortController() : void 0;
+      const timeout = controller ? setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS) : void 0;
+      try {
+        const requestOptions = {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...this.options.headers,
+            ...extraHeaders
+          },
+          body,
+          keepalive: new Blob([body]).size <= MAX_KEEPALIVE_BODY_BYTES,
+          ...controller ? { signal: controller.signal } : {}
+        };
+        const response = await fetch(this.options.url, requestOptions);
+        const result = {
+          statusCode: response.status,
+          headers: {
+            "retry-after": response.headers.get("Retry-After")
+          }
+        };
+        if (response.headers.get("X-Corbado-Observe-Accepted") === "1") result.deliveryAccepted = true;
+        if (response.status === 200) {
+          try {
+            const config = parseReliabilityConfig(await response.json());
+            if (config) {
+              result.config = config;
+            }
+          } catch (error) {
+            this.options.logger.error("Failed to parse SDK config response", error);
+            this.options.logger.reportTelemetry?.("error", "failed to parse SDK config response");
+          }
+        }
+        return result;
+      } finally {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+      }
+    } catch (error) {
+      this.options.logger.error("Failed to send event", error);
+      return {};
+    }
+  }
+  /**
+   * Error situations:
+   *  - navigator.sendBeacon is not a function: return false
+   *  - JSON.stringify(batch) throws: log "Failed to send event via beacon" and return false
+   *  - Blob construction throws: log "Failed to send event via beacon" and return false
+   *  - navigator.sendBeacon throws: log "Failed to send event via beacon" and return false
+   */
+  sendBeacon(batch) {
+    try {
+      this.options.logger.debug(`Sending ${batch.events.length} events via beacon`);
+      if (typeof navigator?.sendBeacon !== "function") {
+        return false;
+      }
+      batch.meta = {
+        ...batch.meta,
+        sent: Date.now(),
+        transport: "beacon"
+      };
+      const blob = new Blob([JSON.stringify(batch)], {
+        // Using text/plain is recommended as it skips CORS handling. The ingestion API
+        // can handle both text/plain and application/json.
+        type: "text/plain"
+      });
+      return navigator.sendBeacon(this.options.url, blob);
+    } catch (error) {
+      this.options.logger.error("Failed to send event via beacon", error);
+      return false;
+    }
+  }
+  /**
+   * This transport does not buffer requests; always resolves with true. The `timeout` argument is unused.
+   */
+  flush(timeout) {
+    return Promise.resolve(true);
+  }
+};
+export {
+  FetchTransport
+};

package/dist/analysis/types.mjs

@@ -0,0 +1,25 @@
+// src/types.ts
+var AuthEventName = /* @__PURE__ */ ((AuthEventName2) => {
+  AuthEventName2["FlowStarted"] = "flow_started";
+  AuthEventName2["FlowDecided"] = "flow_decided";
+  AuthEventName2["FlowFinished"] = "flow_finished";
+  AuthEventName2["FlowReset"] = "flow_reset";
+  AuthEventName2["AuthMethodDecisionStarted"] = "auth_method_decision_started";
+  AuthEventName2["AuthMethodDecisionFinished"] = "auth_method_decision_finished";
+  AuthEventName2["FlowAutoFinished"] = "flow_auto_finished";
+  AuthEventName2["AuthDecisionStarted"] = "auth_decision_started";
+  AuthEventName2["AuthDecisionFinished"] = "auth_decision_finished";
+  AuthEventName2["SubflowStepStarted"] = "subflow_step_started";
+  AuthEventName2["SubflowStepFinished"] = "subflow_step_finished";
+  AuthEventName2["SubflowStepError"] = "subflow_step_error";
+  AuthEventName2["SubflowTrigger"] = "subflow_trigger";
+  AuthEventName2["SubflowError"] = "subflow_error";
+  AuthEventName2["SubflowStarted"] = "subflow_started";
+  AuthEventName2["SubflowFinished"] = "subflow_finished";
+  AuthEventName2["FlowEnriched"] = "flow_enriched";
+  AuthEventName2["Conversion"] = "conversion";
+  return AuthEventName2;
+})(AuthEventName || {});
+export {
+  AuthEventName
+};

package/dist/analysis/utils/appconfirmation-operation-full.mjs

@@ -0,0 +1,19 @@
+// src/utils/appconfirmation-operation-full.ts
+import { OperationFull } from "./operation-full.mjs";
+var AppConfirmationOperationFull = class extends OperationFull {
+  // One app confirmation, on the same device, reached through a QR handoff, or pushed to an enrolled device.
+  ceremony;
+  retry;
+  /** Optional separate browser exchange after approval; omit when the final poll already proves acceptance. */
+  postResponse;
+  constructor(tracker, config = {}) {
+    super(tracker, "app-confirmation");
+    this.ceremony = this.defineStep("ceremony");
+    this.retry = this.defineStep("retry");
+    this.postResponse = this.defineStep("post-response");
+    void this.subflowStart({ explicitSpecType: config.explicitSpecType });
+  }
+};
+export {
+  AppConfirmationOperationFull
+};

package/dist/analysis/utils/blocked-user-agents.mjs

@@ -0,0 +1,37 @@
+// src/utils/blocked-user-agents.ts
+var BLOCKED_UA_SUBSTRINGS = [
+  "ahrefsbot",
+  "ahrefssiteaudit",
+  "amazonbot",
+  "baiduspider",
+  "bingbot",
+  "bingpreview",
+  "chrome-lighthouse",
+  "facebookexternal",
+  "petalbot",
+  "pinterest",
+  "screaming frog",
+  "yahoo! slurp",
+  "yandex",
+  "adsbot-google",
+  "apis-google",
+  "duplexweb-google",
+  "feedfetcher-google",
+  "google favicon",
+  "google web preview",
+  "google-read-aloud",
+  "googlebot",
+  "googleweblight",
+  "mediapartners-google",
+  "storebot-google"
+];
+function isBlockedUserAgent(userAgent) {
+  if (!userAgent) {
+    return false;
+  }
+  const normalizedUa = userAgent.toLowerCase();
+  return BLOCKED_UA_SUBSTRINGS.some((blockedUa) => normalizedUa.includes(blockedUa));
+}
+export {
+  isBlockedUserAgent
+};

package/dist/analysis/utils/captcha-operation-full.mjs

@@ -0,0 +1,17 @@
+// src/utils/captcha-operation-full.ts
+import { OperationFull } from "./operation-full.mjs";
+var CaptchaOperationFull = class extends OperationFull {
+  /** Step representing the captcha challenge ceremony. */
+  ceremony;
+  /** Submission of the captcha token and the server's verdict on it. */
+  postResponse;
+  constructor(tracker, config = {}) {
+    super(tracker, "captcha");
+    this.ceremony = this.defineStep("ceremony");
+    this.postResponse = this.defineStep("post-response");
+    void this.subflowStart({ explicitSpecType: config.explicitSpecType });
+  }
+};
+export {
+  CaptchaOperationFull
+};

package/dist/analysis/utils/email-link-continuity.mjs

@@ -0,0 +1,50 @@
+// src/utils/email-link-continuity.ts
+var EMAIL_LINK_STARTS_STORAGE_KEY = "cbo_email_link_starts";
+var EMAIL_LINK_START_TTL_MS = 24 * 60 * 60 * 1e3;
+var MAX_ENTRIES = 10;
+function read(storage, now) {
+  const raw = storage.getItem(EMAIL_LINK_STARTS_STORAGE_KEY);
+  if (!Array.isArray(raw)) return [];
+  return raw.filter(
+    (entry) => !!entry && typeof entry === "object" && typeof entry.transactionId === "string" && typeof entry.anchor === "string" && typeof entry.sessionId === "string" && typeof entry.startedAt === "number" && now - entry.startedAt < EMAIL_LINK_START_TTL_MS
+  );
+}
+function rememberEmailLinkStart(storage, entry) {
+  if (!storage) return;
+  try {
+    const entries = read(storage, entry.startedAt).filter((e) => e.transactionId !== entry.transactionId);
+    entries.push(entry);
+    storage.setItem(EMAIL_LINK_STARTS_STORAGE_KEY, entries.slice(-MAX_ENTRIES));
+  } catch {
+  }
+}
+function findEmailLinkStart(storage, query, now = Date.now()) {
+  if (!storage) return void 0;
+  try {
+    const entries = read(storage, now);
+    if (query.transactionId) return entries.find((e) => e.transactionId === query.transactionId);
+    const pending = entries.filter(
+      (e) => !e.continued && (!query.specType || !e.specType || e.specType === query.specType)
+    );
+    return pending[pending.length - 1];
+  } catch {
+    return void 0;
+  }
+}
+function markEmailLinkContinued(storage, transactionId) {
+  if (!storage) return;
+  try {
+    const entries = read(storage, Date.now()).map(
+      (e) => e.transactionId === transactionId ? { ...e, continued: true } : e
+    );
+    storage.setItem(EMAIL_LINK_STARTS_STORAGE_KEY, entries);
+  } catch {
+  }
+}
+export {
+  EMAIL_LINK_STARTS_STORAGE_KEY,
+  EMAIL_LINK_START_TTL_MS,
+  findEmailLinkStart,
+  markEmailLinkContinued,
+  rememberEmailLinkStart
+};

package/dist/analysis/utils/email-link-operation-full.mjs

@@ -0,0 +1,142 @@
+// src/utils/email-link-operation-full.ts
+import { v7 as uuidv7 } from "uuid";
+import { OperationFull } from "./operation-full.mjs";
+import { findEmailLinkStart, markEmailLinkContinued, rememberEmailLinkStart } from "./email-link-continuity.mjs";
+var EmailLinkOperationFull = class extends OperationFull {
+  send;
+  postResponse;
+  resend;
+  /** Transaction ID of this email link; hand it to the page that continues it. */
+  transactionId;
+  constructor(tracker, config = {}) {
+    super(tracker, "email-link");
+    this.send = this.defineStep("send");
+    this.postResponse = this.defineStep("post-response");
+    this.resend = this.defineStep("resend");
+    this.transactionId = config.transactionId || uuidv7();
+    void this.subflowStart(
+      { explicitSpecType: config.explicitSpecType },
+      { userReference: { crossEnvironmentTransactionIDStart: this.transactionId } }
+    );
+    const anchor = this.captureReference;
+    const sessionId = this.captureSession;
+    if (anchor && sessionId) {
+      rememberEmailLinkStart(tracker.getPersistentStorage(), {
+        transactionId: this.transactionId,
+        anchor,
+        sessionId,
+        specType: config.explicitSpecType,
+        startedAt: Date.now()
+      });
+    }
+  }
+};
+var EmailLinkContinuationOperation = class extends OperationFull {
+  postResponse;
+  resend;
+  mode;
+  continuationTracker;
+  specType;
+  createdAt = Date.now();
+  transaction;
+  started = false;
+  deferred = [];
+  onPageHide = () => this.flush();
+  constructor(tracker, config = {}) {
+    super(tracker, "email-link");
+    this.continuationTracker = tracker;
+    this.specType = config.explicitSpecType;
+    this.transaction = config.transactionId;
+    this.postResponse = this.deferrable(this.defineStep("post-response"), true);
+    this.resend = this.deferrable(this.defineStep("resend"));
+    const storage = tracker.getPersistentStorage();
+    const entry = findEmailLinkStart(storage, {
+      transactionId: config.transactionId,
+      specType: config.explicitSpecType
+    });
+    if (entry && entry.sessionId === tracker.getSessionId()) {
+      this.mode = "attached";
+      this.transaction = config.transactionId ?? entry.transactionId;
+      this.adoptCapture(entry.anchor, entry.sessionId, entry.specType ?? config.explicitSpecType);
+      this.started = true;
+      return;
+    }
+    this.mode = "detached";
+    if (this.transaction) {
+      this.startDetached(this.createdAt);
+    } else if (typeof window !== "undefined") {
+      window.addEventListener("pagehide", this.onPageHide);
+    }
+  }
+  /** Transaction ID of the continued email link, when known. */
+  get transactionId() {
+    return this.transaction;
+  }
+  /**
+   * Supply the transaction ID once it is known. In detached mode this emits the deferred
+   * continuation start (back-dated to the first deferred step, or construction) and replays the
+   * deferred steps. Has no effect once a detached start was emitted without an ID.
+   */
+  setTransactionId(transactionId) {
+    if (!transactionId || this.transaction) return;
+    this.transaction = transactionId;
+    if (this.mode === "detached" && !this.started) this.startDetached(this.firstDeferredAt());
+  }
+  /** Emit a pending detached start (without transaction ID) and its deferred steps now. */
+  flush() {
+    if (this.mode === "detached" && !this.started) this.startDetached(this.firstDeferredAt());
+  }
+  /** Flush anything pending and release the page-hide listener. */
+  destroy() {
+    this.flush();
+    this.removePageHideListener();
+  }
+  firstDeferredAt() {
+    return this.deferred[0]?.at ?? this.createdAt;
+  }
+  startDetached(timestamp) {
+    this.started = true;
+    this.removePageHideListener();
+    this.subflowStart(
+      { explicitSpecType: this.specType, continuation: true },
+      {
+        explicitTimestamp: timestamp,
+        ...this.transaction ? { userReference: { crossEnvironmentTransactionIDFinish: this.transaction } } : {}
+      }
+    );
+    const calls = this.deferred;
+    this.deferred = [];
+    for (const call of calls) call.run(call.at);
+    try {
+      this.continuationTracker.flushKeepalive();
+    } catch {
+    }
+  }
+  removePageHideListener() {
+    if (typeof window !== "undefined") window.removeEventListener("pagehide", this.onPageHide);
+  }
+  /** Defer step calls until the detached start is emitted; mark the continued link on completion. */
+  deferrable(step, completesLink = false) {
+    const call = (run, options) => {
+      if (this.started) {
+        run(options?.explicitTimestamp ?? Date.now());
+        return;
+      }
+      this.deferred.push({ at: options?.explicitTimestamp ?? Date.now(), run });
+    };
+    return {
+      start: (data, options) => call((explicitTimestamp) => step.start(data, { ...options, explicitTimestamp }), options),
+      finished: (data, options) => {
+        call((explicitTimestamp) => step.finished(data, { ...options, explicitTimestamp }), options);
+        if (completesLink && this.transaction) {
+          markEmailLinkContinued(this.continuationTracker.getPersistentStorage(), this.transaction);
+        }
+      },
+      error: (error, options) => call((explicitTimestamp) => step.error(error, { ...options, explicitTimestamp }), options)
+    };
+  }
+};
+export {
+  EmailLinkContinuationOperation,
+  EmailLinkOperationFull
+};

package/dist/analysis/utils/email-otp-operation-full.mjs

@@ -0,0 +1,39 @@
+// src/utils/email-otp-operation-full.ts
+import { OTPInputBinding } from "../low-events/otp-input-binding.mjs";
+import { OperationFull } from "./operation-full.mjs";
+var EmailOtpOperationFull = class extends OperationFull {
+  lowEventTracker;
+  send;
+  postResponse;
+  resend;
+  constructor(tracker, config = {}) {
+    super(tracker, "email-otp");
+    this.send = this.defineStep("send");
+    this.postResponse = this.defineStep("post-response");
+    this.resend = this.defineStep("resend");
+    void this.subflowStart({ explicitSpecType: config.explicitSpecType, emailDomain: config.emailDomain });
+    this.lowEventTracker = this.createLowCollector(
+      () => new OTPInputBinding(
+        tracker.getLogger(),
+        this.lowEventSink("input", "otp"),
+        this.lowEventSink("input-group", "otp")
+      )
+    );
+    if (config.inputHtmlFields?.length) {
+      this.setInputFields(config.inputHtmlFields);
+    } else if (config.inputHtmlField) {
+      this.lowEventTracker?.setFields([config.inputHtmlField], false);
+    }
+    this.registerLowFlusher(() => this.lowEventTracker?.flushPending());
+  }
+  /** Rebind the ordered OTP group without starting a new subflow. An empty list detaches it. */
+  setInputFields(fields) {
+    this.lowEventTracker?.setFields(fields);
+  }
+  destroy() {
+    this.lowEventTracker?.destroy();
+  }
+};
+export {
+  EmailOtpOperationFull
+};