@corbado/observe 1.7.2 → 1.9.0

package/dist/analysis/utils/operation-full-provide-identifier-with-cui.mjs

@@ -0,0 +1,46 @@
+// src/utils/operation-full-provide-identifier-with-cui.ts
+import { LowEventInputTracker } from "../low-events/input-tracker.mjs";
+import { OperationFull } from "./operation-full.mjs";
+import { acceptHandoffs } from "../handoff.mjs";
+var OperationFullProvideIdentifierWithCUI = class extends OperationFull {
+  lowEventTracker;
+  cui;
+  provideIdentifier;
+  constructor(tracker, config) {
+    super(tracker, "provide-identifier");
+    this.cui = {
+      trigger: (data, options) => {
+        this.trigger(data, options);
+      },
+      // getOptions only fetches assertion options; it is not a user interaction on its own.
+      getOptions: acceptHandoffs(
+        this.defineStep("cui-get-options", true)
+      ),
+      ceremony: acceptHandoffs(
+        this.defineStep("cui-ceremony")
+      ),
+      postResponse: acceptHandoffs(this.defineStep("cui-post-response"))
+    };
+    this.provideIdentifier = {
+      trigger: (data, options) => {
+        this.trigger(data, options);
+      },
+      clientValidation: this.defineStep("pi-client-validation"),
+      postResponse: this.defineStep("pi-post-response")
+    };
+    void this.subflowStart({ explicitSpecType: config?.explicitSpecType });
+    if (!config?.inputHtmlField) {
+      return;
+    }
+    this.lowEventTracker = this.createLowCollector(
+      () => new LowEventInputTracker(tracker.getLogger(), config.inputHtmlField, this.lowEventSink("input", "identifier"))
+    );
+    this.registerLowFlusher(() => this.lowEventTracker?.flushPending());
+  }
+  destroy() {
+    this.lowEventTracker?.destroy();
+  }
+};
+export {
+  OperationFullProvideIdentifierWithCUI
+};

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

