@atsignal/js-core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1995 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  HookRegistry: () => HookRegistry,
+  InMemoryStorage: () => InMemoryStorage,
+  SignalClient: () => SignalClient,
+  createFetchTransport: () => createFetchTransport
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var EVENT_TIME_KEY = "@time";
+var EVENT_INSERT_ID_KEY = "@insertid";
+var EVENT_DEVICE_ID_KEY = "@deviceid";
+var EVENT_USER_ID_KEY = "@userid";
+var EVENT_TYPE_KEY = "@event";
+var EVENT_VERSION_KEY = "@version";
+
+// src/storage.ts
+var InMemoryStorage = class {
+  constructor() {
+    this._map = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    if (!this._map.has(key)) {
+      return null;
+    }
+    return this._map.get(key);
+  }
+  set(key, value) {
+    this._map.set(key, value);
+  }
+  remove(key) {
+    this._map.delete(key);
+  }
+};
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object";
+}
+function toResolvedTrackOptions(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const flush = value.flush;
+  const endpoint = value.endpoint;
+  const retries = value.retries;
+  const timeoutMs = value.timeoutMs;
+  if (flush !== "scheduled" && flush !== "immediate" || typeof endpoint !== "string") {
+    return null;
+  }
+  if (typeof retries !== "number" || !Number.isFinite(retries) || retries < 0) {
+    return null;
+  }
+  const normalizedRetries = Math.floor(retries);
+  if (!Number.isFinite(normalizedRetries)) {
+    return null;
+  }
+  const options = {
+    flush,
+    endpoint,
+    retries: normalizedRetries
+  };
+  if (typeof timeoutMs === "number" && Number.isFinite(timeoutMs)) {
+    options.timeoutMs = timeoutMs;
+  }
+  return options;
+}
+function toPersistedQueueEntry(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const event = value.event;
+  const options = value.options;
+  const attempts = value.attempts;
+  const id = value.id;
+  const resolvedOptions = toResolvedTrackOptions(options);
+  if (!isRecord(event) || !resolvedOptions || typeof attempts !== "number") {
+    return null;
+  }
+  const normalizedId = typeof id === "string" && id.length > 0 ? id : typeof event[EVENT_INSERT_ID_KEY] === "string" && event[EVENT_INSERT_ID_KEY].length > 0 ? event[EVENT_INSERT_ID_KEY] : null;
+  if (!normalizedId) {
+    return null;
+  }
+  return {
+    id: normalizedId,
+    deviceId: typeof value.deviceId === "string" ? value.deviceId : "",
+    event,
+    options: resolvedOptions,
+    attempts
+  };
+}
+function normalizePersistedQueueEntries(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => toPersistedQueueEntry(entry)).filter((entry) => Boolean(entry));
+}
+var SnapshotQueueStorage = class {
+  constructor(storage, storageKey) {
+    this._storage = storage;
+    this._storageKey = storageKey;
+  }
+  async load(limit) {
+    const normalized = await this._readAll();
+    if (!Number.isFinite(limit) || limit <= 0) {
+      return [];
+    }
+    return normalized.slice(-Math.floor(limit));
+  }
+  async upsert(entries) {
+    if (entries.length === 0) {
+      return;
+    }
+    const stored = await this._readAll();
+    const storedIndexById = /* @__PURE__ */ new Map();
+    for (const [index, entry] of stored.entries()) {
+      storedIndexById.set(entry.id, index);
+    }
+    for (const entry of entries) {
+      const existingIndex = storedIndexById.get(entry.id);
+      if (existingIndex !== void 0) {
+        stored[existingIndex] = entry;
+        continue;
+      }
+      storedIndexById.set(entry.id, stored.length);
+      stored.push(entry);
+    }
+    await this._storage.set(this._storageKey, stored);
+  }
+  async remove(ids) {
+    if (ids.length === 0) {
+      return;
+    }
+    const idSet = new Set(ids);
+    const stored = await this._readAll();
+    let changed = false;
+    const filtered = [];
+    for (const entry of stored) {
+      if (idSet.has(entry.id)) {
+        changed = true;
+        continue;
+      }
+      filtered.push(entry);
+    }
+    if (!changed) {
+      return;
+    }
+    await this._storage.set(this._storageKey, filtered);
+  }
+  async trim(maxEntries) {
+    if (!Number.isFinite(maxEntries) || maxEntries < 0) {
+      await this.clear();
+      return;
+    }
+    const max = Math.floor(maxEntries);
+    const stored = await this._readAll();
+    if (stored.length <= max) {
+      return;
+    }
+    await this._storage.set(this._storageKey, stored.slice(-max));
+  }
+  async clear() {
+    await this._storage.remove(this._storageKey);
+  }
+  async _readAll() {
+    const stored = await this._storage.get(this._storageKey);
+    return normalizePersistedQueueEntries(stored);
+  }
+};
+
+// src/timers.ts
+function resolveTimerApi() {
+  const maybeSetTimeout = globalThis.setTimeout;
+  const maybeClearTimeout = globalThis.clearTimeout;
+  if (typeof maybeSetTimeout !== "function" || typeof maybeClearTimeout !== "function") {
+    return null;
+  }
+  return {
+    setTimeout: maybeSetTimeout,
+    clearTimeout: maybeClearTimeout
+  };
+}
+function scheduleTask(callback, delayMs) {
+  const timers = resolveTimerApi();
+  if (!timers) {
+    return null;
+  }
+  const handle = timers.setTimeout(callback, delayMs);
+  return {
+    cancel: () => {
+      timers.clearTimeout(handle);
+    }
+  };
+}
+function createTimeoutController(timeoutMs, createTimeoutValue) {
+  if (typeof timeoutMs !== "number" || timeoutMs <= 0) {
+    return null;
+  }
+  const timers = resolveTimerApi();
+  if (!timers) {
+    return null;
+  }
+  let handle;
+  const timeout = new Promise((resolve) => {
+    handle = timers.setTimeout(() => resolve(createTimeoutValue()), timeoutMs);
+  });
+  return {
+    timeout,
+    clear() {
+      timers.clearTimeout(handle);
+    }
+  };
+}
+
+// src/transport.ts
+function resolveGlobalFetch() {
+  const candidate = globalThis.fetch;
+  if (typeof candidate !== "function") {
+    return null;
+  }
+  return candidate;
+}
+function encodeRequestBody(request) {
+  const parts = [
+    `${encodeURIComponent("apikey")}=${encodeURIComponent(request.apiKey)}`,
+    `${encodeURIComponent("txtime")}=${encodeURIComponent(String(request.txTime))}`
+  ];
+  const locationFromIpEnabled = request.locationFromIp;
+  if (!locationFromIpEnabled) {
+    parts.push(`${encodeURIComponent("ip")}=${encodeURIComponent("false")}`);
+  }
+  for (const group of request.eventGroups) {
+    const entries = group.events.map((event, index) => ({ event, index }));
+    entries.sort((left, right) => {
+      var _a, _b;
+      const timeDelta = Number((_a = left.event[EVENT_TIME_KEY]) != null ? _a : 0) - Number((_b = right.event[EVENT_TIME_KEY]) != null ? _b : 0);
+      return timeDelta !== 0 ? timeDelta : left.index - right.index;
+    });
+    parts.push(
+      `${encodeURIComponent(`@${group.deviceId}`)}=${encodeURIComponent(
+        entries.map(({ event }) => JSON.stringify(event)).join("\n")
+      )}`
+    );
+  }
+  return parts.join("&");
+}
+var FetchTransport = class {
+  constructor(options = {}) {
+    var _a, _b, _c;
+    const fetchImpl = (_a = options.fetch) != null ? _a : resolveGlobalFetch();
+    if (!fetchImpl) {
+      throw new Error("No fetch implementation found for FetchTransport");
+    }
+    this._fetch = fetchImpl;
+    this._keepalive = (_b = options.keepalive) != null ? _b : false;
+    this._headers = (_c = options.headers) != null ? _c : {};
+  }
+  async send(request) {
+    const timer = createTimeoutController(request.timeoutMs, () => ({
+      ok: false,
+      retryable: true,
+      status: 0,
+      error: new Error("Request timed out")
+    }));
+    const requestPromise = this._fetch(request.endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/x-www-form-urlencoded",
+        ...this._headers
+      },
+      body: encodeRequestBody(request),
+      keepalive: this._keepalive
+    }).then((response) => {
+      const status = response.status;
+      if (response.ok) {
+        return { ok: true, status };
+      }
+      return {
+        ok: false,
+        status,
+        retryable: status >= 500 || status === 429
+      };
+    }).catch((error) => {
+      return {
+        ok: false,
+        status: 0,
+        retryable: true,
+        error
+      };
+    });
+    if (!timer) {
+      return requestPromise;
+    }
+    const result = await Promise.race([requestPromise, timer.timeout]);
+    timer.clear();
+    return result;
+  }
+};
+function createFetchTransport(options = {}) {
+  return new FetchTransport(options);
+}
+
+// src/client-config.ts
+var DEFAULT_ENDPOINT = "https://api.example.com/track";
+var DEFAULT_FLUSH_INTERVAL_MS = 5e3;
+var DEFAULT_MAX_BATCH_SIZE = 20;
+var DEFAULT_MAX_QUEUE_SIZE = 1e3;
+var DEFAULT_PART_ID = "";
+var DEFAULT_RETRY_BASE_MS = 500;
+var DEFAULT_RETRY_MAX_MS = 3e4;
+var DEFAULT_RETRY_ATTEMPTS = 5;
+var DEFAULT_RETRY_JITTER = 0.2;
+var MISSING_QUEUE_STORAGE_ERROR = "Signal client requires storage.queue when persistQueue is true; set persistQueue to false for in-memory queueing.";
+var EMPTY_BLOCKED_PROPERTIES = Object.freeze([]);
+var NON_BLOCKABLE_EVENT_PROPERTIES = /* @__PURE__ */ new Set([
+  EVENT_TYPE_KEY,
+  EVENT_TIME_KEY,
+  EVENT_INSERT_ID_KEY,
+  EVENT_USER_ID_KEY,
+  EVENT_VERSION_KEY
+]);
+var IDENTITY_STORAGE_KEY = "signal.identity.v1";
+var QUEUE_STORAGE_KEY = "signal.queue.v1";
+var NOOP_QUEUE_STORAGE = {
+  load: () => [],
+  upsert: () => {
+  },
+  remove: () => {
+  },
+  trim: () => {
+  },
+  clear: () => {
+  }
+};
+function toInteger(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  const rounded = Math.floor(value);
+  return rounded > 0 ? rounded : fallback;
+}
+function resolvePartId(partId) {
+  if (typeof partId !== "string") {
+    return DEFAULT_PART_ID;
+  }
+  return partId;
+}
+function resolveVersion(version) {
+  if (typeof version !== "string") {
+    return void 0;
+  }
+  return version;
+}
+function resolveBlockedProperties(blockedProperties) {
+  if (!Array.isArray(blockedProperties) || blockedProperties.length === 0) {
+    return EMPTY_BLOCKED_PROPERTIES;
+  }
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const property of blockedProperties) {
+    if (typeof property !== "string" || property.length === 0 || seen.has(property) || NON_BLOCKABLE_EVENT_PROPERTIES.has(property)) {
+      continue;
+    }
+    seen.add(property);
+    normalized.push(property);
+  }
+  if (normalized.length === 0) {
+    return EMPTY_BLOCKED_PROPERTIES;
+  }
+  return Object.freeze(normalized);
+}
+function resolveLocationFromIp(locationFromIp) {
+  return locationFromIp !== false;
+}
+function resolveOptOut(optOut) {
+  return optOut === true;
+}
+function resolveInitialUserId(userId) {
+  if (typeof userId === "string" || userId === null) {
+    return userId;
+  }
+  return void 0;
+}
+function resolveInitialDeviceId(deviceId) {
+  if (typeof deviceId !== "string" || deviceId.length === 0) {
+    return void 0;
+  }
+  return deviceId;
+}
+function createIdentityStorage(storage) {
+  return storage != null ? storage : new InMemoryStorage();
+}
+function isQueueStorage(storage) {
+  if (!storage || typeof storage !== "object") {
+    return false;
+  }
+  const queueStorage = storage;
+  return typeof queueStorage.load === "function" && typeof queueStorage.upsert === "function" && typeof queueStorage.remove === "function" && typeof queueStorage.trim === "function" && typeof queueStorage.clear === "function";
+}
+function createQueueStorage(storage) {
+  if (storage == null) {
+    throw new Error(MISSING_QUEUE_STORAGE_ERROR);
+  }
+  if (isQueueStorage(storage)) {
+    return storage;
+  }
+  return new SnapshotQueueStorage(storage, QUEUE_STORAGE_KEY);
+}
+function normalizeConfig(apiKey, config) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  if (!apiKey) {
+    throw new Error("Signal client requires apiKey");
+  }
+  const persistQueue = (_a = config.persistQueue) != null ? _a : true;
+  const initialIdentityOverrides = {
+    userId: resolveInitialUserId(config.userId),
+    deviceId: resolveInitialDeviceId(config.deviceId)
+  };
+  return {
+    apiKey,
+    resolvedConfig: {
+      endpoint: (_b = config.endpoint) != null ? _b : DEFAULT_ENDPOINT,
+      flushIntervalMs: toInteger(config.flushIntervalMs, DEFAULT_FLUSH_INTERVAL_MS),
+      maxBatchSize: toInteger(config.maxBatchSize, DEFAULT_MAX_BATCH_SIZE),
+      maxQueueSize: toInteger(config.maxQueueSize, DEFAULT_MAX_QUEUE_SIZE),
+      retry: {
+        baseMs: toInteger((_c = config.retry) == null ? void 0 : _c.baseMs, DEFAULT_RETRY_BASE_MS),
+        maxMs: toInteger((_d = config.retry) == null ? void 0 : _d.maxMs, DEFAULT_RETRY_MAX_MS),
+        maxAttempts: toInteger((_e = config.retry) == null ? void 0 : _e.maxAttempts, DEFAULT_RETRY_ATTEMPTS),
+        jitter: typeof ((_f = config.retry) == null ? void 0 : _f.jitter) === "number" ? config.retry.jitter : DEFAULT_RETRY_JITTER
+      },
+      persistQueue,
+      locationFromIp: resolveLocationFromIp(config.locationFromIp),
+      optOut: resolveOptOut(config.optOut),
+      partId: resolvePartId(config.partId),
+      version: resolveVersion(config.version),
+      blockedProperties: resolveBlockedProperties(config.blockedProperties)
+    },
+    storage: {
+      identity: createIdentityStorage((_g = config.storage) == null ? void 0 : _g.identity),
+      queue: persistQueue ? createQueueStorage((_h = config.storage) == null ? void 0 : _h.queue) : NOOP_QUEUE_STORAGE
+    },
+    transport: (_i = config.transport) != null ? _i : createFetchTransport(),
+    plugins: (_j = config.plugins) != null ? _j : [],
+    initialIdentityOverrides
+  };
+}
+
+// src/client-mutation.ts
+function createDeferred() {
+  let resolvePromise = () => {
+  };
+  let rejectPromise = () => {
+  };
+  const deferred = {
+    promise: new Promise((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    }),
+    settled: false,
+    resolve(value) {
+      if (deferred.settled) {
+        return;
+      }
+      deferred.settled = true;
+      resolvePromise(value);
+    },
+    reject(error) {
+      if (deferred.settled) {
+        return;
+      }
+      deferred.settled = true;
+      rejectPromise(error);
+    }
+  };
+  return deferred;
+}
+function createTrackFamilyMutationTask(request) {
+  return {
+    kind: "track-family",
+    requests: [request]
+  };
+}
+function collectMergedMutationTask(queue) {
+  const first = queue.shift();
+  if (!first) {
+    return null;
+  }
+  let merged = first;
+  while (queue.length > 0) {
+    const next = queue[0];
+    if (!next) {
+      break;
+    }
+    const candidate = mergeMutationTask(merged, next);
+    if (!candidate) {
+      break;
+    }
+    merged = candidate;
+    queue.shift();
+  }
+  return merged;
+}
+function mergeMutationTask(left, right) {
+  if (left.kind !== "track-family" || right.kind !== "track-family") {
+    return null;
+  }
+  return {
+    kind: "track-family",
+    requests: [...left.requests, ...right.requests]
+  };
+}
+
+// src/client-queue.ts
+function haveCompatibleRequestOptions(left, right) {
+  return left.options.endpoint === right.options.endpoint && left.options.timeoutMs === right.options.timeoutMs;
+}
+function isTrackProperties(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function createQueueEntryId() {
+  const random = Math.random().toString(16).slice(2, 10);
+  const now = Date.now().toString(16);
+  return `q_${now}_${random}`;
+}
+function isQueueEntry(value) {
+  var _a, _b, _c, _d;
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const entry = value;
+  return typeof entry.id === "string" && typeof entry.deviceId === "string" && Boolean(entry.event) && Boolean(entry.options) && typeof entry.attempts === "number" && typeof ((_a = entry.event) == null ? void 0 : _a[EVENT_TYPE_KEY]) === "string" && typeof ((_b = entry.event) == null ? void 0 : _b[EVENT_INSERT_ID_KEY]) === "string" && typeof ((_c = entry.event) == null ? void 0 : _c[EVENT_TIME_KEY]) === "number" && typeof ((_d = entry.options) == null ? void 0 : _d.endpoint) === "string";
+}
+function cloneIdentity(identity) {
+  return {
+    userId: identity.userId,
+    deviceId: identity.deviceId
+  };
+}
+function collectCompatibleBatch(queue, maxEntries) {
+  const first = queue[0];
+  if (!first) {
+    return [];
+  }
+  const batch = [first];
+  const limit = Math.max(1, Math.floor(maxEntries));
+  for (let index = 1; index < queue.length && batch.length < limit; index += 1) {
+    const entry = queue[index];
+    if (!entry || !haveCompatibleRequestOptions(first, entry)) {
+      break;
+    }
+    batch.push(entry);
+  }
+  return batch;
+}
+function createTransportGroups(entries) {
+  const groupedEntries = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = groupedEntries.get(entry.deviceId);
+    if (existing) {
+      existing.push(entry.event);
+      continue;
+    }
+    groupedEntries.set(entry.deviceId, [entry.event]);
+  }
+  return [...groupedEntries.entries()].map(([deviceId, events]) => ({
+    deviceId,
+    events
+  }));
+}
+
+// src/hooks.ts
+function registerListener(listeners, listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+var HookRegistry = class {
+  constructor() {
+    this._onInit = /* @__PURE__ */ new Set();
+    this._onEventCreated = /* @__PURE__ */ new Set();
+    this._onBeforeEnqueue = /* @__PURE__ */ new Set();
+    this._onEventQueued = /* @__PURE__ */ new Set();
+    this._onBeforeFlush = /* @__PURE__ */ new Set();
+    this._onAfterFlush = /* @__PURE__ */ new Set();
+    this._onBeforeSend = /* @__PURE__ */ new Set();
+    this._onAfterSend = /* @__PURE__ */ new Set();
+    this._onIdentityChanged = /* @__PURE__ */ new Set();
+    this._onOptOutChanged = /* @__PURE__ */ new Set();
+    this._onError = /* @__PURE__ */ new Set();
+  }
+  onInit(listener) {
+    return registerListener(this._onInit, listener);
+  }
+  onEventCreated(listener) {
+    return registerListener(this._onEventCreated, listener);
+  }
+  onBeforeEnqueue(listener) {
+    return registerListener(this._onBeforeEnqueue, listener);
+  }
+  onEventQueued(listener) {
+    return registerListener(this._onEventQueued, listener);
+  }
+  onBeforeFlush(listener) {
+    return registerListener(this._onBeforeFlush, listener);
+  }
+  onAfterFlush(listener) {
+    return registerListener(this._onAfterFlush, listener);
+  }
+  onBeforeSend(listener) {
+    return registerListener(this._onBeforeSend, listener);
+  }
+  onAfterSend(listener) {
+    return registerListener(this._onAfterSend, listener);
+  }
+  onIdentityChanged(listener) {
+    return registerListener(this._onIdentityChanged, listener);
+  }
+  onOptOutChanged(listener) {
+    return registerListener(this._onOptOutChanged, listener);
+  }
+  onError(listener) {
+    this._onError.add(listener);
+    return () => {
+      this._onError.delete(listener);
+    };
+  }
+  async emitInit(context) {
+    await this._emitAsync(this._onInit, context);
+  }
+  async emitEventCreated(context) {
+    await this._emitAsync(this._onEventCreated, context);
+  }
+  async emitBeforeEnqueue(context) {
+    await this._emitAsync(this._onBeforeEnqueue, context);
+  }
+  async emitEventQueued(context) {
+    await this._emitAsync(this._onEventQueued, context);
+  }
+  async emitBeforeFlush(context) {
+    await this._emitAsync(this._onBeforeFlush, context);
+  }
+  async emitAfterFlush(context) {
+    await this._emitAsync(this._onAfterFlush, context);
+  }
+  async emitBeforeSend(context) {
+    await this._emitAsync(this._onBeforeSend, context);
+  }
+  async emitAfterSend(context) {
+    await this._emitAsync(this._onAfterSend, context);
+  }
+  async emitIdentityChanged(context) {
+    await this._emitAsync(this._onIdentityChanged, context);
+  }
+  async emitOptOutChanged(context) {
+    await this._emitAsync(this._onOptOutChanged, context);
+  }
+  emitError(context) {
+    for (const listener of this._onError) {
+      try {
+        listener(context);
+      } catch (e) {
+      }
+    }
+  }
+  async _emitAsync(listeners, context) {
+    for (const listener of listeners) {
+      await listener(context);
+    }
+  }
+};
+
+// src/insert-id.ts
+var COUNTER_MASK = 65535;
+var InsertIdGenerator = class {
+  constructor(partId = "") {
+    this._counter = 0;
+    this._partId = partId;
+  }
+  next() {
+    const counter = this._counter;
+    this._counter = counter + 1 & COUNTER_MASK;
+    return `${this._partId}${counter.toString(16)}`;
+  }
+};
+
+// src/plugin-runtime.ts
+var PluginRuntime = class {
+  constructor(options) {
+    this._plugins = [];
+    this._setupPluginNames = /* @__PURE__ */ new Set();
+    this._pendingPluginSetups = /* @__PURE__ */ new Map();
+    this._pluginUnsubscribes = /* @__PURE__ */ new Map();
+    var _a;
+    this._config = options.config;
+    this._hooks = options.hooks;
+    this._emitError = options.emitError;
+    for (const plugin of (_a = options.plugins) != null ? _a : []) {
+      this.register(plugin);
+    }
+  }
+  register(plugin) {
+    const duplicate = this._plugins.find((existing) => existing.name === plugin.name);
+    if (duplicate) {
+      throw new Error(`Plugin already registered: ${plugin.name}`);
+    }
+    this._plugins.push(plugin);
+    this._pluginUnsubscribes.set(plugin.name, /* @__PURE__ */ new Set());
+  }
+  list() {
+    return [...this._plugins];
+  }
+  async setup(plugin) {
+    if (!this._plugins.includes(plugin)) {
+      return;
+    }
+    if (this._setupPluginNames.has(plugin.name)) {
+      return;
+    }
+    const pendingSetup = this._pendingPluginSetups.get(plugin.name);
+    if (pendingSetup) {
+      await pendingSetup;
+      return;
+    }
+    const setup = plugin.setup;
+    if (!setup) {
+      this._setupPluginNames.add(plugin.name);
+      return;
+    }
+    const setupPromise = (async () => {
+      try {
+        await setup(this._createSetupContext(plugin.name));
+        if (!this._plugins.includes(plugin)) {
+          if (!plugin.teardown) {
+            return;
+          }
+          try {
+            await plugin.teardown();
+          } catch (error) {
+            this._emitError({ stage: "plugin:teardown", pluginName: plugin.name, error });
+          }
+          return;
+        }
+        this._setupPluginNames.add(plugin.name);
+      } catch (error) {
+        this._emitError({ stage: "plugin:setup", pluginName: plugin.name, error });
+      } finally {
+        this._pendingPluginSetups.delete(plugin.name);
+      }
+    })();
+    this._pendingPluginSetups.set(plugin.name, setupPromise);
+    await setupPromise;
+  }
+  async setupAll() {
+    for (const plugin of this.list()) {
+      await this.setup(plugin);
+    }
+  }
+  async remove(pluginName) {
+    const index = this._plugins.findIndex((plugin2) => plugin2.name === pluginName);
+    if (index < 0) {
+      return false;
+    }
+    const [plugin] = this._plugins.splice(index, 1);
+    if (!plugin) {
+      return false;
+    }
+    this._detachPluginListeners(plugin.name);
+    const pendingSetup = this._pendingPluginSetups.get(plugin.name);
+    if (pendingSetup) {
+      await pendingSetup;
+      return true;
+    }
+    const wasSetup = this._setupPluginNames.delete(plugin.name);
+    if (!plugin.teardown || !wasSetup) {
+      return true;
+    }
+    try {
+      await plugin.teardown();
+    } catch (error) {
+      this._emitError({ stage: "plugin:teardown", pluginName: plugin.name, error });
+    }
+    return true;
+  }
+  async flushAll() {
+    for (const plugin of this.list()) {
+      if (!plugin.flush) {
+        continue;
+      }
+      try {
+        await plugin.flush();
+      } catch (error) {
+        this._emitError({ stage: "plugin:flush", pluginName: plugin.name, error });
+      }
+    }
+  }
+  async teardownAll() {
+    for (const plugin of this.list()) {
+      if (!plugin.teardown) {
+        continue;
+      }
+      try {
+        await plugin.teardown();
+      } catch (error) {
+        this._emitError({ stage: "plugin:teardown", pluginName: plugin.name, error });
+      }
+    }
+  }
+  _createSetupContext(pluginName) {
+    return {
+      hooks: this._createScopedHooks(pluginName),
+      config: this._config
+    };
+  }
+  _createScopedHooks(pluginName) {
+    return {
+      onInit: (listener) => this._registerHook(pluginName, this._hooks.onInit.bind(this._hooks), listener),
+      onEventCreated: (listener) => this._registerHook(pluginName, this._hooks.onEventCreated.bind(this._hooks), listener),
+      onBeforeEnqueue: (listener) => this._registerHook(pluginName, this._hooks.onBeforeEnqueue.bind(this._hooks), listener),
+      onEventQueued: (listener) => this._registerHook(pluginName, this._hooks.onEventQueued.bind(this._hooks), listener),
+      onBeforeFlush: (listener) => this._registerHook(pluginName, this._hooks.onBeforeFlush.bind(this._hooks), listener),
+      onAfterFlush: (listener) => this._registerHook(pluginName, this._hooks.onAfterFlush.bind(this._hooks), listener),
+      onBeforeSend: (listener) => this._registerHook(pluginName, this._hooks.onBeforeSend.bind(this._hooks), listener),
+      onAfterSend: (listener) => this._registerHook(pluginName, this._hooks.onAfterSend.bind(this._hooks), listener),
+      onIdentityChanged: (listener) => this._registerHook(pluginName, this._hooks.onIdentityChanged.bind(this._hooks), listener),
+      onOptOutChanged: (listener) => this._registerHook(pluginName, this._hooks.onOptOutChanged.bind(this._hooks), listener),
+      onError: (listener) => this._registerErrorHook(pluginName, this._hooks.onError.bind(this._hooks), listener)
+    };
+  }
+  _registerHook(pluginName, register, listener) {
+    if (!this._plugins.some((plugin) => plugin.name === pluginName)) {
+      return () => {
+      };
+    }
+    const unsubscribe = register(listener);
+    return this._trackUnsubscribe(pluginName, unsubscribe);
+  }
+  _registerErrorHook(pluginName, register, listener) {
+    if (!this._plugins.some((plugin) => plugin.name === pluginName)) {
+      return () => {
+      };
+    }
+    const unsubscribe = register(listener);
+    return this._trackUnsubscribe(pluginName, unsubscribe);
+  }
+  _trackUnsubscribe(pluginName, unsubscribe) {
+    const pluginUnsubscribes = this._pluginUnsubscribes.get(pluginName);
+    if (!pluginUnsubscribes) {
+      unsubscribe();
+      return () => {
+      };
+    }
+    let active = true;
+    const trackedUnsubscribe = () => {
+      if (!active) {
+        return;
+      }
+      active = false;
+      pluginUnsubscribes.delete(trackedUnsubscribe);
+      unsubscribe();
+    };
+    pluginUnsubscribes.add(trackedUnsubscribe);
+    if (!this._plugins.some((plugin) => plugin.name === pluginName)) {
+      trackedUnsubscribe();
+    }
+    return trackedUnsubscribe;
+  }
+  _detachPluginListeners(pluginName) {
+    const pluginUnsubscribes = this._pluginUnsubscribes.get(pluginName);
+    if (!pluginUnsubscribes) {
+      return;
+    }
+    this._pluginUnsubscribes.delete(pluginName);
+    for (const unsubscribe of [...pluginUnsubscribes]) {
+      unsubscribe();
+    }
+  }
+};
+
+// src/uuid.ts
+function getCrypto() {
+  const maybeCrypto = globalThis.crypto;
+  if (!maybeCrypto || typeof maybeCrypto !== "object") {
+    return null;
+  }
+  return maybeCrypto;
+}
+function byteToHex(byte) {
+  return byte.toString(16).padStart(2, "0");
+}
+function getByte(bytes, index) {
+  var _a;
+  return (_a = bytes[index]) != null ? _a : 0;
+}
+function formatUuidV4(bytes) {
+  bytes[6] = getByte(bytes, 6) & 15 | 64;
+  bytes[8] = getByte(bytes, 8) & 63 | 128;
+  return [
+    byteToHex(getByte(bytes, 0)) + byteToHex(getByte(bytes, 1)) + byteToHex(getByte(bytes, 2)) + byteToHex(getByte(bytes, 3)),
+    byteToHex(getByte(bytes, 4)) + byteToHex(getByte(bytes, 5)),
+    byteToHex(getByte(bytes, 6)) + byteToHex(getByte(bytes, 7)),
+    byteToHex(getByte(bytes, 8)) + byteToHex(getByte(bytes, 9)),
+    byteToHex(getByte(bytes, 10)) + byteToHex(getByte(bytes, 11)) + byteToHex(getByte(bytes, 12)) + byteToHex(getByte(bytes, 13)) + byteToHex(getByte(bytes, 14)) + byteToHex(getByte(bytes, 15))
+  ].join("-");
+}
+function createMathRandomBytes() {
+  const bytes = new Uint8Array(16);
+  for (let index = 0; index < bytes.length; index += 1) {
+    bytes[index] = Math.floor(Math.random() * 256);
+  }
+  return bytes;
+}
+function createUuidV4() {
+  const crypto = getCrypto();
+  if (typeof (crypto == null ? void 0 : crypto.randomUUID) === "function") {
+    return crypto.randomUUID();
+  }
+  if (typeof (crypto == null ? void 0 : crypto.getRandomValues) === "function") {
+    return formatUuidV4(crypto.getRandomValues(new Uint8Array(16)));
+  }
+  return formatUuidV4(createMathRandomBytes());
+}
+
+// src/client.ts
+var SignalClient = class {
+  constructor() {
+    this._apiKey = "";
+    this._hooks = new HookRegistry();
+    this._blockedProperties = null;
+    this._identity = {
+      userId: null,
+      deviceId: ""
+    };
+    this._optOut = false;
+    this._queue = [];
+    this._ready = null;
+    this._state = "uninitialized";
+    this._initError = null;
+    this._queuedMutations = [];
+    this._drainingQueuedMutations = false;
+    this._flushTask = null;
+    this._mutationQueue = [];
+    this._mutationDrainPromise = null;
+    this._automaticFlushPending = false;
+    this._activeAutomaticFlushReason = null;
+    this._acceptEvents = true;
+    this._shutdownPromise = null;
+  }
+  hooks() {
+    return this._hooks;
+  }
+  async init(apiKey, options = {}) {
+    if (this._state === "initializing" || this._state === "ready") {
+      throw new Error("Signal client init() can only be called once per instance");
+    }
+    if (this._state === "shutdown") {
+      throw new Error("Signal client has been shut down; create a new client instance instead");
+    }
+    if (this._state === "failed") {
+      throw new Error(
+        "Signal client init() previously failed; create a new client instance to retry"
+      );
+    }
+    this._state = "initializing";
+    try {
+      const normalized = normalizeConfig(apiKey, this.resolveInitConfig(options));
+      this._applyNormalizedConfig(normalized);
+      this._ready = this._initialize(normalized.initialIdentityOverrides);
+      await this._ready;
+      await this._drainQueuedMutations();
+      if (!this._isShutdown()) {
+        this._state = "ready";
+      }
+      return this;
+    } catch (error) {
+      this._state = "failed";
+      this._initError = error;
+      this._rejectQueuedMutations(error);
+      this._emitError({ stage: "init", error });
+      throw error;
+    }
+  }
+  resolveInitConfig(options) {
+    return options;
+  }
+  async add(plugin) {
+    return this._queueOrRunMutation("mutation", async () => {
+      this._pluginRuntime.register(plugin);
+      const completion = createDeferred();
+      const task = {
+        kind: "plugin-add",
+        plugin,
+        completion
+      };
+      this._enqueueMutation(task);
+      await completion.promise;
+    });
+  }
+  async remove(pluginName) {
+    return this._queueOrRunMutationWithResult(async () => {
+      const completion = createDeferred();
+      const task = {
+        kind: "plugin-remove",
+        pluginName,
+        completion
+      };
+      this._enqueueMutation(task);
+      return completion.promise;
+    });
+  }
+  listPlugins() {
+    return this._requireReadyRuntime().list();
+  }
+  async loggedIn(userId) {
+    return this._queueOrRunMutation("mutation", async () => {
+      const completion = createDeferred();
+      const task = {
+        kind: "identity",
+        action: "logged-in",
+        userId,
+        completion
+      };
+      this._enqueueMutation(task);
+      await completion.promise;
+    });
+  }
+  async loggedOut() {
+    return this._queueOrRunMutation("mutation", async () => {
+      const completion = createDeferred();
+      const task = {
+        kind: "identity",
+        action: "logged-out",
+        completion
+      };
+      this._enqueueMutation(task);
+      await completion.promise;
+    });
+  }
+  async reset(deviceId) {
+    return this._queueOrRunMutation("mutation", async () => {
+      const completion = createDeferred();
+      const task = {
+        kind: "identity",
+        action: "reset",
+        deviceId,
+        completion
+      };
+      this._enqueueMutation(task);
+      await completion.promise;
+    });
+  }
+  userId() {
+    this._requireReadyRuntime();
+    return this._identity.userId;
+  }
+  optOut() {
+    this._requireReadyRuntime();
+    return this._optOut;
+  }
+  async setOptOut(optOut) {
+    return this._queueOrRunMutation("mutation", async () => {
+      const completion = createDeferred();
+      const task = {
+        kind: "opt-out",
+        optOut,
+        completion
+      };
+      this._enqueueMutation(task);
+      await completion.promise;
+    });
+  }
+  async track(event, properties = {}, options = {}) {
+    return this._queueOrRunMutation("mutation", async () => {
+      if (!this._acceptEvents) {
+        return;
+      }
+      const completion = createDeferred();
+      const request = {
+        event,
+        properties,
+        options,
+        waitForImmediateFlush: options.flush === "immediate",
+        completion
+      };
+      this._enqueueMutation(createTrackFamilyMutationTask(request));
+      await completion.promise;
+    });
+  }
+  async trackNow(event, properties = {}, options = {}) {
+    await this.track(event, properties, { ...options, flush: "immediate" });
+  }
+  async flush(reason = "manual") {
+    return this._queueOrRunMutation("mutation", async () => {
+      const completion = createDeferred();
+      const task = {
+        kind: "flush",
+        reason,
+        automatic: false,
+        completion
+      };
+      this._enqueueMutation(task);
+      await completion.promise;
+    });
+  }
+  async shutdown() {
+    if (this._state === "shutdown") {
+      return;
+    }
+    return this._queueOrRunMutation("shutdown", async () => {
+      if (this._shutdownPromise) {
+        await this._shutdownPromise;
+        return;
+      }
+      this._acceptEvents = false;
+      this._cancelScheduledFlush();
+      const completion = createDeferred();
+      const task = {
+        kind: "shutdown",
+        completion
+      };
+      this._shutdownPromise = completion.promise;
+      this._enqueueMutation(task);
+      await this._shutdownPromise;
+      this._state = "shutdown";
+    });
+  }
+  config() {
+    this._requireReadyRuntime();
+    return this._config;
+  }
+  _applyNormalizedConfig(normalized) {
+    this._apiKey = normalized.apiKey;
+    this._config = normalized.resolvedConfig;
+    this._storage = normalized.storage;
+    this._transport = normalized.transport;
+    this._insertIdGenerator = new InsertIdGenerator(this._config.partId);
+    this._blockedProperties = this._config.blockedProperties.length > 0 ? new Set(this._config.blockedProperties) : null;
+    this._pluginRuntime = new PluginRuntime({
+      config: this._config,
+      hooks: this._hooks,
+      emitError: this._emitError.bind(this),
+      plugins: normalized.plugins
+    });
+    this._optOut = this._config.optOut;
+    this._identity = {
+      userId: null,
+      deviceId: createUuidV4()
+    };
+    this._queue = [];
+    this._flushTask = null;
+    this._mutationQueue = [];
+    this._mutationDrainPromise = null;
+    this._automaticFlushPending = false;
+    this._activeAutomaticFlushReason = null;
+    this._acceptEvents = true;
+    this._shutdownPromise = null;
+  }
+  _requireReadyRuntime() {
+    if (this._state !== "ready") {
+      throw new Error("Signal client is not initialized; call init(apiKey, options) first");
+    }
+    return this._pluginRuntime;
+  }
+  async _queueOrRunMutation(kind, run) {
+    var _a;
+    if (this._state === "shutdown") {
+      throw this._shutdownError();
+    }
+    if (this._state === "failed") {
+      throw (_a = this._initError) != null ? _a : new Error("Signal client initialization failed");
+    }
+    if (this._state === "uninitialized" || this._state === "initializing") {
+      const deferred = createDeferred();
+      this._queuedMutations.push({
+        kind,
+        deferred,
+        run
+      });
+      return deferred.promise;
+    }
+    return run();
+  }
+  async _queueOrRunMutationWithResult(run) {
+    var _a;
+    if (this._state === "shutdown") {
+      throw this._shutdownError();
+    }
+    if (this._state === "failed") {
+      throw (_a = this._initError) != null ? _a : new Error("Signal client initialization failed");
+    }
+    if (this._state === "uninitialized" || this._state === "initializing") {
+      const deferred = createDeferred();
+      this._queuedMutations.push({
+        kind: "mutation",
+        deferred,
+        run
+      });
+      return deferred.promise;
+    }
+    return run();
+  }
+  async _drainQueuedMutations() {
+    if (this._drainingQueuedMutations) {
+      return;
+    }
+    this._drainingQueuedMutations = true;
+    try {
+      while (this._queuedMutations.length > 0) {
+        const mutation = this._queuedMutations.shift();
+        if (!mutation) {
+          continue;
+        }
+        try {
+          const value = await mutation.run();
+          mutation.deferred.resolve(value);
+        } catch (error) {
+          mutation.deferred.reject(error);
+        }
+        if (mutation.kind === "shutdown") {
+          this._rejectQueuedMutations(this._shutdownError());
+          break;
+        }
+      }
+    } finally {
+      this._drainingQueuedMutations = false;
+    }
+  }
+  _rejectQueuedMutations(error) {
+    var _a;
+    while (this._queuedMutations.length > 0) {
+      (_a = this._queuedMutations.shift()) == null ? void 0 : _a.deferred.reject(error);
+    }
+  }
+  _shutdownError() {
+    return new Error("Signal client has been shut down; create a new client instance instead");
+  }
+  _isShutdown() {
+    return this._state === "shutdown";
+  }
+  _enqueueMutation(task) {
+    this._mutationQueue.push(task);
+    this._ensureMutationDrain();
+  }
+  _ensureMutationDrain() {
+    if (this._mutationDrainPromise) {
+      return;
+    }
+    this._mutationDrainPromise = this._drainMutations().finally(() => {
+      this._mutationDrainPromise = null;
+      if (this._mutationQueue.length > 0) {
+        this._ensureMutationDrain();
+      }
+    });
+  }
+  async _drainMutations() {
+    while (this._mutationQueue.length > 0) {
+      const headTask = this._mutationQueue[0];
+      if (!headTask) {
+        break;
+      }
+      let task = null;
+      try {
+        await this._awaitMutationPrerequisites(headTask);
+        task = collectMergedMutationTask(this._mutationQueue);
+        if (!task) {
+          break;
+        }
+        await this._runMutationTask(task);
+      } catch (error) {
+        if (task) {
+          this._rejectMutationTask(task, error);
+        } else {
+          const failedHead = this._mutationQueue.shift();
+          if (failedHead) {
+            this._rejectMutationTask(failedHead, error);
+          }
+        }
+        this._emitError({ stage: "mutation", error });
+      }
+    }
+  }
+  _rejectMutationTask(task, error) {
+    switch (task.kind) {
+      case "plugin-add":
+      case "identity":
+      case "opt-out":
+      case "flush":
+      case "shutdown":
+        task.completion.reject(error);
+        return;
+      case "plugin-remove":
+        task.completion.reject(error);
+        return;
+      case "track-family":
+        for (const request of task.requests) {
+          request.completion.reject(error);
+        }
+        return;
+    }
+  }
+  async _awaitMutationPrerequisites(task) {
+    switch (task.kind) {
+      case "plugin-add":
+      case "plugin-remove":
+        return;
+      default:
+        await this._ready;
+    }
+  }
+  async _runMutationTask(task) {
+    switch (task.kind) {
+      case "plugin-add":
+        await this._pluginRuntime.setup(task.plugin);
+        task.completion.resolve(void 0);
+        return;
+      case "plugin-remove": {
+        const removed = await this._pluginRuntime.remove(task.pluginName);
+        task.completion.resolve(removed);
+        return;
+      }
+      case "identity":
+        await this._runIdentityMutationTask(task);
+        task.completion.resolve(void 0);
+        return;
+      case "opt-out":
+        await this._runOptOutMutationTask(task);
+        task.completion.resolve(void 0);
+        return;
+      case "track-family":
+        await this._runTrackFamilyMutationTask(task);
+        return;
+      case "flush":
+        await this._runFlushMutationTask(task);
+        return;
+      case "shutdown":
+        await this._runShutdownMutationTask();
+        task.completion.resolve(void 0);
+        return;
+    }
+  }
+  async _runIdentityMutationTask(task) {
+    var _a;
+    const previousIdentity = cloneIdentity(this._identity);
+    switch (task.action) {
+      case "logged-in":
+        this._identity.userId = (_a = task.userId) != null ? _a : null;
+        break;
+      case "logged-out":
+        this._identity.userId = null;
+        break;
+      case "reset":
+        this._identity.userId = null;
+        this._identity.deviceId = typeof task.deviceId === "string" && task.deviceId.length > 0 ? task.deviceId : createUuidV4();
+        break;
+    }
+    await this._persistIdentity();
+    await this._emitIdentityChanged(previousIdentity, task.action);
+  }
+  async _runOptOutMutationTask(task) {
+    const previousOptOut = this._optOut;
+    if (previousOptOut === task.optOut) {
+      task.completion.resolve(void 0);
+      return;
+    }
+    this._optOut = task.optOut;
+    this._config.optOut = task.optOut;
+    await this._persistIdentity();
+    if (task.optOut) {
+      this._cancelScheduledFlush();
+      this._queue = [];
+      await this._clearQueueStorage();
+    }
+    await this._hooks.emitOptOutChanged({
+      previousOptOut,
+      optOut: task.optOut
+    });
+  }
+  async _runTrackFamilyMutationTask(task) {
+    if (!this._acceptEvents || this._optOut) {
+      for (const request of task.requests) {
+        request.completion.resolve(void 0);
+      }
+      return;
+    }
+    const queuedResults = [];
+    const droppedIds = [];
+    let shouldFlushImmediately = false;
+    for (const request of task.requests) {
+      const entry = await this._createQueueEntry(
+        request.event,
+        request.properties,
+        request.options
+      );
+      if (!entry) {
+        request.completion.resolve(void 0);
+        continue;
+      }
+      const dropped = this._enqueue(entry);
+      queuedResults.push({
+        entry,
+        queuedEvents: this._queue.length,
+        request
+      });
+      if (dropped) {
+        droppedIds.push(dropped.id);
+      }
+      shouldFlushImmediately || (shouldFlushImmediately = entry.options.flush === "immediate");
+    }
+    await this._upsertQueueEntries(queuedResults.map(({ entry }) => entry));
+    if (droppedIds.length > 0) {
+      await this._removeQueueEntries(droppedIds);
+    }
+    for (const { entry, queuedEvents, request } of queuedResults) {
+      await this._hooks.emitEventQueued({
+        event: entry.event,
+        options: entry.options,
+        queuedEvents
+      });
+      if (!request.waitForImmediateFlush) {
+        request.completion.resolve(void 0);
+      }
+    }
+    if (queuedResults.length === 0) {
+      return;
+    }
+    if (shouldFlushImmediately) {
+      this._cancelScheduledFlush();
+      await this._performFlush("immediate");
+      for (const { request } of queuedResults) {
+        if (request.waitForImmediateFlush) {
+          request.completion.resolve(void 0);
+        }
+      }
+      return;
+    }
+    this._scheduleAutomaticFlush(this._config.flushIntervalMs, "scheduled");
+  }
+  async _runFlushMutationTask(task) {
+    if (!task.automatic) {
+      this._cancelScheduledFlush();
+    } else {
+      this._activeAutomaticFlushReason = task.reason;
+    }
+    try {
+      await this._performFlush(task.reason);
+      task.completion.resolve(void 0);
+    } finally {
+      if (task.automatic) {
+        this._activeAutomaticFlushReason = null;
+        this._automaticFlushPending = false;
+      }
+    }
+  }
+  async _runShutdownMutationTask() {
+    await this._performFlush("shutdown");
+    await this._pluginRuntime.flushAll();
+    await this._pluginRuntime.teardownAll();
+    if (!this._transport.shutdown) {
+      return;
+    }
+    try {
+      await this._transport.shutdown();
+    } catch (error) {
+      this._emitError({ stage: "transport:shutdown", error });
+    }
+  }
+  async _initialize(initialIdentityOverrides) {
+    await this._hydrateIdentity();
+    await this._applyInitialIdentityOverrides(initialIdentityOverrides);
+    if (this._optOut) {
+      await this._clearQueueStorage();
+    } else {
+      await this._hydrateQueue();
+    }
+    await this._pluginRuntime.setupAll();
+    await this._hooks.emitInit({
+      config: this._config,
+      identity: cloneIdentity(this._identity),
+      optOut: this._optOut
+    });
+    if (this._queue.length > 0) {
+      this._scheduleAutomaticFlush(this._config.flushIntervalMs, "scheduled");
+    }
+  }
+  async _hydrateIdentity() {
+    try {
+      const stored = await this._storage.identity.get(IDENTITY_STORAGE_KEY);
+      if (!stored || typeof stored.deviceId !== "string" || typeof stored.optOut !== "boolean") {
+        await this._persistIdentity();
+        return;
+      }
+      this._identity.userId = typeof stored.userId === "string" ? stored.userId : null;
+      this._identity.deviceId = stored.deviceId;
+      this._optOut = stored.optOut;
+      this._config.optOut = stored.optOut;
+    } catch (error) {
+      this._emitError({ stage: "storage:hydrate-identity", error });
+    }
+  }
+  async _applyInitialIdentityOverrides(initialIdentityOverrides) {
+    let changed = false;
+    if (initialIdentityOverrides.userId !== void 0 && this._identity.userId !== initialIdentityOverrides.userId) {
+      this._identity.userId = initialIdentityOverrides.userId;
+      changed = true;
+    }
+    if (typeof initialIdentityOverrides.deviceId === "string" && this._identity.deviceId !== initialIdentityOverrides.deviceId) {
+      this._identity.deviceId = initialIdentityOverrides.deviceId;
+      changed = true;
+    }
+    if (!changed) {
+      return;
+    }
+    await this._persistIdentity();
+  }
+  async _hydrateQueue() {
+    if (!this._config.persistQueue) {
+      return;
+    }
+    try {
+      const stored = await this._storage.queue.load(this._config.maxQueueSize);
+      const hydrated = stored.filter(isQueueEntry).slice(-this._config.maxQueueSize);
+      this._queue.push(...hydrated);
+      await this._trimQueueStorage();
+    } catch (error) {
+      this._emitError({ stage: "storage:hydrate-queue", error });
+    }
+  }
+  async _createQueueEntry(eventType, properties, options) {
+    const resolvedOptions = this._resolveTrackOptions(options);
+    const now = Date.now();
+    if (typeof eventType !== "string" || eventType.length === 0) {
+      this._emitError({
+        stage: "event:validation",
+        error: new Error("track() requires a non-empty event name")
+      });
+      return null;
+    }
+    const normalizedProperties = isTrackProperties(properties) ? properties : {};
+    const {
+      [EVENT_TYPE_KEY]: _ignoredEventType,
+      [EVENT_TIME_KEY]: _ignoredTime,
+      [EVENT_USER_ID_KEY]: _ignoredUserId,
+      [EVENT_DEVICE_ID_KEY]: _ignoredDeviceId,
+      [EVENT_INSERT_ID_KEY]: _ignoredInsertId,
+      [EVENT_VERSION_KEY]: _ignoredVersion,
+      ...rest
+    } = normalizedProperties;
+    const event = {
+      ...rest,
+      [EVENT_TYPE_KEY]: eventType,
+      [EVENT_TIME_KEY]: now,
+      [EVENT_USER_ID_KEY]: this._identity.userId,
+      [EVENT_INSERT_ID_KEY]: this._insertIdGenerator.next(),
+      ...this._config.version === void 0 ? {} : {
+        [EVENT_VERSION_KEY]: this._config.version
+      }
+    };
+    let dropped = false;
+    const drop = () => {
+      dropped = true;
+    };
+    await this._hooks.emitEventCreated({ event, options: resolvedOptions, drop });
+    if (dropped) {
+      return null;
+    }
+    await this._hooks.emitBeforeEnqueue({ event, options: resolvedOptions, drop });
+    if (dropped) {
+      return null;
+    }
+    if (typeof event[EVENT_INSERT_ID_KEY] !== "string" || event[EVENT_INSERT_ID_KEY].length === 0) {
+      this._emitError({
+        stage: "event:validation",
+        error: new Error("track() requires event.@insertid")
+      });
+      return null;
+    }
+    return {
+      id: createQueueEntryId(),
+      deviceId: this._identity.deviceId,
+      event,
+      options: resolvedOptions,
+      attempts: 0
+    };
+  }
+  _resolveTrackOptions(options) {
+    var _a;
+    return {
+      flush: options.flush === "immediate" ? "immediate" : "scheduled",
+      endpoint: (_a = options.endpoint) != null ? _a : this._config.endpoint,
+      timeoutMs: options.timeoutMs,
+      retries: typeof options.retries === "number" && options.retries >= 0 ? Math.floor(options.retries) : this._config.retry.maxAttempts
+    };
+  }
+  _enqueue(entry) {
+    var _a;
+    let dropped = null;
+    if (this._queue.length >= this._config.maxQueueSize) {
+      dropped = (_a = this._queue.shift()) != null ? _a : null;
+    }
+    this._queue.push(entry);
+    return dropped;
+  }
+  _scheduleAutomaticFlush(delayMs, reason) {
+    if (!this._acceptEvents) {
+      return;
+    }
+    if (reason === "scheduled" && this._automaticFlushPending) {
+      return;
+    }
+    if (reason === "retry") {
+      this._cancelScheduledFlush();
+    }
+    const enqueueAutomaticFlush = () => {
+      this._flushTask = null;
+      if (!this._acceptEvents) {
+        if (!this._activeAutomaticFlushReason) {
+          this._automaticFlushPending = false;
+        }
+        return;
+      }
+      const completion = createDeferred();
+      const task2 = {
+        kind: "flush",
+        reason,
+        automatic: true,
+        completion
+      };
+      this._enqueueMutation(task2);
+    };
+    this._automaticFlushPending = true;
+    if (delayMs <= 0) {
+      enqueueAutomaticFlush();
+      return;
+    }
+    const task = scheduleTask(() => {
+      enqueueAutomaticFlush();
+    }, delayMs);
+    if (!task) {
+      enqueueAutomaticFlush();
+      return;
+    }
+    this._flushTask = task;
+  }
+  async _performFlush(reason) {
+    await this._hooks.emitBeforeFlush({
+      reason,
+      queuedEvents: this._queue.length
+    });
+    let attempted = 0;
+    let sent = 0;
+    let dropped = 0;
+    let queueMutated = false;
+    let scheduledRetry = false;
+    const removedIds = [];
+    const upsertedEntries = [];
+    const maxEventsForRun = reason === "scheduled" || reason === "retry" ? this._config.maxBatchSize : Number.POSITIVE_INFINITY;
+    const stopAfterFirstRequest = reason === "scheduled" || reason === "retry";
+    while (this._queue.length > 0 && attempted < maxEventsForRun) {
+      const batch = collectCompatibleBatch(this._queue, maxEventsForRun - attempted);
+      if (batch.length === 0) {
+        break;
+      }
+      attempted += batch.length;
+      const { droppedBeforeSendEntries, transportEntries } = await this._prepareBatchForTransport(
+        reason,
+        batch
+      );
+      if (droppedBeforeSendEntries.length > 0) {
+        queueMutated = true;
+        dropped += droppedBeforeSendEntries.length;
+        removedIds.push(
+          ...await this._removeDroppedBeforeSendEntries(
+            reason,
+            batch,
+            transportEntries,
+            droppedBeforeSendEntries
+          )
+        );
+      }
+      if (transportEntries.length === 0) {
+        continue;
+      }
+      const txTime = Date.now();
+      const request = this._createTransportRequest(transportEntries, txTime);
+      const result = await this._transport.send(request);
+      if (result.ok) {
+        queueMutated = true;
+        sent += transportEntries.length;
+        removedIds.push(
+          ...await this._handleSuccessfulTransportBatch(reason, transportEntries, txTime, result)
+        );
+        if (stopAfterFirstRequest) {
+          break;
+        }
+        continue;
+      }
+      const failedTransportBatch = await this._handleFailedTransportBatch(
+        reason,
+        transportEntries,
+        txTime,
+        result
+      );
+      queueMutated = true;
+      dropped += failedTransportBatch.dropped;
+      removedIds.push(...failedTransportBatch.removedIds);
+      upsertedEntries.push(...failedTransportBatch.upsertedEntries);
+      scheduledRetry || (scheduledRetry = failedTransportBatch.scheduledRetry);
+      break;
+    }
+    if (queueMutated) {
+      await this._upsertQueueEntries(upsertedEntries);
+      await this._removeQueueEntries(removedIds);
+    }
+    const pendingAutomaticFlush = this._automaticFlushPending && this._activeAutomaticFlushReason === null;
+    if (this._acceptEvents && !scheduledRetry && this._queue.length > 0 && !this._flushTask && !pendingAutomaticFlush) {
+      this._scheduleAutomaticFlush(this._config.flushIntervalMs, "scheduled");
+    }
+    await this._hooks.emitAfterFlush({
+      reason,
+      attempted,
+      sent,
+      dropped,
+      queuedEvents: this._queue.length
+    });
+  }
+  _computeBackoff(attempt) {
+    const exponential = this._config.retry.baseMs * 2 ** Math.max(0, attempt - 1);
+    const clamped = Math.min(this._config.retry.maxMs, exponential);
+    if (this._config.retry.jitter <= 0) {
+      return clamped;
+    }
+    const jitterWindow = clamped * this._config.retry.jitter;
+    const randomOffset = (Math.random() * 2 - 1) * jitterWindow;
+    return Math.max(1, Math.floor(clamped + randomOffset));
+  }
+  async _persistIdentity() {
+    try {
+      await this._storage.identity.set(IDENTITY_STORAGE_KEY, {
+        userId: this._identity.userId,
+        deviceId: this._identity.deviceId,
+        optOut: this._optOut
+      });
+    } catch (error) {
+      this._emitError({ stage: "storage:persist-identity", error });
+    }
+  }
+  async _emitIdentityChanged(previousIdentity, reason) {
+    await this._hooks.emitIdentityChanged({
+      reason,
+      previousIdentity,
+      identity: cloneIdentity(this._identity)
+    });
+  }
+  _cancelScheduledFlush() {
+    if (!this._flushTask) {
+      return;
+    }
+    this._flushTask.cancel();
+    this._flushTask = null;
+    if (!this._activeAutomaticFlushReason) {
+      this._automaticFlushPending = false;
+    }
+  }
+  async _clearQueueStorage() {
+    if (!this._config.persistQueue) {
+      return;
+    }
+    try {
+      await this._storage.queue.clear();
+    } catch (error) {
+      this._emitError({ stage: "storage:clear-queue", error });
+    }
+  }
+  async _upsertQueueEntries(entries) {
+    if (!this._config.persistQueue) {
+      return;
+    }
+    if (entries.length === 0) {
+      return;
+    }
+    const byId = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      byId.set(entry.id, entry);
+    }
+    try {
+      await this._storage.queue.upsert([...byId.values()]);
+    } catch (error) {
+      this._emitError({ stage: "storage:upsert-queue", error });
+    }
+  }
+  async _removeQueueEntries(ids) {
+    if (!this._config.persistQueue) {
+      return;
+    }
+    if (ids.length === 0) {
+      return;
+    }
+    const uniqueIds = [...new Set(ids)];
+    try {
+      await this._storage.queue.remove(uniqueIds);
+    } catch (error) {
+      this._emitError({ stage: "storage:remove-queue", error });
+    }
+  }
+  async _trimQueueStorage() {
+    if (!this._config.persistQueue) {
+      return;
+    }
+    try {
+      await this._storage.queue.trim(this._config.maxQueueSize);
+    } catch (error) {
+      this._emitError({ stage: "storage:trim-queue", error });
+    }
+  }
+  _emitError(context) {
+    this._hooks.emitError(context);
+  }
+  async _prepareBatchForTransport(reason, batch) {
+    const droppedBeforeSendEntries = [];
+    const transportEntries = [];
+    for (const entry of batch) {
+      const attempt = entry.attempts + 1;
+      let droppedBeforeSend = false;
+      const drop = () => {
+        droppedBeforeSend = true;
+      };
+      await this._hooks.emitBeforeSend({
+        reason,
+        event: entry.event,
+        options: entry.options,
+        attempt,
+        drop
+      });
+      if (droppedBeforeSend) {
+        droppedBeforeSendEntries.push({ attempt, entry });
+        continue;
+      }
+      this._stripBlockedProperties(entry.event);
+      transportEntries.push({ attempt, entry });
+    }
+    return {
+      droppedBeforeSendEntries,
+      transportEntries
+    };
+  }
+  async _removeDroppedBeforeSendEntries(reason, batch, transportEntries, droppedBeforeSendEntries) {
+    const removedIds = droppedBeforeSendEntries.map(({ entry }) => entry.id);
+    this._queue.splice(0, batch.length, ...transportEntries.map(({ entry }) => entry));
+    for (const { attempt, entry } of droppedBeforeSendEntries) {
+      await this._hooks.emitAfterSend({
+        reason,
+        event: entry.event,
+        options: entry.options,
+        attempt,
+        outcome: "dropped",
+        queuedEvents: this._queue.length
+      });
+    }
+    return removedIds;
+  }
+  _createTransportRequest(transportEntries, txTime) {
+    const [firstTransportEntry] = transportEntries;
+    if (!firstTransportEntry) {
+      throw new Error("Transport request requires at least one queue entry");
+    }
+    const requestEntries = transportEntries.map(({ entry }) => entry);
+    const locationFromIpEnabled = this._config.locationFromIp;
+    return {
+      apiKey: this._apiKey,
+      endpoint: firstTransportEntry.entry.options.endpoint,
+      // Keep both request views derived from the same queue batch.
+      events: requestEntries.map(({ event }) => event),
+      eventGroups: createTransportGroups(requestEntries),
+      locationFromIp: locationFromIpEnabled,
+      txTime,
+      timeoutMs: firstTransportEntry.entry.options.timeoutMs
+    };
+  }
+  async _handleSuccessfulTransportBatch(reason, transportEntries, txTime, result) {
+    const removedIds = transportEntries.map(({ entry }) => entry.id);
+    this._queue.splice(0, transportEntries.length);
+    for (const { attempt, entry } of transportEntries) {
+      await this._hooks.emitAfterSend({
+        reason,
+        event: entry.event,
+        options: entry.options,
+        attempt,
+        outcome: "sent",
+        txTime,
+        result,
+        queuedEvents: this._queue.length
+      });
+    }
+    return removedIds;
+  }
+  async _handleFailedTransportBatch(reason, transportEntries, txTime, result) {
+    var _a, _b, _c;
+    const status = (_a = result.status) != null ? _a : 0;
+    const retryable = (_b = result.retryable) != null ? _b : status >= 500 || status === 429 || status === 0;
+    this._emitTransportFailure(transportEntries, result, status);
+    const retryEntries = [];
+    const droppedAfterFailureEntries = [];
+    for (const transportEntry of transportEntries) {
+      if (retryable && transportEntry.entry.attempts < transportEntry.entry.options.retries) {
+        transportEntry.entry.attempts += 1;
+        retryEntries.push(transportEntry);
+        continue;
+      }
+      droppedAfterFailureEntries.push(transportEntry);
+    }
+    this._queue.splice(0, transportEntries.length, ...retryEntries.map(({ entry }) => entry));
+    let scheduledRetry = false;
+    if (retryEntries.length > 0 && this._acceptEvents) {
+      const [firstRetryEntry] = retryEntries;
+      const delay = this._computeBackoff((_c = firstRetryEntry == null ? void 0 : firstRetryEntry.entry.attempts) != null ? _c : 1);
+      this._scheduleAutomaticFlush(delay, "retry");
+      scheduledRetry = true;
+    }
+    for (const { attempt, entry } of retryEntries) {
+      await this._hooks.emitAfterSend({
+        reason,
+        event: entry.event,
+        options: entry.options,
+        attempt,
+        outcome: "retry",
+        txTime,
+        result,
+        queuedEvents: this._queue.length
+      });
+    }
+    for (const { attempt, entry } of droppedAfterFailureEntries) {
+      await this._hooks.emitAfterSend({
+        reason,
+        event: entry.event,
+        options: entry.options,
+        attempt,
+        outcome: "dropped",
+        result,
+        queuedEvents: this._queue.length
+      });
+    }
+    return {
+      dropped: droppedAfterFailureEntries.length,
+      removedIds: droppedAfterFailureEntries.map(({ entry }) => entry.id),
+      scheduledRetry,
+      upsertedEntries: retryEntries.map(({ entry }) => entry)
+    };
+  }
+  _emitTransportFailure(transportEntries, result, status) {
+    var _a;
+    const failedInsertIds = transportEntries.map(({ entry }) => {
+      var _a2;
+      return String((_a2 = entry.event[EVENT_INSERT_ID_KEY]) != null ? _a2 : "unknown");
+    }).join(", ");
+    this._emitError({
+      stage: "transport:send",
+      error: (_a = result.error) != null ? _a : new Error(`Transport failed with status ${status} for events ${failedInsertIds}`)
+    });
+  }
+  _stripBlockedProperties(properties) {
+    if (!this._blockedProperties) {
+      return;
+    }
+    for (const property of this._blockedProperties) {
+      delete properties[property];
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HookRegistry,
+  InMemoryStorage,
+  SignalClient,
+  createFetchTransport
+});