@bazariodev/docket 0.0.0-stage → 0.0.0

package/dist/history/index.js

@@ -0,0 +1,1194 @@
+import { e as randomHex, c as assertStormLimit, a as assertLevel, p as positive, b as report, f as copyBindings } from '../chunk-LRCHwVuE.js';
+import { c as LOGGING_LIMITS, L as LEVELS, d as LOGGING_ERROR_SOURCES, b as LOGGING_ERROR_CODES } from '../chunk-CSS3f4_M.js';
+import { c as createLogging, l as loggingError } from '../chunk-B-SP8Od_.js';
+import '../chunk-7ld72rnl.js';
+
+const STORE_MODES = Object.freeze({
+  OPENING: 'opening',
+  MEMORY: 'memory',
+  PERSISTENT: 'persistent',
+  FALLBACK: 'fallback',
+  STOPPED: 'stopped',
+});
+
+const OVERFLOW_STRATEGIES = Object.freeze({
+  CYCLE: 'cycle',
+  ROTATE: 'rotate',
+});
+
+const HISTORY_MODES = /* @__PURE__ */ Object.freeze({
+  OFF: 'off',
+  MEMORY: 'memory',
+  PERSISTENT: 'persistent',
+});
+const HISTORY_STATES = /* @__PURE__ */ Object.freeze({
+  IDLE: 'idle',
+  ACTIVE: 'active',
+  TRANSITIONING: 'transitioning',
+  BLOCKED: 'blocked',
+  STALE: 'stale',
+  STOPPED: 'stopped',
+});
+const HISTORY_ERROR_CODES = /* @__PURE__ */ Object.freeze({
+  METADATA: 'metadata',
+  CLEANUP: 'cleanup',
+  STALE: 'stale',
+  SETUP: 'setup',
+  MIGRATION: 'migration',
+  STOPPED: 'stopped',
+  ROTATION: 'rotation',
+});
+const HISTORY_ERRORS = /* @__PURE__ */ Object.freeze({
+  [HISTORY_ERROR_CODES.METADATA]: 'Log history metadata failed',
+  [HISTORY_ERROR_CODES.CLEANUP]: 'Log history cleanup failed',
+  [HISTORY_ERROR_CODES.STALE]: 'Log history stale failed',
+  [HISTORY_ERROR_CODES.SETUP]: 'Log history setup failed',
+  [HISTORY_ERROR_CODES.MIGRATION]: 'Log history migration failed',
+  [HISTORY_ERROR_CODES.STOPPED]: 'Log history stopped failed',
+  [HISTORY_ERROR_CODES.ROTATION]: 'Log history rotation failed',
+});
+const HISTORY_LIMITS = /* @__PURE__ */ Object.freeze({
+  STARTUP_DEFAULT_MAX_SIZE_PER_AREA: 250_000,
+  STARTUP_MAX_TOTAL_SIZE: 1_000_000,
+});
+
+function historyError(code, cause) {
+  return Object.assign(
+    new Error(
+      HISTORY_ERRORS[code] ?? `Log history ${code} failed`,
+      cause === undefined ? undefined : { cause },
+    ),
+    { code },
+  );
+}
+
+function readMetadata(storage, key, leaseKey) {
+  const text = storage.getItem(key);
+  if (!text) return null;
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (
+    !value ||
+    value.version !== 1 ||
+    !Number.isSafeInteger(value.revision) ||
+    value.revision < 1 ||
+    !Object.values(HISTORY_MODES).includes(value.mode) ||
+    typeof value.cleanupPending !== 'boolean'
+  )
+    return null;
+  if (value.leaseKey !== leaseKey)
+    throw historyError(HISTORY_ERROR_CODES.METADATA);
+  if (
+    !value.loggedOut &&
+    !value.ownerless &&
+    (!/^[a-f0-9]{32}$/.test(value.salt) ||
+      !/^[a-f0-9]{64}$/.test(value.ownerDigest))
+  )
+    return null;
+  if (
+    (value.mode !== HISTORY_MODES.PERSISTENT || value.cleanupPending) &&
+    Object.hasOwn(value, 'key')
+  ) {
+    delete value.key;
+    storage.setItem(key, JSON.stringify(value));
+  }
+  if (value.key && !/^[a-f0-9]{64}$/.test(value.key)) return null;
+  return value;
+}
+
+async function digestOwner(ownerId, salt = randomHex(16)) {
+  if (!globalThis.crypto?.subtle) throw historyError(HISTORY_ERROR_CODES.SETUP);
+  const input = new TextEncoder().encode(
+    JSON.stringify(['bazario-log-owner-v1', salt, ownerId]),
+  );
+  const digest = await crypto.subtle.digest('SHA-256', input);
+  return {
+    salt,
+    ownerDigest: Array.from(new Uint8Array(digest), (byte) =>
+      byte.toString(16).padStart(2, '0'),
+    ).join(''),
+  };
+}
+
+const STORE_OPTION_NAMES = Object.freeze([
+  'flushIntervalMs',
+  'maxBatchSize',
+  'maxQueuedRecords',
+  'maxQueuedSize',
+]);
+
+function validateStoreOptions(options, stores, lease) {
+  stores.validateStoreOptions(options);
+  if (lease.signal.aborted) throw historyError(HISTORY_ERROR_CODES.STOPPED);
+}
+
+function validateHistoryOptions(options) {
+  const { lease } = options ?? {};
+  if (
+    !lease?.key ||
+    !lease.signal ||
+    lease.signal.aborted ||
+    typeof lease.signal.addEventListener !== 'function'
+  )
+    throw new TypeError('An active application lease is required');
+  if (
+    !Array.isArray(options.logging?.areas) ||
+    typeof options.createRedactor !== 'function'
+  )
+    throw new TypeError('Logging areas and createRedactor are required');
+  if (Object.hasOwn(options.logging, 'createRunId'))
+    throw new TypeError('Managed history controls its run IDs');
+  if (Object.hasOwn(options.logging, 'isActive'))
+    throw new TypeError('Managed history controls admission');
+  assertStormLimit(options.logging.stormLimit);
+  if (Object.hasOwn(options.persistent ?? {}, 'allowUnprotected'))
+    throw new TypeError('Managed history requires protected database access');
+  const areas = new Set();
+  for (const area of options.logging.areas) {
+    if (typeof area.id !== 'string' || !area.id || areas.has(area.id))
+      throw new TypeError('Invalid history area');
+    assertLevel(area.level ?? 'info');
+    areas.add(area.id);
+  }
+  for (const nested of [options.memory, options.startup, options.persistent])
+    if (
+      nested &&
+      (Object.hasOwn(nested, 'overflowStrategy') ||
+        Object.hasOwn(nested, 'onRotate'))
+    )
+      throw new TypeError('Rotation options belong to history');
+  validateStoreOptions(options, options.stores, lease);
+  for (const nested of [
+    options.memory,
+    options.startup || {},
+    options.persistent,
+    options.persistent?.fallback,
+  ])
+    validateStoreOptions(nested, options.stores, lease);
+  for (const name of STORE_OPTION_NAMES)
+    if (options.persistent?.[name] !== undefined)
+      positive(options.persistent[name], name);
+  if (options.logging.maxOverrideMs !== undefined)
+    positive(options.logging.maxOverrideMs, 'maxOverrideMs');
+  if (
+    options.databaseName !== undefined &&
+    (typeof options.databaseName !== 'string' || !options.databaseName)
+  )
+    throw new TypeError('Invalid history database name');
+  const databaseName =
+    options.databaseName ?? `bazario-logging:history:${lease.key}`;
+  const metadataKey = `bazario-logging:metadata:${databaseName}`;
+  const requestedMode = options.initialMode ?? HISTORY_MODES.MEMORY;
+  if (!Object.values(HISTORY_MODES).includes(requestedMode))
+    throw new TypeError('Invalid history mode');
+  return { lease, areas, databaseName, metadataKey, requestedMode };
+}
+
+function createHistorySession({
+  options,
+  store,
+  key,
+  isLive,
+  canControl,
+  levelStorage,
+  startup,
+  trackCleanup,
+}) {
+  const state = {
+    valid: true,
+    paused: false,
+    store,
+    key,
+    startup,
+    hub: null,
+    session: null,
+    queries: new Set(),
+  };
+  const live = () => state.valid && !state.paused && isLive();
+  const check = () => {
+    if (!live()) throw historyError(HISTORY_ERROR_CODES.STALE);
+  };
+  const redactor = options.createRedactor(key);
+  check();
+  const guardedRedactor = {
+    version: redactor.version,
+    limits: redactor.limits,
+  };
+  for (const method of [
+    'redact',
+    'redactValue',
+    'redactText',
+    'mask',
+    ...(redactor.hash ? ['hash'] : []),
+  ])
+    guardedRedactor[method] = (...args) => {
+      check();
+      const result = redactor[method](...args);
+      check();
+      return result;
+    };
+  const sinks = [];
+  let hub;
+  try {
+    if (!startup)
+      sinks.push(
+        ...(options.createSinks?.(Object.freeze(guardedRedactor)) ?? []),
+      );
+    check();
+    hub = createLogging({
+      ...options.logging,
+      redactor: guardedRedactor,
+      sinks: [store, ...sinks],
+      ...(levelStorage ? { levelStorage } : {}),
+      isActive: live,
+    });
+  } catch (failure) {
+    const cleanup = Promise.allSettled(
+      sinks.map(async (sink) => sink.stop?.()),
+    );
+    trackCleanup(cleanup);
+    throw failure;
+  }
+  state.hub = hub;
+  const logging = {};
+  for (const method of ['setLevel', 'resetLevel', 'getLevels', 'setContext'])
+    logging[method] = (...args) => {
+      check();
+      if (['setLevel', 'resetLevel'].includes(method) && !canControl())
+        throw historyError(HISTORY_ERROR_CODES.STALE);
+      const result = hub[method](...args);
+      check();
+      return result;
+    };
+  const guardLogger = (logger) => {
+    const result = {};
+    for (const level of Object.values(LEVELS))
+      result[level] = (message, data) => {
+        if (live()) logger[level](message, data);
+      };
+    result.child = (binding) => guardLogger(logger.child(binding));
+    return Object.freeze(result);
+  };
+  const roots = new Map();
+  logging.runId = hub.runId;
+  logging.getLogger = (area, scope) => {
+    check();
+    const key = JSON.stringify([area, scope]);
+    const cached = roots.get(key);
+    if (cached) return cached;
+    const logger = guardLogger(hub.getLogger(area, scope));
+    if (roots.size < LOGGING_LIMITS.ROOT_LOGGER_CACHE_PAIRS)
+      roots.set(key, logger);
+    return logger;
+  };
+  logging.flush = async () => {
+    check();
+    await hub.flush();
+    check();
+  };
+  const source = Object.freeze({
+    async query(query) {
+      check();
+      const pending = Promise.resolve().then(() => store.query(query));
+      state.queries.add(pending);
+      try {
+        const records = await pending;
+        check();
+        return records;
+      } finally {
+        state.queries.delete(pending);
+      }
+    },
+
+    getStatus() {
+      check();
+      return store.getStatus();
+    },
+  });
+  state.session = Object.freeze({
+    logging: Object.freeze(logging),
+    source,
+    redactor: Object.freeze(guardedRedactor),
+  });
+  return state;
+}
+
+function createLogHistory(options) {
+  if (
+    !options?.stores ||
+    typeof options.stores.createMemoryStore !== 'function' ||
+    typeof options.stores.createIndexedDbStore !== 'function' ||
+    typeof options.stores.validateStoreOptions !== 'function' ||
+    typeof options.stores.copyRecords !== 'function'
+  )
+    throw new TypeError('History store providers are required');
+  const {
+    lease,
+    areas,
+    databaseName,
+    metadataKey,
+    requestedMode: initialMode,
+  } = validateHistoryOptions(options);
+  if (lease.signal.aborted) throw historyError(HISTORY_ERROR_CODES.STOPPED);
+  const roots = new Map();
+  const retired = new Set();
+  const sessions = new Set();
+  let storage;
+  let metadata = null;
+  let requestedMode = initialMode;
+  let state = HISTORY_STATES.IDLE;
+  let current = null;
+  let startup = null;
+  let ownerId;
+  let stopped = false;
+  let startupEpoch = 0;
+  let controlQueue = Promise.resolve();
+  let stopPromise;
+  let rotationBusy = false;
+  let setupFailure;
+  let forwarding = false;
+  let rootLoggerLimitReported = false;
+  const status = () =>
+    Object.freeze({
+      state,
+      requestedMode,
+      activeMode: current
+        ? current.store.getStatus().mode === STORE_MODES.PERSISTENT
+          ? HISTORY_MODES.PERSISTENT
+          : HISTORY_MODES.MEMORY
+        : HISTORY_MODES.OFF,
+      cleanupPending: metadata?.cleanupPending ?? false,
+    });
+
+  function notify() {
+    report(options.onChange, current?.session ?? null, status());
+  }
+
+  function error(code, cause) {
+    const failure = historyError(code, cause);
+    report(options.onError, failure);
+    return failure;
+  }
+
+  function check() {
+    if (stopped || lease.signal.aborted)
+      throw historyError(HISTORY_ERROR_CODES.STOPPED);
+  }
+
+  function retire(session, discard = false) {
+    if (!session) return Promise.resolve();
+    session.valid = false;
+    if (current === session) current = null;
+    if (startup === session) startup = null;
+    if (session.cleanupPromise) return session.cleanupPromise;
+    const cleanup = Promise.resolve().then(async () => {
+      try {
+        if (!discard)
+          try {
+            await session.store.flush();
+          } catch (failure) {
+            report(
+              options.onError,
+              historyError(HISTORY_ERROR_CODES.SETUP, failure),
+            );
+          }
+        try {
+          await session.store.stop({ discard });
+        } catch (failure) {
+          if (session.store.getStatus?.()?.mode !== STORE_MODES.STOPPED)
+            throw failure;
+          report(
+            options.onError,
+            historyError(HISTORY_ERROR_CODES.SETUP, failure),
+          );
+        }
+        try {
+          await session.hub?.stop();
+        } catch (failure) {
+          if (session.store.getStatus?.()?.mode !== STORE_MODES.STOPPED)
+            throw failure;
+          report(
+            options.onError,
+            historyError(HISTORY_ERROR_CODES.SETUP, failure),
+          );
+        }
+      } finally {
+        await Promise.allSettled(session.queries ?? []);
+      }
+    });
+    retired.add(cleanup);
+    session.cleanupPromise = cleanup;
+    cleanup.then(
+      () => {
+        retired.delete(cleanup);
+        sessions.delete(session);
+      },
+      () => {
+        retired.delete(cleanup);
+        session.cleanupPromise = null;
+      },
+    );
+    return cleanup;
+  }
+
+  function ownStore(store) {
+    const session = {
+      valid: false,
+      discardOnStop: true,
+      store,
+      hub: null,
+      cleanupPromise: null,
+    };
+    sessions.add(session);
+    return session;
+  }
+
+  async function drainInvalidSessions() {
+    await Promise.all(
+      Array.from(sessions)
+        .filter((session) => !session.valid)
+        .map((session) => retire(session, true)),
+    );
+    check();
+  }
+
+  function discardStartup() {
+    startupEpoch++;
+    if (startup) void retire(startup, true);
+  }
+
+  function block(code, cause) {
+    if (stopped) return historyError(HISTORY_ERROR_CODES.STOPPED);
+    setupFailure = code;
+    state = HISTORY_STATES.BLOCKED;
+    discardStartup();
+    for (const session of sessions) void retire(session, true);
+    notify();
+    return error(code, cause);
+  }
+
+  function read() {
+    try {
+      storage ??= options.storage ?? globalThis.localStorage;
+      if (!storage) throw historyError(HISTORY_ERROR_CODES.METADATA);
+      metadata = readMetadata(storage, metadataKey, lease.key);
+      requestedMode = metadata?.mode ?? requestedMode;
+      return metadata;
+    } catch {
+      throw block(HISTORY_ERROR_CODES.METADATA);
+    }
+  }
+
+  function save(value) {
+    check();
+    const next = { ...value };
+    if (
+      next.mode !== HISTORY_MODES.PERSISTENT ||
+      next.cleanupPending ||
+      next.loggedOut
+    )
+      delete next.key;
+    try {
+      storage.setItem(metadataKey, JSON.stringify(next));
+      metadata = next;
+    } catch {
+      throw block(HISTORY_ERROR_CODES.METADATA);
+    }
+  }
+
+  function privateLevels(owningSession) {
+    return {
+      key: 'levels',
+      storage: {
+        getItem: () => JSON.stringify(metadata?.levels ?? {}),
+        setItem(_key, text) {
+          if (
+            stopped ||
+            lease.signal.aborted ||
+            state !== HISTORY_STATES.ACTIVE ||
+            current !== owningSession() ||
+            !owningSession()?.valid
+          )
+            return;
+          save({ ...metadata, levels: JSON.parse(text) });
+        },
+      },
+    };
+  }
+
+  function trackCleanup(cleanup) {
+    retired.add(cleanup);
+    cleanup.then(() => retired.delete(cleanup));
+  }
+
+  function makeSession(mode, key = randomHex(32), isStartup = false) {
+    let session;
+    const rotationOptions = {
+      overflowStrategy: isStartup
+        ? OVERFLOW_STRATEGIES.CYCLE
+        : options.overflowStrategy,
+      isRotationEnabled: () =>
+        Boolean(
+          session?.valid &&
+            !session.paused &&
+            current === session &&
+            !rotationBusy &&
+            state === HISTORY_STATES.ACTIVE,
+        ),
+      onRotate: options.onRotate
+        ? async (source) => {
+            if (
+              !session?.valid ||
+              stopped ||
+              lease.signal.aborted ||
+              rotationBusy
+            )
+              return;
+            rotationBusy = true;
+            const guardedSource = {
+              async query(query) {
+                if (!session.valid || stopped || lease.signal.aborted)
+                  throw historyError(HISTORY_ERROR_CODES.STALE);
+                const result = await source.query(query);
+                if (!session.valid || stopped || lease.signal.aborted)
+                  throw historyError(HISTORY_ERROR_CODES.STALE);
+                return result;
+              },
+
+              getStatus() {
+                if (!session.valid)
+                  throw historyError(HISTORY_ERROR_CODES.STALE);
+                return source.getStatus();
+              },
+            };
+            try {
+              await options.onRotate(
+                Object.freeze({
+                  source: Object.freeze(guardedSource),
+                  redactor: session.session.redactor,
+                }),
+              );
+            } catch {
+              report(
+                options.onError,
+                historyError(HISTORY_ERROR_CODES.ROTATION),
+              );
+            } finally {
+              rotationBusy = false;
+            }
+          }
+        : undefined,
+    };
+    let store;
+    if (mode === HISTORY_MODES.PERSISTENT) {
+      store = options.stores.createIndexedDbStore({
+        ...options.persistent,
+        ...rotationOptions,
+        databaseName,
+        indexedDB: options.indexedDB,
+        allowUnprotected: false,
+        onStatusChange: () => {
+          if (session?.valid && current === session) notify();
+        },
+      });
+    } else {
+      store = options.stores.createMemoryStore({
+        ...(isStartup
+          ? {
+              defaultMaxSizePerArea:
+                HISTORY_LIMITS.STARTUP_DEFAULT_MAX_SIZE_PER_AREA,
+              maxTotalSize: HISTORY_LIMITS.STARTUP_MAX_TOTAL_SIZE,
+              ...options.startup,
+            }
+          : options.memory),
+        ...rotationOptions,
+      });
+    }
+    if (stopped || lease.signal.aborted) {
+      void retire(ownStore(store), true).catch((failure) => {
+        report(
+          options.onError,
+          historyError(HISTORY_ERROR_CODES.CLEANUP, failure),
+        );
+      });
+      throw historyError(HISTORY_ERROR_CODES.STOPPED);
+    }
+    try {
+      session = createHistorySession({
+        options,
+        store,
+        key,
+        startup: isStartup,
+        isLive: () => !stopped && !lease.signal.aborted,
+        canControl: () => isStartup || state === HISTORY_STATES.ACTIVE,
+        levelStorage: isStartup ? undefined : privateLevels(() => session),
+        trackCleanup,
+      });
+      sessions.add(session);
+      return session;
+    } catch (failure) {
+      void retire(ownStore(store), true);
+      throw block(HISTORY_ERROR_CODES.SETUP, failure);
+    }
+  }
+
+  async function clearDisk() {
+    await drainInvalidSessions();
+    let cleanup;
+    try {
+      cleanup = ownStore(
+        options.stores.createIndexedDbStore({
+          ...options.persistent,
+          databaseName,
+          indexedDB: options.indexedDB,
+          allowUnprotected: false,
+          overflowStrategy: OVERFLOW_STRATEGIES.CYCLE,
+        }),
+      );
+      check();
+      await cleanup.store.clear();
+      check();
+    } finally {
+      await retire(cleanup, true);
+    }
+  }
+
+  async function copySession(source, destination) {
+    await options.stores.copyRecords(source, {
+      write(record) {
+        check();
+        destination.write(record);
+      },
+      async flush() {
+        try {
+          await destination.flush();
+        } catch (failure) {
+          if (destination.getStatus().mode !== STORE_MODES.FALLBACK)
+            throw failure;
+        }
+      },
+    });
+  }
+
+  async function clearAndSave(selectedOwner, mode) {
+    await clearDisk();
+    check();
+    let key;
+    try {
+      if (selectedOwner && mode !== HISTORY_MODES.OFF) key = randomHex(32);
+    } catch {
+      throw block(HISTORY_ERROR_CODES.SETUP);
+    }
+    save({
+      ...metadata,
+      cleanupPending: false,
+      ...(mode === HISTORY_MODES.PERSISTENT && key ? { key } : {}),
+    });
+    return key;
+  }
+
+  async function publish(mode, key, bufferToken, selectedOwner = ownerId) {
+    check();
+    if (mode === HISTORY_MODES.OFF) {
+      ownerId = selectedOwner;
+      state = selectedOwner ? HISTORY_STATES.ACTIVE : HISTORY_STATES.IDLE;
+      notify();
+      return status();
+    }
+    if (mode === HISTORY_MODES.PERSISTENT) await drainInvalidSessions();
+    const candidate = makeSession(mode, key);
+    try {
+      if (startup) {
+        const source = startup;
+        source.paused = true;
+        current = null;
+        notify();
+        try {
+          await copySession(source.store, candidate.store);
+          check();
+          if (bufferToken !== startupEpoch || startup !== source)
+            throw historyError(HISTORY_ERROR_CODES.STALE);
+        } catch {
+          await retire(candidate, true);
+          if (!stopped && source.valid && bufferToken === startupEpoch) {
+            source.paused = false;
+            current = source;
+            state = HISTORY_STATES.IDLE;
+            notify();
+          }
+          throw error(HISTORY_ERROR_CODES.MIGRATION);
+        }
+        await retire(source, true);
+      }
+      check();
+      if (bufferToken !== startupEpoch) {
+        await retire(candidate, true);
+        throw historyError(HISTORY_ERROR_CODES.STALE);
+      }
+      current = candidate;
+      ownerId = selectedOwner;
+      state = HISTORY_STATES.ACTIVE;
+      setupFailure = undefined;
+      notify();
+      return status();
+    } catch (failure) {
+      if (candidate !== current) await retire(candidate, true);
+      throw failure;
+    }
+  }
+
+  async function destructive(
+    selectedOwner,
+    ownerFields,
+    mode,
+    {
+      reset = true,
+      keepStartup = false,
+      logout = false,
+      remainBlocked = false,
+    } = {},
+  ) {
+    const previous = current;
+    const savedLevels = reset ? {} : (metadata?.levels ?? {});
+    state = HISTORY_STATES.TRANSITIONING;
+    if (previous && previous !== startup) {
+      previous.valid = false;
+      current = null;
+    }
+    if (!keepStartup) discardStartup();
+    const bufferToken = startupEpoch;
+    notify();
+    const pending = {
+      version: 1,
+      leaseKey: lease.key,
+      revision: (metadata?.revision ?? 0) + 1,
+      mode,
+      cleanupPending: true,
+      loggedOut: logout || (!selectedOwner && Boolean(metadata?.loggedOut)),
+      ...(selectedOwner || (!logout && ownerFields?.salt) ? ownerFields : {}),
+      ...(!selectedOwner && !logout && !ownerFields?.salt
+        ? { ownerless: true }
+        : {}),
+      levels: savedLevels,
+    };
+    save(pending);
+    requestedMode = mode;
+    if (previous && previous !== startup)
+      await retire(previous, true).catch((failure) => {
+        throw block(HISTORY_ERROR_CODES.CLEANUP, failure);
+      });
+    check();
+    let clean = false;
+    let key;
+    try {
+      key = await clearAndSave(selectedOwner, mode);
+      clean = true;
+    } catch (failure) {
+      check();
+      if (
+        failure.code === HISTORY_ERROR_CODES.METADATA ||
+        failure.code === HISTORY_ERROR_CODES.SETUP
+      )
+        throw failure;
+      error(HISTORY_ERROR_CODES.CLEANUP, failure);
+    }
+    check();
+    if (remainBlocked) {
+      ownerId = selectedOwner;
+      state = HISTORY_STATES.BLOCKED;
+      notify();
+      return status();
+    }
+    if (!selectedOwner || mode === HISTORY_MODES.OFF) {
+      ownerId = selectedOwner;
+      state = selectedOwner ? HISTORY_STATES.ACTIVE : HISTORY_STATES.IDLE;
+      notify();
+      return status();
+    }
+    return publish(
+      clean ? mode : HISTORY_MODES.MEMORY,
+      key,
+      bufferToken,
+      selectedOwner,
+    );
+  }
+
+  async function resume(id) {
+    const bufferToken = startupEpoch;
+    if (state === HISTORY_STATES.ACTIVE && ownerId && ownerId !== id)
+      throw error(HISTORY_ERROR_CODES.STALE);
+    if (ownerId === id && state === HISTORY_STATES.ACTIVE) {
+      if (metadata.cleanupPending) return retryCleanup();
+      return status();
+    }
+    const saved = read();
+    let fields;
+    try {
+      fields = await digestOwner(id, saved?.salt);
+    } catch {
+      throw block(HISTORY_ERROR_CODES.SETUP);
+    }
+    check();
+    if (bufferToken !== startupEpoch)
+      throw historyError(HISTORY_ERROR_CODES.STALE);
+    if (
+      saved &&
+      (saved.loggedOut ||
+        (!saved.ownerless && saved.ownerDigest !== fields.ownerDigest))
+    ) {
+      if (!ownerId) state = HISTORY_STATES.STALE;
+      notify();
+      throw error(HISTORY_ERROR_CODES.STALE);
+    }
+    if (
+      !saved ||
+      saved.ownerless ||
+      saved.cleanupPending ||
+      saved.mode !== HISTORY_MODES.PERSISTENT ||
+      !saved.key
+    )
+      return destructive(id, fields, requestedMode, {
+        reset: false,
+        keepStartup: true,
+      });
+    return publish(requestedMode, saved.key, startupEpoch, id);
+  }
+
+  async function setOwner(id) {
+    if (ownerId === id && state === HISTORY_STATES.ACTIVE) return status();
+    if (state === HISTORY_STATES.BLOCKED) read();
+    const bufferToken = startupEpoch;
+    let fields;
+    try {
+      fields = await digestOwner(id);
+    } catch {
+      throw block(HISTORY_ERROR_CODES.SETUP);
+    }
+    check();
+    if (bufferToken !== startupEpoch)
+      throw historyError(HISTORY_ERROR_CODES.STALE);
+    return destructive(id, fields, requestedMode, {
+      keepStartup: Boolean(startup) && (!ownerId || ownerId === id),
+    });
+  }
+
+  async function retryCleanup() {
+    if (!metadata?.cleanupPending) return status();
+    const previousState = state;
+    state = HISTORY_STATES.TRANSITIONING;
+    notify();
+    let key;
+    try {
+      key = await clearAndSave(ownerId, requestedMode);
+    } catch (failure) {
+      check();
+      if (
+        failure.code === HISTORY_ERROR_CODES.METADATA ||
+        failure.code === HISTORY_ERROR_CODES.SETUP
+      )
+        throw failure;
+      state = previousState;
+      notify();
+      error(HISTORY_ERROR_CODES.CLEANUP, failure);
+      return status();
+    }
+    check();
+    const previous = current;
+    if (previous && previous !== startup) await retire(previous, true);
+    check();
+    if (!ownerId || previousState === HISTORY_STATES.BLOCKED) {
+      state =
+        previousState === HISTORY_STATES.BLOCKED
+          ? HISTORY_STATES.BLOCKED
+          : HISTORY_STATES.IDLE;
+      notify();
+      return status();
+    }
+    return publish(requestedMode, key, startupEpoch, ownerId);
+  }
+
+  async function setMode(mode) {
+    if (state === HISTORY_STATES.BLOCKED)
+      throw historyError(setupFailure ?? HISTORY_ERROR_CODES.METADATA);
+    if (state === HISTORY_STATES.STALE)
+      throw historyError(HISTORY_ERROR_CODES.STALE);
+    if (mode === requestedMode) return status();
+    if (!ownerId) {
+      if (mode === HISTORY_MODES.OFF)
+        return destructive(
+          undefined,
+          { salt: metadata?.salt, ownerDigest: metadata?.ownerDigest },
+          mode,
+        );
+      requestedMode = mode;
+      save({
+        ...(metadata ?? {
+          version: 1,
+          leaseKey: lease.key,
+          revision: 1,
+          ownerless: true,
+          loggedOut: false,
+          cleanupPending: false,
+          levels: {},
+        }),
+        mode,
+      });
+      notify();
+      return status();
+    }
+    if (
+      requestedMode === HISTORY_MODES.MEMORY &&
+      mode === HISTORY_MODES.PERSISTENT &&
+      !metadata.cleanupPending &&
+      current
+    ) {
+      const previous = current;
+      state = HISTORY_STATES.TRANSITIONING;
+      notify();
+      let candidate;
+      let detach;
+      try {
+        await clearDisk();
+        check();
+        candidate = makeSession(mode, previous.key);
+        detach = previous.hub.addSink(candidate.store);
+        await copySession(previous.store, candidate.store);
+        check();
+        save({ ...metadata, mode, key: previous.key });
+        requestedMode = mode;
+        detach();
+        previous.valid = false;
+        current = candidate;
+      } catch (failure) {
+        detach?.();
+        if (candidate)
+          await retire(candidate, true).catch(() =>
+            error(HISTORY_ERROR_CODES.SETUP),
+          );
+        if (!stopped && state !== HISTORY_STATES.BLOCKED) {
+          current = previous;
+          state = HISTORY_STATES.ACTIVE;
+          notify();
+        }
+        throw failure.code === 'metadata' ||
+          failure.code === HISTORY_ERROR_CODES.SETUP ||
+          stopped ||
+          state === HISTORY_STATES.BLOCKED
+          ? failure
+          : error(HISTORY_ERROR_CODES.MIGRATION);
+      }
+      await retire(previous, true).catch(() =>
+        error(HISTORY_ERROR_CODES.CLEANUP),
+      );
+      check();
+      state = HISTORY_STATES.ACTIVE;
+      notify();
+      return status();
+    }
+    return destructive(
+      ownerId,
+      { salt: metadata.salt, ownerDigest: metadata.ownerDigest },
+      mode,
+      { reset: mode === HISTORY_MODES.OFF },
+    );
+  }
+  const enqueue = (action, argument, validate) => {
+    if (validate && !validate(argument))
+      return Promise.reject(new TypeError('Invalid history control argument'));
+    if (stopped)
+      return Promise.reject(historyError(HISTORY_ERROR_CODES.STOPPED));
+    const operation = controlQueue.then(async () => {
+      check();
+      if (state === HISTORY_STATES.BLOCKED && action !== setMode)
+        try {
+          await drainInvalidSessions();
+        } catch (failure) {
+          check();
+          throw error(HISTORY_ERROR_CODES.CLEANUP, failure);
+        }
+      return action(argument);
+    });
+    controlQueue = operation.catch(() => {});
+    return operation;
+  };
+
+  function forward(area, scope, binding, invalid) {
+    const logger = {};
+    for (const level of Object.values(LEVELS))
+      logger[level] = (message, data) => {
+        const selected = current;
+        if (
+          forwarding ||
+          !selected?.valid ||
+          selected.paused ||
+          stopped ||
+          lease.signal.aborted
+        )
+          return;
+        forwarding = true;
+        try {
+          if (invalid) throw invalid.error;
+          let target = selected.session.logging.getLogger(area, scope);
+          if (binding) target = target.child(binding);
+          target[level](message, data);
+        } catch (failure) {
+          report(options.logging.onError, failure, LOGGING_ERROR_SOURCES.DATA);
+        } finally {
+          forwarding = false;
+        }
+      };
+    logger.child = (child = {}) => {
+      if (invalid) return forward(area, scope, binding, invalid);
+      try {
+        const {
+          scope: childScope = binding ? binding.scope : scope,
+          context = {},
+        } = child;
+        return forward(area, scope, {
+          scope: childScope,
+          context: { ...binding?.context, ...copyBindings(context) },
+        });
+      } catch (failure) {
+        return forward(area, scope, binding, { error: failure });
+      }
+    };
+    return Object.freeze(logger);
+  }
+
+  function stop() {
+    if (stopPromise) return stopPromise;
+    stopped = true;
+    state = HISTORY_STATES.STOPPED;
+    lease.signal.removeEventListener('abort', abort);
+    current = null;
+    const unexpected =
+      lease.signal.aborted &&
+      !['release', 'pagehide', 'stop'].includes(lease.signal.reason);
+    discardStartup();
+    for (const session of sessions)
+      void retire(
+        session,
+        unexpected || session.startup || session.discardOnStop,
+      );
+    stopPromise = Promise.resolve()
+      .then(async () => {
+        await controlQueue;
+        const cleanups = Array.from(sessions, (session) =>
+          retire(
+            session,
+            unexpected || session.startup || session.discardOnStop,
+          ),
+        );
+        await Promise.all([...retired, ...cleanups]);
+      })
+      .catch((failure) => {
+        stopPromise = undefined;
+        throw failure;
+      });
+    notify();
+    return stopPromise;
+  }
+
+  function abort() {
+    void stop().catch((failure) => error(HISTORY_ERROR_CODES.SETUP, failure));
+  }
+  lease.signal.addEventListener('abort', abort, { once: true });
+  try {
+    read();
+    if (requestedMode !== HISTORY_MODES.OFF && options.startup !== false) {
+      startup = makeSession(HISTORY_MODES.MEMORY, randomHex(32), true);
+      current = startup;
+    }
+  } catch {
+    if (state !== HISTORY_STATES.BLOCKED) block(HISTORY_ERROR_CODES.SETUP);
+  }
+  const api = Object.freeze({
+    getLogger(area, scope) {
+      if (!areas.has(area) || typeof scope !== 'string')
+        throw new TypeError('Invalid logger area or scope');
+      const key = JSON.stringify([area, scope]);
+      const cached = roots.get(key);
+      if (cached) return cached;
+      const logger = forward(area, scope);
+      if (roots.size < LOGGING_LIMITS.ROOT_LOGGER_CACHE_PAIRS) {
+        roots.set(key, logger);
+        return logger;
+      }
+      if (!rootLoggerLimitReported) {
+        rootLoggerLimitReported = true;
+        report(
+          options.logging.onError,
+          loggingError(LOGGING_ERROR_CODES.ROOT_LOGGER_CACHE_LIMIT),
+          LOGGING_ERROR_SOURCES.SCOPE,
+        );
+      }
+      return logger;
+    },
+    resume: (id) =>
+      enqueue(
+        resume,
+        id,
+        (value) => typeof value === 'string' && value.length > 0,
+      ),
+    setOwner: (id) =>
+      enqueue(
+        setOwner,
+        id,
+        (value) => typeof value === 'string' && value.length > 0,
+      ),
+    logout() {
+      discardStartup();
+      return enqueue(async () => {
+        if (state === HISTORY_STATES.BLOCKED) read();
+        return destructive(undefined, {}, requestedMode, { logout: true });
+      });
+    },
+
+    setMode(mode) {
+      if (mode === HISTORY_MODES.OFF) discardStartup();
+      return enqueue(setMode, mode, (value) =>
+        [
+          HISTORY_MODES.OFF,
+          HISTORY_MODES.MEMORY,
+          HISTORY_MODES.PERSISTENT,
+        ].includes(value),
+      );
+    },
+
+    clear() {
+      discardStartup();
+      return enqueue(async () => {
+        if (state === HISTORY_STATES.STALE)
+          throw historyError(HISTORY_ERROR_CODES.STALE);
+        const remainBlocked = state === HISTORY_STATES.BLOCKED;
+        if (remainBlocked) read();
+        return destructive(
+          ownerId,
+          { salt: metadata?.salt, ownerDigest: metadata?.ownerDigest },
+          requestedMode,
+          { remainBlocked },
+        );
+      });
+    },
+    retryCleanup: () =>
+      enqueue(async () => {
+        if (state === HISTORY_STATES.STALE)
+          throw historyError(HISTORY_ERROR_CODES.STALE);
+        if (state === HISTORY_STATES.BLOCKED) read();
+        return retryCleanup();
+      }),
+    getSession: () =>
+      current?.valid && !current.paused ? current.session : null,
+    getStatus: status,
+    stop,
+  });
+  notify();
+  return api;
+}
+
+export { createLogHistory };
+//# sourceMappingURL=index.js.map