@@ -0,0 +1,235 @@
+// src/utils/operation-full.ts
+import { reserveCaptureSeq } from "../low-events/capture-sequence.mjs";
+import { inferCeremonyInitiator } from "../low-events/ceremony-initiator.mjs";
+import { v7 as uuidv7 } from "uuid";
+import { normalizeError } from "./normalize-error.mjs";
+import { serializeRawError } from "./serialize-raw-error.mjs";
+var CEREMONY_LOW_EVENT_TAIL_MS = 1500;
+var OperationFull = class {
+  constructor(tracker, operationName) {
+    this.tracker = tracker;
+    this.operationName = operationName;
+  }
+  startReference;
+  captureSpecType;
+  captureSessionId;
+  lowFlushers = [];
+  lowPrefillCapturers = [];
+  lowEventSink(sourceKind, fieldRole) {
+    return {
+      reserveCaptureSeq,
+      enqueueLowEvent: (low) => this.tracker.enqueueLowEvent(
+        {
+          ...low,
+          captureSeq: low.captureSeq ?? reserveCaptureSeq(),
+          subflowStartEventId: this.startReference,
+          sourceKind,
+          fieldRole,
+          initiator: low.initiator ?? (fieldRole ? `input-${fieldRole}` : "unknown")
+        },
+        this.captureSessionId
+      ),
+      flushKeepalive: () => this.tracker.lowEventFlushKeepalive(),
+      passwordManagerDomScan: () => this.tracker.isPasswordManagerDomScanEnabled(),
+      registerInputs: (fields, flush) => this.tracker.getWindowObserver().registerInputs(
+        fields,
+        () => ({
+          subflowStartEventId: this.startReference,
+          fieldRole,
+          initiator: fieldRole ? `input-${fieldRole}` : "unknown",
+          sessionId: this.captureSessionId
+        }),
+        flush
+      ),
+      beginCeremony: (initiator) => this.tracker.getWindowObserver().beginCeremony({
+        subflowStartEventId: this.startReference,
+        initiator: initiator ?? "unknown",
+        sessionId: this.captureSessionId
+      })
+    };
+  }
+  createLowCollector(create) {
+    try {
+      const collector = create();
+      this.lowPrefillCapturers.push((newCapture) => collector.capturePrefill(newCapture));
+      return collector;
+    } catch (error) {
+      this.tracker.getLogger().error("Failed to attach low-event collector", error);
+      return void 0;
+    }
+  }
+  registerLowFlusher(flush) {
+    this.lowFlushers.push(flush);
+  }
+  captureOptions(options, reference = this.startReference, sessionId = this.captureSessionId, initiator) {
+    if (!reference && !initiator) return options;
+    const context = {};
+    if (reference) {
+      context.subflowStartEventId = options?.subflowStartEventId ?? reference;
+      context.captureSessionId = options?.captureSessionId ?? sessionId;
+    }
+    if (initiator) context.initiator = options?.initiator ?? initiator;
+    return Object.defineProperties(
+      {},
+      {
+        ...Object.getOwnPropertyDescriptors(options ?? {}),
+        ...Object.getOwnPropertyDescriptors(context)
+      }
+    );
+  }
+  /** Anchor (subflowStartEventId) of the current start; undefined before the first start. */
+  get captureReference() {
+    return this.startReference;
+  }
+  /** Session the current start was tracked under. */
+  get captureSession() {
+    return this.captureSessionId;
+  }
+  /**
+   * Continue an attempt started elsewhere (e.g. on another page of the same session) without
+   * emitting a subflow_started: later steps and low events carry the given anchor and session.
+   */
+  adoptCapture(reference, sessionId, specType) {
+    this.startReference = reference;
+    this.captureSessionId = sessionId;
+    this.captureSpecType = specType;
+  }
+  /**
+   * Emits an additional subflow_started; construction already emits the initial start.
+   * `data` supports SubflowTrigger fields (`actor`, `explicitSpecType`, `ignoreAsInteraction`)
+   * plus free-form extras; see SubflowTrigger for programmatic interaction suppression.
+   */
+  subflowStart(data, options) {
+    try {
+      for (const flush of this.lowFlushers) {
+        try {
+          flush();
+        } catch (error) {
+          this.tracker.getLogger().error("Failed to flush previous low-event context", error);
+        }
+      }
+      this.captureSpecType = data?.explicitSpecType;
+      this.startReference = uuidv7();
+      this.captureSessionId = this.tracker.getSessionId();
+      this.tracker.trackSubflowStarted(this.operationName, data, this.captureOptions(options), this.startReference);
+      this.captureInputPrefills(true);
+    } catch (error) {
+      this.tracker.getLogger().error("Failed to start low-event capture context", error);
+    }
+  }
+  /**
+   * Capture values initialized by the application after constructing this operation, without
+   * dispatching DOM input events. Call immediately after initialization, before user editing.
+   * Each field/group emits at most one prefill per subflow start; values are never recorded.
+   */
+  capturePrefill() {
+    this.captureInputPrefills(false);
+  }
+  captureInputPrefills(newCapture) {
+    for (const capture of this.lowPrefillCapturers) {
+      try {
+        capture(newCapture);
+      } catch (error) {
+        this.tracker.getLogger().error("Failed to capture input prefill", error);
+      }
+    }
+  }
+  /**
+   * @deprecated `subflow_trigger` will be removed in the next major version.
+   */
+  trigger(data, options) {
+    void this.tracker.trackSubflowTrigger(this.operationName, data, this.captureOptions(options));
+  }
+  customStep(stepName) {
+    return this.defineStep(stepName);
+  }
+  subflowStepStarted(stepName, data, options, ignoreAsInteraction) {
+    this.captureSpecType = data?.explicitSpecType ?? this.captureSpecType;
+    void this.tracker.trackSubflowStepStarted(
+      this.operationName,
+      stepName,
+      data,
+      this.captureOptions(options),
+      ignoreAsInteraction
+    );
+  }
+  subflowStepFinished(stepName, data, options) {
+    if (!options?.subflowStartEventId || options.subflowStartEventId === this.startReference) {
+      this.captureSpecType = data?.explicitSpecType ?? this.captureSpecType;
+    }
+    void this.tracker.trackSubflowStepFinished(this.operationName, stepName, data, this.captureOptions(options));
+  }
+  subflowStepError(stepName, data, options) {
+    let payload = data;
+    try {
+      const rawError = this.tracker.getSdkConfig().rawErrors ? options?.rawError : void 0;
+      if (rawError !== void 0) payload = { ...data, rawError: serializeRawError(rawError, options?.rawErrorLimits) };
+    } catch {
+    }
+    void this.tracker.trackSubflowStepError(this.operationName, stepName, payload, this.captureOptions(options));
+  }
+  /**
+   * Decorate a (ceremony) step so window low-event collection follows its lifecycle: `start` arms
+   * the tracker, `finished`/`error`/`errorTyped` schedule disarming after
+   * {@link CEREMONY_LOW_EVENT_TAIL_MS}. A `start` during the tail (ceremony retry) keeps the
+   * tracker armed.
+   */
+  withWindowLowEvents(step, windowTracker) {
+    let ceremonyReference;
+    const settle = (options) => {
+      if (options?.subflowStartEventId && options.subflowStartEventId !== ceremonyReference) return;
+      windowTracker.scheduleDisarm(CEREMONY_LOW_EVENT_TAIL_MS);
+    };
+    const inner = step;
+    return {
+      ...step,
+      start: (data, options) => {
+        ceremonyReference = options?.subflowStartEventId ?? this.startReference;
+        const spec = data?.explicitSpecType ?? this.captureSpecType;
+        const initiator = options?.initiator ?? inferCeremonyInitiator(this.operationName, spec);
+        windowTracker.arm(initiator, spec === "passkey-cui");
+        inner.start(data, initiator ? { ...options, initiator } : options);
+      },
+      finished: (data, options) => {
+        inner.finished(data, options);
+        settle(options);
+      },
+      error: (error, options) => {
+        inner.error(error, options);
+        settle(options);
+      },
+      errorTyped: (error, options) => {
+        inner.errorTyped?.(error, options);
+        settle(options);
+      }
+    };
+  }
+  defineStep(stepName, ignoreAsInteractionOnStart) {
+    let stepReference;
+    let stepSessionId;
+    let stepInitiator;
+    const stepOptions = (options) => this.captureOptions(options, stepReference, stepSessionId, stepInitiator);
+    const step = {
+      start: (data, options) => {
+        stepReference = this.startReference;
+        stepSessionId = this.captureSessionId;
+        stepInitiator = options?.initiator;
+        this.subflowStepStarted(stepName, data, stepOptions(options), ignoreAsInteractionOnStart);
+      },
+      finished: (data, options) => {
+        this.subflowStepFinished(stepName, data, stepOptions(options));
+      },
+      error: (error, options) => {
+        this.subflowStepError(stepName, { error: normalizeError(error) }, stepOptions(options));
+      },
+      errorTyped: (error, options) => {
+        this.subflowStepError(stepName, error, stepOptions(options));
+      }
+    };
+    return step;
+  }
+};
+export {
+  CEREMONY_LOW_EVENT_TAIL_MS,
+  OperationFull
+};

