@corbado/observe 1.7.1 → 1.8.0

package/dist/analysis/logger.mjs

@@ -0,0 +1,50 @@
+// src/logger.ts
+function createLogger(options) {
+  const debugEnabled = options.debug;
+  let telemetrySink;
+  const withPrefix = (level, message) => `[Corbado Observe SDK ${level}] ${message}`;
+  return {
+    reportTelemetry(level, message) {
+      if (!telemetrySink) {
+        return;
+      }
+      try {
+        telemetrySink(level, message);
+      } catch {
+      }
+    },
+    setTelemetrySink(sink) {
+      telemetrySink = sink;
+    },
+    debug(message, ...args) {
+      if (!debugEnabled) {
+        return;
+      }
+      console.log(withPrefix("DEBUG", message), ...args);
+    },
+    info(message, ...args) {
+      if (!debugEnabled) {
+        return;
+      }
+      console.log(withPrefix("INFO", message), ...args);
+    },
+    warn(message, ...args) {
+      if (!debugEnabled) {
+        return;
+      }
+      console.warn(withPrefix("WARN", message), ...args);
+    },
+    error(message, ...args) {
+      if (!debugEnabled) {
+        return;
+      }
+      console.error(withPrefix("ERROR", message), ...args);
+    },
+    critical(message, ...args) {
+      console.error(withPrefix("CRITICAL", message), ...args);
+    }
+  };
+}
+export {
+  createLogger
+};

package/dist/analysis/low-events/capture-sequence.mjs

@@ -0,0 +1,11 @@
+// src/low-events/capture-sequence.ts
+var captureSequence = 0;
+function reserveCaptureSeq() {
+  if (captureSequence === 4294967295) {
+    throw new Error("Low-event capture sequence exhausted");
+  }
+  return ++captureSequence;
+}
+export {
+  reserveCaptureSeq
+};

package/dist/analysis/low-events/ceremony-initiator.mjs

@@ -0,0 +1,26 @@
+// src/low-events/ceremony-initiator.ts
+function inferCeremonyInitiator(operation, spec) {
+  if (operation === "passkey-login") {
+    switch (spec) {
+      case "passkey-known-identifier":
+      case "passkey-no-identifier":
+        return "passkey-button";
+      case "passkey-known-identifier-auto":
+      case "passkey-no-identifier-auto":
+      case "passkey-immediate":
+        return "automatic";
+    }
+  } else if (operation === "passkey-enrollment") {
+    switch (spec) {
+      case "manual":
+        return "passkey-button";
+      case "auto":
+      case "conditional":
+        return "automatic";
+    }
+  }
+  return void 0;
+}
+export {
+  inferCeremonyInitiator
+};

package/dist/analysis/low-events/form-input-binding.mjs

@@ -0,0 +1,46 @@
+// src/low-events/form-input-binding.ts
+import { LowEventInputTracker } from "./input-tracker.mjs";
+var FormInputBinding = class {
+  constructor(logger, sink) {
+    this.logger = logger;
+    this.sink = sink;
+  }
+  trackers = /* @__PURE__ */ new Map();
+  destroyed = false;
+  /** Bind exactly these fields; an empty list detaches every field. */
+  setFields(fields) {
+    if (this.destroyed) return;
+    const next = new Set(fields);
+    for (const [field, tracker] of this.trackers) {
+      if (next.has(field)) continue;
+      this.safe(() => tracker.destroy());
+      this.trackers.delete(field);
+    }
+    for (const field of next) {
+      if (this.trackers.has(field)) continue;
+      this.safe(() => this.trackers.set(field, new LowEventInputTracker(this.logger, field, this.sink())));
+    }
+  }
+  capturePrefill(newCapture = false) {
+    for (const tracker of this.trackers.values()) this.safe(() => tracker.capturePrefill(newCapture));
+  }
+  flushPending() {
+    for (const tracker of this.trackers.values()) this.safe(() => tracker.flushPending());
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    for (const tracker of this.trackers.values()) this.safe(() => tracker.destroy());
+    this.trackers.clear();
+  }
+  safe(run) {
+    try {
+      run();
+    } catch (error) {
+      this.logger.error("Form input binding failed", error);
+    }
+  }
+};
+export {
+  FormInputBinding
+};

