@corbado/observe 1.7.2 → 1.9.0

package/dist/analysis/transports/fetch.mjs

@@ -0,0 +1,150 @@
+// src/transports/fetch.ts
+import { parseReliabilityConfig } from "../config.mjs";
+import { beaconSender, sendFetch } from "../readers/network.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 sendFetch(
+          {
+            key: "network:observe.events",
+            title: "Sending events to Corbado Observe",
+            accessNote: "fetch (keepalive) to the Observe ingestion API",
+            group: "Event delivery",
+            origin: "observe-internal",
+            fields: [
+              { path: "response.status", label: "Response code", exposure: "raw" },
+              { path: "response.header.retry-after", label: "Retry delay requested by the server", exposure: "raw" },
+              {
+                path: "response.header.x-corbado-observe-accepted",
+                label: "Whether Observe accepted the events",
+                exposure: "enum",
+                transform: { values: ["1", "other"] }
+              },
+              {
+                path: "response.body",
+                label: "Observe settings in the response",
+                exposure: "raw",
+                transform: { note: "SDK reliability config (HTTP 200 only)" }
+              }
+            ]
+          },
+          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`);
+      const send = beaconSender({
+        key: "network:observe.events-beacon",
+        title: "Sending events to Corbado Observe when the page closes",
+        accessNote: "navigator.sendBeacon to the Observe ingestion API",
+        group: "Event delivery",
+        origin: "observe-internal",
+        fields: [
+          {
+            path: "result",
+            label: "Whether the browser accepted the data for sending",
+            exposure: "enum",
+            transform: { values: [true, false], note: "whether the browser queued the beacon" }
+          }
+        ]
+      });
+      if (!send) {
+        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 send(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,162 @@
+// 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";
+import { listenWindow } from "../readers/page.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();
+  removePageHide;
+  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") {
+      this.removePageHide = listenWindow(
+        {
+          key: "page:lifecycle.pagehide",
+          title: "Leaving the page",
+          accessNote: "pagehide event on window",
+          group: "Page lifecycle",
+          origin: "observe-external",
+          fields: [
+            {
+              path: "event.pagehide",
+              label: "Leaving the page",
+              exposure: "presence",
+              transform: { note: "flushes a detached email-link continuation on unload" }
+            }
+          ]
+        },
+        "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") this.removePageHide?.();
+  }
+  /** 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,38 @@
+// 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());
+  }
+  setInputFields(fields) {
+    this.lowEventTracker?.setFields(fields);
+  }
+  destroy() {
+    this.lowEventTracker?.destroy();
+  }
+};
+export {
+  EmailOtpOperationFull
+};

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

@@ -0,0 +1,80 @@
+// src/utils/form-operation-full.ts
+import { FormInputBinding } from "../low-events/form-input-binding.mjs";
+import { OperationFull } from "./operation-full.mjs";
+var FORM_FIELDS_MAX_COUNT = 50;
+var FORM_STARTED_AT_MAX_AGE_MS = 6e4;
+var FORM_FIELD_NAME_MAX_LENGTH = 40;
+var FORM_FIELD_NAME_PATTERN = /^[A-Za-z0-9._-]+$/;
+var FormOperationFull = class extends OperationFull {
+  /** The application accepts the submitted form. */
+  submit;
+  /** The user leaves the form forward without submitting it. */
+  skip;
+  inputBinding;
+  constructor(tracker, config) {
+    super(tracker, "form");
+    this.submit = this.defineStep("submit");
+    this.skip = this.defineStep("skip");
+    void this.subflowStart(formStartData(tracker, config), formStartOptions(tracker, config));
+    this.inputBinding = this.createLowCollector(
+      () => new FormInputBinding(tracker.getLogger(), () => this.lowEventSink("input", "data"))
+    );
+    this.registerLowFlusher(() => this.inputBinding?.flushPending());
+    if (config?.inputHtmlFields?.length) this.setInputFields(config.inputHtmlFields);
+  }
+  setInputFields(fields) {
+    this.inputBinding?.setFields(fields);
+  }
+  destroy() {
+    this.inputBinding?.destroy();
+  }
+};
+function formStartOptions(tracker, config) {
+  const startedAt = config?.startedAt;
+  if (startedAt === void 0) return void 0;
+  const now = Date.now();
+  if (typeof startedAt !== "number" || !Number.isFinite(startedAt) || startedAt > now || now - startedAt > FORM_STARTED_AT_MAX_AGE_MS) {
+    warn(tracker, "Form: implausible startedAt ignored; using the current time");
+    return void 0;
+  }
+  return { explicitTimestamp: startedAt };
+}
+function formStartData(tracker, config) {
+  const data = {};
+  const name = config?.name;
+  if (typeof name === "string" && name.trim() !== "") {
+    data.name = name;
+  } else {
+    warn(tracker, "Form: missing name; the form will not be counted");
+  }
+  const fields = config?.fields;
+  if (fields === void 0) {
+    return data;
+  }
+  if (!Array.isArray(fields)) {
+    warn(tracker, "Form: fields must be an array of field names; omitted from telemetry");
+    return data;
+  }
+  const valid = fields.filter(
+    (field) => typeof field === "string" && field.length <= FORM_FIELD_NAME_MAX_LENGTH && FORM_FIELD_NAME_PATTERN.test(field)
+  );
+  if (valid.length < fields.length) {
+    warn(tracker, "Form: unsupported field names omitted from telemetry");
+  }
+  if (valid.length > FORM_FIELDS_MAX_COUNT) {
+    warn(tracker, `Form: more than ${FORM_FIELDS_MAX_COUNT} field names; the rest is omitted from telemetry`);
+  }
+  if (valid.length > 0) {
+    data.fields = valid.slice(0, FORM_FIELDS_MAX_COUNT);
+  }
+  return data;
+}
+function warn(tracker, message) {
+  try {
+    tracker.getLogger().warn(message);
+  } catch {
+  }
+}
+export {
+  FormOperationFull
+};

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

@@ -0,0 +1,38 @@
+// src/utils/key-operation-full.ts
+import { OperationFull } from "./operation-full.mjs";
+function specType(tracker, config) {
+  if (config.explicitSpecType === void 0) return void 0;
+  try {
+    tracker.getLogger().warn("Unsupported key operation spec type; omitting it");
+  } catch {
+  }
+  return void 0;
+}
+var KeySigningOperationFull = class extends OperationFull {
+  /** Resolve an eligible key and prepare the input for an actual signing attempt. */
+  prepare;
+  /** Sign and assemble the usable signed artifact. Does not include submitting it. */
+  sign;
+  constructor(tracker, config = {}) {
+    super(tracker, "key-signing");
+    this.prepare = this.defineStep("prepare");
+    this.sign = this.defineStep("sign");
+    void this.subflowStart({ actor: "system", explicitSpecType: specType(tracker, config) });
+  }
+};
+var KeyRegistrationOperationFull = class extends OperationFull {
+  /** Build the request that will establish the key's authority. */
+  prepare;
+  /** Submit and await acceptance: finish only when the key is authorized and usable. */
+  postResponse;
+  constructor(tracker, config = {}) {
+    super(tracker, "key-registration");
+    this.prepare = this.defineStep("prepare");
+    this.postResponse = this.defineStep("post-response");
+    void this.subflowStart({ actor: "system", explicitSpecType: specType(tracker, config) });
+  }
+};
+export {
+  KeyRegistrationOperationFull,
+  KeySigningOperationFull
+};

package/dist/analysis/utils/normalize-error.mjs

@@ -0,0 +1,29 @@
+// src/utils/normalize-error.ts
+function normalizeError(error) {
+  if (error === void 0 || error === null) {
+    return void 0;
+  }
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message
+    };
+  }
+  if (typeof error === "string") {
+    return { message: error };
+  }
+  if (typeof error === "object") {
+    const obj = error;
+    if (typeof obj.message === "string" || typeof obj.code === "string") {
+      return {
+        name: typeof obj.name === "string" ? obj.name : void 0,
+        message: typeof obj.message === "string" ? obj.message : void 0,
+        code: typeof obj.code === "string" ? obj.code : void 0
+      };
+    }
+  }
+  return { message: String(error) };
+}
+export {
+  normalizeError
+};