package/dist/analysis/utils/passkey-deletion-operation-full.mjs

@@ -0,0 +1,17 @@
+// src/utils/passkey-deletion-operation-full.ts
+import { OperationFull } from "./operation-full.mjs";
+var PasskeyDeletionOperationFull = class extends OperationFull {
+  /** Optional confirmation dialog: start when it opens, finish when the user confirms. */
+  userConfirmation;
+  /** The deletion request: finish only when the passkey was actually deleted. */
+  deletion;
+  constructor(tracker, _config = {}) {
+    super(tracker, "passkey-deletion");
+    this.userConfirmation = this.defineStep("user-confirmation");
+    this.deletion = this.defineStep("deletion");
+    void this.subflowStart({});
+  }
+};
+export {
+  PasskeyDeletionOperationFull
+};

package/dist/analysis/utils/passkey-enrollment-operation-full.mjs

@@ -0,0 +1,35 @@
+// src/utils/passkey-enrollment-operation-full.ts
+import { LowEventWindowTracker } from "../low-events/window-tracker.mjs";
+import { OperationFull } from "./operation-full.mjs";
+import { acceptHandoffs } from "../handoff.mjs";
+var PasskeyEnrollmentOperationFull = class extends OperationFull {
+  getOptions;
+  ceremony;
+  postResponse;
+  lowEventTracker;
+  constructor(tracker, config) {
+    super(tracker, "passkey-enrollment");
+    this.lowEventTracker = new LowEventWindowTracker(tracker.getLogger(), this.lowEventSink("ceremony"));
+    this.registerLowFlusher(() => this.lowEventTracker.disarm());
+    this.getOptions = acceptHandoffs(
+      this.defineStep("get-options")
+    );
+    this.ceremony = acceptHandoffs(
+      this.withWindowLowEvents(
+        this.defineStep("ceremony"),
+        this.lowEventTracker
+      )
+    );
+    this.postResponse = acceptHandoffs(this.defineStep("post-response"));
+    void this.subflowStart({
+      explicitSpecType: config?.explicitSpecType,
+      ...config?.ignoreAsInteraction ? { ignoreAsInteraction: true } : {}
+    });
+  }
+  destroy() {
+    this.lowEventTracker.destroy();
+  }
+};
+export {
+  PasskeyEnrollmentOperationFull
+};