package/dist/analysis/low-events/grouped-input-tracker.mjs

@@ -0,0 +1,133 @@
+// src/low-events/grouped-input-tracker.ts
+import { InputChangeRecorder } from "./input-change-recorder.mjs";
+import { InputPasteObserver } from "./input-paste-observer.mjs";
+var LowEventGroupedInputTracker = class {
+  constructor(logger, fields, sink) {
+    this.logger = logger;
+    this.sink = sink;
+    this.inputs = [...new Set(fields)];
+    this.changes = new InputChangeRecorder(
+      this.length(),
+      (low) => sink.enqueueLowEvent(low),
+      logger,
+      sink.reserveCaptureSeq
+    );
+    this.paste = new InputPasteObserver(
+      this.inputs,
+      logger,
+      (ts, _inserted, captureSeq) => {
+        this.cancelChange();
+        this.changes.flush();
+        this.changes.markInputObserved();
+        const oldLength = this.changes.previousLength;
+        this.changes.previousLength = this.length();
+        sink.enqueueLowEvent({
+          ...captureSeq === void 0 ? {} : { captureSeq },
+          lowType: "input-paste",
+          ts,
+          inputEffect: this.length() === 0 ? "clear" : oldLength === 0 ? "fill" : "modify"
+        });
+      },
+      sink.reserveCaptureSeq
+    );
+    this.unregisterInputs = sink.registerInputs?.(this.inputs, () => this.flushPending());
+    this.capturePrefill();
+    for (const input of this.inputs) {
+      this.listen(input, "input", (event) => {
+        if (this.paste.handlesInput(event)) return;
+        this.composing ||= event.isComposing || event.inputType === "insertCompositionText";
+        if (this.changeTimer !== null) return;
+        this.changeTime = Date.now();
+        this.changeSeq = sink.reserveCaptureSeq?.();
+        this.changeTimer = setTimeout(() => this.safe(() => this.flushChanges()), 0);
+      });
+      this.listen(input, "focus", (event) => {
+        if (this.contains(event.relatedTarget)) return;
+        this.emit("focus");
+      });
+      this.listen(input, "blur", (event) => {
+        if (this.contains(event.relatedTarget)) return;
+        this.flushPending();
+        this.emit("blur");
+      });
+      for (const type of ["click", "pointerdown", "pointerup"]) this.listen(input, type, () => this.emit(type));
+      this.listen(input, "keyup", (event) => {
+        if (event.key === "Escape") this.emit("keyup-escape");
+      });
+    }
+    if (typeof window !== "undefined")
+      this.listen(window, "pagehide", () => {
+        this.flushPending();
+        sink.flushKeepalive();
+      });
+    if (typeof document !== "undefined" && this.contains(document.activeElement)) {
+      this.emit("focus");
+    }
+  }
+  inputs;
+  changes;
+  paste;
+  unregisterInputs;
+  listeners = [];
+  changeTimer = null;
+  changeTime = 0;
+  changeSeq;
+  composing = false;
+  destroyed = false;
+  contains(target) {
+    return this.inputs.some((field) => field === target);
+  }
+  length() {
+    return this.inputs.reduce((total, field) => total + field.value.length, 0);
+  }
+  safe(action) {
+    try {
+      action();
+    } catch (error) {
+      this.logger.error("Failed to observe grouped input", error);
+    }
+  }
+  listen(target, type, handler) {
+    const wrapped = (event) => this.safe(() => handler(event));
+    target.addEventListener(type, wrapped);
+    this.listeners.push(() => target.removeEventListener(type, wrapped));
+  }
+  cancelChange() {
+    if (this.changeTimer !== null) clearTimeout(this.changeTimer);
+    this.changeTimer = null;
+  }
+  flushChanges() {
+    if (this.changeTimer === null) return;
+    this.cancelChange();
+    if (!this.paste.pending) this.changes.record(this.length(), this.changeTime, this.composing, this.changeSeq);
+    this.composing = false;
+  }
+  emit(lowType) {
+    this.flushChanges();
+    this.changes.flush();
+    this.sink.enqueueLowEvent({ lowType, ts: Date.now() });
+  }
+  capturePrefill(newCapture = false) {
+    if (this.destroyed) return;
+    this.flushPending();
+    this.changes.capturePrefill(this.length(), newCapture);
+  }
+  flushPending() {
+    this.paste.flush();
+    this.flushChanges();
+    this.changes.flush();
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.safe(() => {
+      this.flushPending();
+      this.paste.destroy();
+      this.unregisterInputs?.();
+      for (const remove of this.listeners) remove();
+    });
+  }
+};
+export {
+  LowEventGroupedInputTracker
+};