package/dist/analysis/utils/passkey-login-operation-full.mjs

@@ -0,0 +1,39 @@
+// src/utils/passkey-login-operation-full.ts
+import { LowEventWindowTracker } from "../low-events/window-tracker.mjs";
+import { OperationFull } from "./operation-full.mjs";
+import { acceptHandoffs } from "../handoff.mjs";
+var PasskeyLoginOperationFull = class extends OperationFull {
+  getOptions;
+  ceremony;
+  postResponse;
+  lowEventTracker;
+  constructor(tracker, config) {
+    super(tracker, "passkey-login");
+    this.lowEventTracker = new LowEventWindowTracker(tracker.getLogger(), this.lowEventSink("ceremony"));
+    this.registerLowFlusher(() => this.lowEventTracker.disarm());
+    this.getOptions = acceptHandoffs(
+      this.defineStep("get-options")
+    );
+    this.ceremony = acceptHandoffs(
+      this.withWindowLowEvents(
+        this.defineStep("ceremony"),
+        this.lowEventTracker
+      )
+    );
+    this.postResponse = acceptHandoffs(this.defineStep("post-response"));
+    void this.subflowStart({ explicitSpecType: config?.explicitSpecType });
+  }
+  /**
+   * @deprecated `subflow_trigger` is not supported for passkey-login and will be removed in the
+   * next major version.
+   */
+  trigger(data, options) {
+    super.trigger(data, options);
+  }
+  destroy() {
+    this.lowEventTracker.destroy();
+  }
+};
+export {
+  PasskeyLoginOperationFull
+};

package/dist/analysis/utils/password-enrollment-operation-full.mjs

@@ -0,0 +1,27 @@
+// src/utils/password-enrollment-operation-full.ts
+import { LowEventInputTracker } from "../low-events/input-tracker.mjs";
+import { OperationFull } from "./operation-full.mjs";
+var PasswordEnrollmentOperationFull = class extends OperationFull {
+  clientValidation;
+  postResponse;
+  lowEventTracker;
+  constructor(tracker, config) {
+    super(tracker, "password-enrollment");
+    this.clientValidation = this.defineStep("client-validation");
+    this.postResponse = this.defineStep("post-response");
+    void this.subflowStart({ explicitSpecType: config?.explicitSpecType });
+    if (!config?.inputHtmlField) {
+      return;
+    }
+    this.lowEventTracker = this.createLowCollector(
+      () => new LowEventInputTracker(tracker.getLogger(), config.inputHtmlField, this.lowEventSink("input", "password"))
+    );
+    this.registerLowFlusher(() => this.lowEventTracker?.flushPending());
+  }
+  destroy() {
+    this.lowEventTracker?.destroy();
+  }
+};
+export {
+  PasswordEnrollmentOperationFull
+};

package/dist/analysis/utils/password-login-operation-full.mjs

@@ -0,0 +1,65 @@
+// src/utils/password-login-operation-full.ts
+import { LowEventInputTracker } from "../low-events/input-tracker.mjs";
+import { OperationFull } from "./operation-full.mjs";
+import { acceptHandoffs } from "../handoff.mjs";
+var PasswordLoginOperationFull = class extends OperationFull {
+  clientValidation;
+  postResponse;
+  /**
+   * Conditional-UI passkey ceremony that runs while the password form is mounted. The three steps
+   * are emitted under the same `password-login` subflow so a CUI passkey login on this screen is
+   * attributed to password-login rather than a separate subflow.
+   */
+  cui;
+  lowEventTracker;
+  identifierLowEventTracker;
+  constructor(tracker, config) {
+    super(tracker, "password-login");
+    this.clientValidation = this.defineStep("client-validation");
+    this.postResponse = this.defineStep("post-response");
+    this.cui = {
+      // getOptions only fetches assertion options; it is not a user interaction on its own.
+      getOptions: acceptHandoffs(
+        this.defineStep("cui-get-options", true)
+      ),
+      ceremony: acceptHandoffs(
+        this.defineStep(
+          "cui-ceremony"
+        )
+      ),
+      postResponse: this.defineStep("cui-post-response")
+    };
+    void this.subflowStart({ explicitSpecType: config?.explicitSpecType });
+    if (config?.identifierInputHtmlField) {
+      this.identifierLowEventTracker = this.createLowCollector(
+        () => new LowEventInputTracker(
+          tracker.getLogger(),
+          config.identifierInputHtmlField,
+          this.lowEventSink("input", "identifier")
+        )
+      );
+      this.registerLowFlusher(() => this.identifierLowEventTracker?.flushPending());
+    }
+    if (!config?.inputHtmlField) {
+      return;
+    }
+    this.lowEventTracker = this.createLowCollector(
+      () => new LowEventInputTracker(tracker.getLogger(), config.inputHtmlField, this.lowEventSink("input", "password"))
+    );
+    this.registerLowFlusher(() => this.lowEventTracker?.flushPending());
+  }
+  /**
+   * @deprecated `subflow_trigger` is not supported for password-login and will be removed in the
+   * next major version.
+   */
+  trigger(data, options) {
+    super.trigger(data, options);
+  }
+  destroy() {
+    this.lowEventTracker?.destroy();
+    this.identifierLowEventTracker?.destroy();
+  }
+};
+export {
+  PasswordLoginOperationFull
+};

package/dist/analysis/utils/password-manager-sampler.mjs