package/dist/analysis/low-events/input-change-recorder.mjs

@@ -0,0 +1,200 @@
+// src/low-events/input-change-recorder.ts
+var INPUT_IDLE_MS = 3e3;
+var BIG_INPUT_DELTA_THRESHOLD = 3;
+var AUTOFILL_STREAK_LENGTH = 5;
+var AUTOFILL_FAST_INTERVAL_MS = 80;
+var AUTOFILL_UNIFORM_SPREAD_MS = 25;
+var InputChangeRecorder = class {
+  constructor(previousLength, pushLow, logger, reserveCaptureSeq) {
+    this.previousLength = previousLength;
+    this.pushLow = pushLow;
+    this.logger = logger;
+    this.reserveCaptureSeq = reserveCaptureSeq;
+  }
+  prefillSettled = false;
+  inputBatch = null;
+  currentEffect = "modify";
+  ringEffect = "modify";
+  autofillTimestamps = [];
+  autofillStreak = null;
+  idleTimer = null;
+  markInputObserved() {
+    this.prefillSettled = true;
+  }
+  capturePrefill(length, newCapture = false) {
+    if (newCapture) this.prefillSettled = false;
+    if (this.prefillSettled) return;
+    this.previousLength = length;
+    if (length === 0) return;
+    this.prefillSettled = true;
+    this.pushLow({ lowType: "input-prefill", ts: Date.now(), initiator: "unknown" });
+  }
+  flush() {
+    this.cancelIdle();
+    this.flushInputBatch();
+    this.flushAutofillStreak();
+  }
+  cancelIdle() {
+    if (this.idleTimer !== null) clearTimeout(this.idleTimer);
+    this.idleTimer = null;
+  }
+  scheduleIdle() {
+    this.cancelIdle();
+    this.idleTimer = setTimeout(() => {
+      this.idleTimer = null;
+      try {
+        this.flushInputBatch(true);
+        this.flushAutofillStreak();
+      } catch (error) {
+        this.logger.error("Failed to flush idle input", error);
+      }
+    }, INPUT_IDLE_MS);
+  }
+  extendInputBatch(timestamp, effect = this.currentEffect, captureSeq) {
+    const batch = this.inputBatch;
+    if (!batch) {
+      this.inputBatch = { firstTimestamp: timestamp, lastTimestamp: timestamp, effect, captureSeq };
+      return;
+    }
+    batch.lastTimestamp = timestamp;
+  }
+  drainAutofillRingToBatch() {
+    for (const ts of this.autofillTimestamps) {
+      this.extendInputBatch(ts.ts, this.ringEffect, ts.captureSeq);
+    }
+    this.autofillTimestamps.length = 0;
+  }
+  flushInputBatch(idle = false) {
+    this.drainAutofillRingToBatch();
+    const batch = this.inputBatch;
+    if (!batch) {
+      return;
+    }
+    this.pushLow({
+      ...batch.captureSeq === void 0 ? {} : { captureSeq: batch.captureSeq },
+      lowType: idle ? "input-idle" : "input",
+      ts: batch.firstTimestamp,
+      durationMs: batch.lastTimestamp - batch.firstTimestamp,
+      inputEffect: batch.effect
+    });
+    this.inputBatch = null;
+  }
+  flushAutofillStreak() {
+    const streak = this.autofillStreak;
+    if (!streak) {
+      return;
+    }
+    this.pushLow({
+      ...streak.captureSeq === void 0 ? {} : { captureSeq: streak.captureSeq },
+      lowType: "big-input-add",
+      ts: streak.firstTimestamp,
+      durationMs: streak.lastTimestamp - streak.firstTimestamp,
+      inputEffect: streak.effect
+    });
+    this.autofillStreak = null;
+  }
+  detectAutofillStreak() {
+    const ring = this.autofillTimestamps;
+    if (ring.length < AUTOFILL_STREAK_LENGTH) {
+      return false;
+    }
+    let minInterval = Infinity;
+    let maxInterval = -Infinity;
+    for (let i = 1; i < ring.length; i++) {
+      const interval = ring[i].ts - ring[i - 1].ts;
+      if (interval > AUTOFILL_FAST_INTERVAL_MS) {
+        return false;
+      }
+      if (interval < minInterval) {
+        minInterval = interval;
+      }
+      if (interval > maxInterval) {
+        maxInterval = interval;
+      }
+    }
+    return maxInterval - minInterval <= AUTOFILL_UNIFORM_SPREAD_MS;
+  }
+  record(newLength, timestamp = Date.now(), composing = false, captureSeq = this.reserveCaptureSeq?.()) {
+    this.markInputObserved();
+    this.scheduleIdle();
+    const oldLength = this.previousLength;
+    this.currentEffect = newLength === 0 ? "clear" : oldLength === 0 ? "fill" : "modify";
+    const delta = newLength - oldLength;
+    this.previousLength = newLength;
+    if (newLength === 0 && oldLength > 0) {
+      this.flush();
+      this.pushLow({
+        ...captureSeq === void 0 ? {} : { captureSeq },
+        lowType: "input-clear",
+        ts: timestamp,
+        inputEffect: "clear"
+      });
+      return;
+    }
+    if (composing) {
+      this.flushAutofillStreak();
+      this.drainAutofillRingToBatch();
+      this.extendInputBatch(timestamp, this.currentEffect, captureSeq);
+      return;
+    }
+    if (delta >= BIG_INPUT_DELTA_THRESHOLD) {
+      this.flushInputBatch();
+      this.flushAutofillStreak();
+      this.pushLow({
+        ...captureSeq === void 0 ? {} : { captureSeq },
+        lowType: "big-input-add",
+        ts: timestamp,
+        inputEffect: this.currentEffect
+      });
+      return;
+    }
+    if (delta <= -BIG_INPUT_DELTA_THRESHOLD) {
+      this.flushInputBatch();
+      this.flushAutofillStreak();
+      this.pushLow({
+        ...captureSeq === void 0 ? {} : { captureSeq },
+        lowType: "big-input-rem",
+        ts: timestamp,
+        inputEffect: this.currentEffect
+      });
+      return;
+    }
+    const activeStreak = this.autofillStreak;
+    if (activeStreak) {
+      if (delta === 1 && timestamp - activeStreak.lastTimestamp <= AUTOFILL_FAST_INTERVAL_MS) {
+        activeStreak.lastTimestamp = timestamp;
+        return;
+      }
+      this.flushAutofillStreak();
+    }
+    if (delta !== 1) {
+      this.drainAutofillRingToBatch();
+      this.extendInputBatch(timestamp, this.currentEffect, captureSeq);
+      return;
+    }
+    const ring = this.autofillTimestamps;
+    if (ring.length === 0) this.ringEffect = this.currentEffect;
+    ring.push({ ts: timestamp, captureSeq });
+    if (ring.length > AUTOFILL_STREAK_LENGTH) {
+      const graduated = ring.shift();
+      this.extendInputBatch(graduated.ts, this.ringEffect, graduated.captureSeq);
+      this.ringEffect = "modify";
+    }
+    if (!this.detectAutofillStreak()) {
+      return;
+    }
+    const streakStart = ring[0];
+    const streakLast = ring[ring.length - 1];
+    ring.length = 0;
+    this.flushInputBatch();
+    this.autofillStreak = {
+      firstTimestamp: streakStart.ts,
+      captureSeq: streakStart.captureSeq,
+      lastTimestamp: streakLast.ts,
+      effect: this.ringEffect
+    };
+  }
+};
+export {
+  InputChangeRecorder
+};