@@ -0,0 +1,170 @@
+// src/utils/password-manager-sampler.ts
+import { listenWindow, readDocumentComplete } from "../readers/page.mjs";
+import {
+  readPasswordManagerExtensions
+} from "../readers/password-manager-extensions.mjs";
+var LOAD_RESAMPLE_DELAY_MS = 3e3;
+var INPUT_FOCUS_SAMPLE_DELAY_MS = 500;
+var MAX_FOCUS_SAMPLES = 6;
+var IDLE_TIMEOUT_MS = 1e3;
+var PasswordManagerSampler = class {
+  constructor(logger, isEnabled, windowObserver) {
+    this.logger = logger;
+    this.isEnabled = isEnabled;
+    if (typeof window === "undefined" || typeof document === "undefined") return;
+    this.sample();
+    if (readDocumentComplete({
+      key: "page:lifecycle.ready-state",
+      title: "Page load state",
+      accessNote: "document.readyState",
+      group: "Page lifecycle",
+      origin: "observe-external",
+      fields: [
+        {
+          path: "readyState",
+          label: "Whether the page has finished loading",
+          exposure: "enum",
+          transform: { values: ["complete", "other"] }
+        }
+      ]
+    })) {
+      this.sampleAfter(LOAD_RESAMPLE_DELAY_MS);
+    } else {
+      const onLoad = () => {
+        this.sampleWhenIdle();
+        this.sampleAfter(LOAD_RESAMPLE_DELAY_MS);
+      };
+      this.removers.push(
+        listenWindow(
+          {
+            key: "page:lifecycle.load",
+            title: "Page load",
+            accessNote: "load event on window",
+            group: "Page lifecycle",
+            origin: "observe-external",
+            fields: [
+              {
+                path: "event.load",
+                label: "Page finished loading",
+                exposure: "presence",
+                transform: { note: "schedules a password manager sample" }
+              }
+            ]
+          },
+          "load",
+          onLoad,
+          { once: true }
+        )
+      );
+    }
+    const removeFocus = windowObserver.onInputFocus((field) => {
+      if (!this.isEnabled() || this.sampledFields.has(field)) return;
+      this.sampledFields.add(field);
+      if (++this.focusSamples >= MAX_FOCUS_SAMPLES) removeFocus();
+      this.sampleAfter(INPUT_FOCUS_SAMPLE_DELAY_MS);
+    });
+    this.removers.push(removeFocus);
+  }
+  detected = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Set();
+  idleCallbacks = /* @__PURE__ */ new Set();
+  /** Registered fields whose first focus already scheduled a sample (weak, so removed forms are not retained). */
+  sampledFields = /* @__PURE__ */ new WeakSet();
+  focusSamples = 0;
+  removers = [];
+  destroyed = false;
+  /** Per session, how many managers the last reported set held; the set only grows, so a count suffices. */
+  reportedCounts = /* @__PURE__ */ new Map();
+  /** Managers detected on this page so far, in detection order. */
+  getDetected() {
+    return [...this.detected.values()];
+  }
+  /**
+   * The full set of detected manager names when it grew since the last report for `sessionId`, otherwise
+   * undefined. Each session's first event after a detection carries the set (also after `resetSession()`),
+   * later events only when a sample added a manager. Signed-in upgrades are not reported, so they never
+   * count as growth. A lost event that carried the set is not repaired by later events of the same page.
+   */
+  takeReport(sessionId) {
+    if (!this.isEnabled() || this.detected.size <= (this.reportedCounts.get(sessionId) ?? 0)) return void 0;
+    this.reportedCounts.set(sessionId, this.detected.size);
+    return this.getDetected().map(({ name }) => ({ name }));
+  }
+  destroy() {
+    this.destroyed = true;
+    for (const remove of this.removers) remove();
+    for (const timer of this.timers) clearTimeout(timer);
+    this.timers.clear();
+    for (const handle of this.idleCallbacks) cancelIdleCallback(handle);
+    this.idleCallbacks.clear();
+  }
+  sampleAfter(delayMs) {
+    const timer = setTimeout(() => {
+      this.timers.delete(timer);
+      this.sampleWhenIdle();
+    }, delayMs);
+    this.timers.add(timer);
+  }
+  sampleWhenIdle() {
+    if (typeof requestIdleCallback !== "function") {
+      this.sample();
+      return;
+    }
+    const handle = requestIdleCallback(
+      () => {
+        this.idleCallbacks.delete(handle);
+        this.sample();
+      },
+      { timeout: IDLE_TIMEOUT_MS }
+    );
+    this.idleCallbacks.add(handle);
+  }
+  sample() {
+    if (this.destroyed || !this.isEnabled()) return;
+    try {
+      const found = readPasswordManagerExtensions({
+        key: "browser-api:password-managers.extensions",
+        title: "Installed password manager extensions",
+        accessNote: "globals and DOM elements that known password manager extensions inject",
+        group: "Password manager detection",
+        origin: "observe-external",
+        fields: [
+          {
+            path: "result[].name",
+            label: "Names of known password managers found",
+            exposure: "enum",
+            transform: {
+              values: [
+                "1password",
+                "bitwarden",
+                "dashlane",
+                "kaspersky",
+                "keeper",
+                "lastpass",
+                "nordpass",
+                "protonpass"
+              ]
+            }
+          },
+          // Read to merge samples, never reported (takeReport keeps only the name).
+          { path: "result[].signedIn", label: "Whether the password manager is signed in", exposure: "none" }
+        ],
+        dataConfig: "pmd"
+      });
+      for (const extension of found) {
+        const known = this.detected.get(extension.name);
+        if (!known || extension.signedIn && !known.signedIn) {
+          this.detected.set(extension.name, extension);
+        }
+      }
+    } catch (error) {
+      this.logger.error("Failed to detect password manager extensions", error);
+    }
+  }
+};
+export {
+  INPUT_FOCUS_SAMPLE_DELAY_MS,
+  LOAD_RESAMPLE_DELAY_MS,
+  MAX_FOCUS_SAMPLES,
+  PasswordManagerSampler
+};

package/dist/analysis/utils/provide-data-operation-full.mjs

@@ -0,0 +1,28 @@
+// src/utils/provide-data-operation-full.ts
+import { LowEventInputTracker } from "../low-events/input-tracker.mjs";
+import { OperationFull } from "./operation-full.mjs";
+var ProvideDataOperationFull = class extends OperationFull {
+  clientValidation;
+  postResponse;
+  lowEventTracker;
+  constructor(tracker, config = {}) {
+    super(tracker, "provide-data");
+    this.clientValidation = this.defineStep("client-validation");
+    this.postResponse = this.defineStep("post-response");
+    const { inputHtmlField, ...startData } = config;
+    void this.subflowStart(startData);
+    if (!inputHtmlField) {
+      return;
+    }
+    this.lowEventTracker = this.createLowCollector(
+      () => new LowEventInputTracker(tracker.getLogger(), inputHtmlField, this.lowEventSink("input", "data"))
+    );
+    this.registerLowFlusher(() => this.lowEventTracker?.flushPending());
+  }
+  destroy() {
+    this.lowEventTracker?.destroy();
+  }
+};
+export {
+  ProvideDataOperationFull
+};