package/dist/analysis/low-events/input-paste-observer.mjs

@@ -0,0 +1,91 @@
+// src/low-events/input-paste-observer.ts
+var InputPasteObserver = class {
+  constructor(inputs, logger, changed, reserveCaptureSeq) {
+    this.inputs = inputs;
+    this.logger = logger;
+    this.changed = changed;
+    this.reserveCaptureSeq = reserveCaptureSeq;
+    for (const input of inputs) {
+      input.addEventListener("paste", this.onPaste, true);
+      input.addEventListener("beforeinput", this.onBeforeInput, true);
+    }
+  }
+  before = null;
+  timestamp = 0;
+  captureSeq;
+  pasteEvent;
+  timer = null;
+  onPaste = (event) => this.begin(event);
+  onBeforeInput = (event) => {
+    if (event.inputType === "insertFromPaste") this.begin(event);
+    else this.flush();
+  };
+  /** An unrelated input event invalidates pending paste provenance before recording its change. */
+  handlesInput(event) {
+    if (!this.before) return false;
+    const inPasteDispatch = this.pasteEvent?.type === "paste" && (this.pasteEvent.eventPhase ?? 0) > 0;
+    if (event.inputType === "insertFromPaste" || inPasteDispatch) {
+      return true;
+    }
+    this.clear();
+    return false;
+  }
+  get pending() {
+    return this.before !== null;
+  }
+  begin(event) {
+    if (!event.isTrusted || this.before) return;
+    try {
+      this.before = this.inputs.map((input) => input.value);
+      this.pasteEvent = event;
+      this.timestamp = Date.now();
+      this.captureSeq = this.reserveCaptureSeq?.();
+      this.timer = setTimeout(() => this.flush(), 0);
+    } catch (error) {
+      this.logger.error("Failed to observe paste", error);
+      this.clear();
+    }
+  }
+  flush() {
+    const before = this.before;
+    if (!before) return;
+    const timestamp = this.timestamp;
+    const captureSeq = this.captureSeq;
+    this.clear();
+    try {
+      let inserted = 0;
+      let changed = false;
+      this.inputs.forEach((input, index) => {
+        const old = before[index];
+        const value = input.value;
+        if (old === value) return;
+        changed = true;
+        let start = 0;
+        while (start < old.length && start < value.length && old[start] === value[start]) start++;
+        let end = 0;
+        while (end < old.length - start && end < value.length - start && old[old.length - end - 1] === value[value.length - end - 1])
+          end++;
+        inserted += value.length - start - end;
+      });
+      if (changed) this.changed(timestamp, inserted, captureSeq);
+    } catch (error) {
+      this.logger.error("Failed to finish paste observation", error);
+    }
+  }
+  clear() {
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = null;
+    this.before = null;
+    this.pasteEvent = void 0;
+  }
+  destroy() {
+    this.flush();
+    for (const input of this.inputs) {
+      input.removeEventListener("paste", this.onPaste, true);
+      input.removeEventListener("beforeinput", this.onBeforeInput, true);
+    }
+  }
+};
+export {
+  InputPasteObserver
+};