stitchkit 0.77.0 → 0.78.0

package/dist/application-diagnostic-journal.js

@@ -0,0 +1,714 @@
+import {
+  createBoundedChannel
+} from "./index-n1g2xm6a.js";
+import {
+  isRecord
+} from "./index-qyrqwr4c.js";
+
+// src/application/diagnostic-journal.ts
+import { randomUUID } from "node:crypto";
+
+// src/application/diagnostic-journal-contract.ts
+import { z } from "zod";
+var PositiveSafeIntegerSchema = z.number().int().positive().safe();
+var FileModeSchema = z.number().int().min(0).max(511);
+var DiagnosticJournalLimitsSchema = z.object({
+  maxEventBytes: PositiveSafeIntegerSchema,
+  maxPendingItems: PositiveSafeIntegerSchema,
+  maxPendingBytes: PositiveSafeIntegerSchema,
+  maxFileBytes: PositiveSafeIntegerSchema,
+  maxFiles: PositiveSafeIntegerSchema
+}).strict().readonly();
+var DiagnosticJournalLockPolicySchema = z.enum(["refuse", "reclaim-stale"]);
+var DiagnosticJournalStateSchema = z.enum(["open", "draining", "closed", "failed"]);
+var DiagnosticJournalRefusalReasonSchema = z.enum([
+  "closed",
+  "failed",
+  "invalid",
+  "oversized",
+  "item-capacity",
+  "byte-capacity"
+]);
+var DiagnosticJournalRefusalCountersSchema = z.object({
+  closed: z.number().int().nonnegative(),
+  failed: z.number().int().nonnegative(),
+  invalid: z.number().int().nonnegative(),
+  oversized: z.number().int().nonnegative(),
+  "item-capacity": z.number().int().nonnegative(),
+  "byte-capacity": z.number().int().nonnegative()
+}).strict().readonly();
+var DiagnosticJournalFailurePhaseSchema = z.enum(["write", "rotation", "close"]);
+var DiagnosticJournalStatusSchema = z.object({
+  state: DiagnosticJournalStateSchema,
+  epoch: z.uuid(),
+  limits: DiagnosticJournalLimitsSchema,
+  lock: z.object({
+    policy: DiagnosticJournalLockPolicySchema,
+    reclaimedStale: z.boolean()
+  }).strict().readonly(),
+  received: z.number().int().nonnegative(),
+  accepted: z.number().int().nonnegative(),
+  refused: z.number().int().nonnegative(),
+  refusals: DiagnosticJournalRefusalCountersSchema,
+  written: z.number().int().nonnegative(),
+  failedRecords: z.number().int().nonnegative(),
+  pendingItems: z.number().int().nonnegative(),
+  pendingBytes: z.number().int().nonnegative(),
+  inFlight: z.boolean(),
+  rotations: z.number().int().nonnegative(),
+  rotationFailures: z.number().int().nonnegative(),
+  partialTails: z.number().int().nonnegative(),
+  currentFileBytes: z.number().int().nonnegative(),
+  retainedFiles: z.number().int().nonnegative(),
+  lastAcceptedSequence: z.number().int().positive().optional(),
+  lastWrittenSequence: z.number().int().positive().optional(),
+  lastSettledSequence: z.number().int().positive().optional(),
+  lastFailure: z.object({
+    phase: DiagnosticJournalFailurePhaseSchema,
+    sequence: z.number().int().positive().optional()
+  }).strict().readonly().optional()
+}).strict().readonly();
+var DiagnosticJournalSubmitResultSchema = z.discriminatedUnion("outcome", [
+  z.object({
+    outcome: z.literal("accepted"),
+    epoch: z.uuid(),
+    sequence: z.number().int().positive()
+  }).strict().readonly(),
+  z.object({
+    outcome: z.literal("refused"),
+    reason: DiagnosticJournalRefusalReasonSchema
+  }).strict().readonly()
+]);
+var DiagnosticJournalWaitResultSchema = z.object({
+  outcome: z.enum(["settled", "timed-out", "cancelled"]),
+  state: DiagnosticJournalStateSchema,
+  throughSequence: z.number().int().nonnegative(),
+  settledSequence: z.number().int().nonnegative()
+}).strict().readonly();
+var DiagnosticJournalCloseResultSchema = z.object({
+  outcome: z.enum(["closed", "timed-out", "cancelled"]),
+  state: DiagnosticJournalStateSchema,
+  pendingItems: z.number().int().nonnegative()
+}).strict().readonly();
+var DiagnosticJournalFrameSchema = z.object({
+  schemaVersion: z.literal(1),
+  epoch: z.uuid(),
+  sequence: z.number().int().positive(),
+  event: z.json()
+}).strict().readonly();
+function parseDiagnosticJournalMode(mode) {
+  return FileModeSchema.parse(mode ?? 384);
+}
+
+// src/application/diagnostic-journal-manager.ts
+import { z as z2 } from "zod";
+
+// src/application/diagnostic-journal-storage.ts
+import { constants as constants2 } from "node:fs";
+import { lstat, open as open2, readdir, realpath, rename, unlink as unlink2 } from "node:fs/promises";
+import { basename, dirname, isAbsolute, resolve } from "node:path";
+
+// src/application/diagnostic-journal-lock.ts
+import { execFile } from "node:child_process";
+import { constants } from "node:fs";
+import { open, readFile, unlink } from "node:fs/promises";
+import { hostname, platform } from "node:os";
+import { promisify } from "node:util";
+function isExisting(error) {
+  return isRecord(error) && error.code === "EEXIST";
+}
+function readOwner(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return;
+  }
+  if (!isRecord(parsed))
+    return;
+  const { pid, host, acquiredAt, machine } = parsed;
+  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
+    return;
+  if (typeof host !== "string" || host.length === 0)
+    return;
+  if (typeof acquiredAt !== "string")
+    return;
+  const identified = typeof machine === "string" && machine.length > 0 ? { machine } : {};
+  return { pid, host, acquiredAt, ...identified };
+}
+var detectedIdentity;
+async function firstReadableLine(paths) {
+  for (const path of paths) {
+    try {
+      const text = (await readFile(path, "utf8")).trim();
+      if (text.length > 0)
+        return text;
+    } catch {}
+  }
+  return null;
+}
+var run = promisify(execFile);
+function parsePlatformUuid(dump) {
+  return /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(dump)?.[1] ?? null;
+}
+async function readDarwinPlatformUuid(command = "ioreg") {
+  try {
+    const { stdout } = await run(command, ["-rd1", "-c", "IOPlatformExpertDevice"], {
+      timeout: 2000,
+      maxBuffer: 1 << 20,
+      encoding: "utf8"
+    });
+    return parsePlatformUuid(stdout);
+  } catch {
+    return null;
+  }
+}
+async function machineIdentity(declared) {
+  if (declared !== undefined)
+    return declared;
+  if (detectedIdentity !== undefined)
+    return detectedIdentity;
+  detectedIdentity = platform() === "darwin" ? await readDarwinPlatformUuid() : await firstReadableLine(["/etc/machine-id", "/var/lib/dbus/machine-id"]);
+  return detectedIdentity;
+}
+function attribute(owner, identity) {
+  if (identity !== null && owner.machine !== undefined) {
+    return owner.machine === identity ? "this-machine" : "another-machine";
+  }
+  return owner.host === hostname() ? "this-machine" : "unattributable";
+}
+async function probeLiveness(owner) {
+  try {
+    process.kill(owner.pid, 0);
+  } catch (error) {
+    return isRecord(error) && error.code === "ESRCH" ? "gone" : "alive";
+  }
+  return await isZombieProcess(owner.pid) ? "gone" : "alive";
+}
+async function isZombieProcess(pid, seam = {}) {
+  const { procRoot = "/proc", psCommand = "ps" } = seam;
+  try {
+    const stat = await readFile(`${procRoot}/${pid}/stat`, "utf8");
+    return stat.slice(stat.lastIndexOf(")") + 1).trimStart().startsWith("Z");
+  } catch {}
+  try {
+    const { stdout } = await run(psCommand, ["-o", "state=", "-p", String(pid)], {
+      timeout: 2000,
+      maxBuffer: 1 << 16,
+      encoding: "utf8"
+    });
+    return stdout.trim().startsWith("Z");
+  } catch {
+    return false;
+  }
+}
+async function diagnose(owner, declaredIdentity) {
+  if (!owner)
+    return { attribution: "unattributable", liveness: "not-probed", owner: null };
+  const attribution = attribute(owner, await machineIdentity(declaredIdentity));
+  const record = {
+    pid: owner.pid,
+    host: owner.host,
+    acquiredAt: owner.acquiredAt,
+    ...owner.machine !== undefined && { machine: owner.machine }
+  };
+  if (attribution !== "this-machine")
+    return { attribution, liveness: "not-probed", owner: record };
+  return { attribution, liveness: await probeLiveness(owner), owner: record };
+}
+async function readLockOwner(lockPath) {
+  let handle;
+  try {
+    handle = await open(lockPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    return readOwner(await handle.readFile("utf8"));
+  } catch {
+    return;
+  } finally {
+    await handle?.close().catch(() => {
+      return;
+    });
+  }
+}
+async function createExclusive(lockPath, mode, declaredIdentity) {
+  const handle = await open(lockPath, "wx", mode);
+  const identity = await machineIdentity(declaredIdentity);
+  const owner = {
+    pid: process.pid,
+    host: hostname(),
+    acquiredAt: new Date().toISOString(),
+    ...identity !== null && { machine: identity }
+  };
+  await handle.writeFile(`${JSON.stringify(owner)}
+`, "utf8");
+  return handle;
+}
+async function acquireDiagnosticJournalLock(lockPath, mode, policy, declaredIdentity) {
+  try {
+    return {
+      handle: await createExclusive(lockPath, mode, declaredIdentity),
+      reclaimedStale: false
+    };
+  } catch (error) {
+    if (policy !== "reclaim-stale" || !isExisting(error))
+      throw error;
+    const owner = await readLockOwner(lockPath);
+    const diagnosis = await diagnose(owner, declaredIdentity);
+    if (!owner || diagnosis.liveness !== "gone") {
+      if (isRecord(error))
+        Object.assign(error, { journalLock: diagnosis });
+      throw error;
+    }
+    await unlink(lockPath).catch(() => {
+      return;
+    });
+    return {
+      handle: await createExclusive(lockPath, mode, declaredIdentity),
+      reclaimedStale: true
+    };
+  }
+}
+
+// src/application/diagnostic-journal-storage.ts
+class DiagnosticJournalStorageError extends Error {
+  phase;
+  constructor(phase, message, options) {
+    super(message, options);
+    this.phase = phase;
+    this.name = "DiagnosticJournalStorageError";
+  }
+}
+function isMissing(error) {
+  return isRecord(error) && error.code === "ENOENT";
+}
+async function removeIfPresent(path) {
+  try {
+    const info = await lstat(path);
+    if (info.isSymbolicLink() || !info.isFile()) {
+      throw new Error("Diagnostic journal generations must be regular files");
+    }
+    await unlink2(path);
+  } catch (error) {
+    if (!isMissing(error))
+      throw error;
+  }
+}
+async function moveIfPresent(from, to) {
+  try {
+    const info = await lstat(from);
+    if (info.isSymbolicLink() || !info.isFile()) {
+      throw new Error("Diagnostic journal generations must be regular files");
+    }
+    await rename(from, to);
+    return true;
+  } catch (error) {
+    if (isMissing(error))
+      return false;
+    throw error;
+  }
+}
+function generation(path, index) {
+  return `${path}.${index}`;
+}
+function generationIndex(name, prefix) {
+  if (!name.startsWith(prefix))
+    return;
+  const suffix = name.slice(prefix.length);
+  if (!/^\d+$/.test(suffix))
+    return;
+  const value = Number(suffix);
+  return Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+async function createRotatingDiagnosticJournalStorage(config) {
+  if (!isAbsolute(config.path) || resolve(config.path) !== config.path) {
+    throw new TypeError("Diagnostic journal path must be normalized and absolute");
+  }
+  const parent = await realpath(dirname(config.path));
+  const journalPath = resolve(parent, basename(config.path));
+  const lockPath = `${journalPath}.lock`;
+  const { handle: lock, reclaimedStale } = await acquireDiagnosticJournalLock(lockPath, config.mode, config.lock, config.machineIdentity);
+  let handle;
+  let currentFileBytes = 0;
+  let retainedFiles = 1;
+  let rotations = 0;
+  let partialTails = 0;
+  let closed = false;
+  const openCurrent = async () => {
+    handle = await open2(journalPath, constants2.O_APPEND | constants2.O_CREAT | constants2.O_RDWR | constants2.O_NOFOLLOW, config.mode);
+    const info = await handle.stat();
+    if (!info.isFile()) {
+      await handle.close();
+      handle = undefined;
+      throw new Error("Diagnostic journal path must be a regular file");
+    }
+    currentFileBytes = Number(info.size);
+  };
+  const rotate = async () => {
+    try {
+      await handle?.close();
+      handle = undefined;
+      if (config.maxFiles === 1) {
+        await removeIfPresent(journalPath);
+      } else {
+        await removeIfPresent(generation(journalPath, config.maxFiles - 1));
+        for (let index = config.maxFiles - 2;index >= 1; index -= 1) {
+          await moveIfPresent(generation(journalPath, index), generation(journalPath, index + 1));
+        }
+        await moveIfPresent(journalPath, generation(journalPath, 1));
+      }
+      retainedFiles = Math.min(config.maxFiles, retainedFiles + 1);
+      rotations += 1;
+      await openCurrent();
+    } catch (error) {
+      throw new DiagnosticJournalStorageError("rotation", "Diagnostic journal rotation failed", { cause: error });
+    }
+  };
+  try {
+    const names = await readdir(parent);
+    const prefix = `${basename(journalPath)}.`;
+    let existingGenerations = 0;
+    for (const name of names) {
+      const index = generationIndex(name, prefix);
+      if (index === undefined)
+        continue;
+      if (index >= config.maxFiles) {
+        await removeIfPresent(resolve(parent, name));
+      } else {
+        const info = await lstat(resolve(parent, name));
+        if (info.isSymbolicLink() || !info.isFile()) {
+          throw new Error("Diagnostic journal generations must be regular files");
+        }
+        existingGenerations += 1;
+      }
+    }
+    retainedFiles = Math.min(config.maxFiles, existingGenerations + 1);
+    await openCurrent();
+    if (currentFileBytes > 0) {
+      const tail = new Uint8Array(1);
+      const read = await handle?.read(tail, 0, 1, currentFileBytes - 1);
+      if (read?.bytesRead === 1 && tail[0] !== 10) {
+        partialTails += 1;
+        await rotate();
+      }
+    }
+  } catch (error) {
+    await handle?.close().catch(() => {
+      return;
+    });
+    await lock.close().catch(() => {
+      return;
+    });
+    await unlink2(lockPath).catch(() => {
+      return;
+    });
+    throw error;
+  }
+  const snapshot = () => ({
+    currentFileBytes,
+    retainedFiles,
+    rotations,
+    partialTails
+  });
+  return {
+    reclaimedStale,
+    async append(bytes) {
+      if (closed || !handle) {
+        throw new DiagnosticJournalStorageError("write", "Diagnostic journal storage is closed");
+      }
+      let rotated = false;
+      if (currentFileBytes > 0 && currentFileBytes + bytes.byteLength > config.maxFileBytes) {
+        await rotate();
+        rotated = true;
+      }
+      try {
+        await handle.writeFile(bytes);
+        currentFileBytes += bytes.byteLength;
+        return { ...snapshot(), rotated };
+      } catch (error) {
+        throw new DiagnosticJournalStorageError("write", "Diagnostic journal write failed", {
+          cause: error
+        });
+      }
+    },
+    snapshot,
+    async close() {
+      if (closed)
+        return;
+      closed = true;
+      let failure;
+      try {
+        await handle?.close();
+      } catch (error) {
+        failure = error;
+      }
+      try {
+        await lock.close();
+        await unlink2(lockPath);
+      } catch (error) {
+        failure ??= error;
+      }
+      if (failure !== undefined) {
+        throw new DiagnosticJournalStorageError("close", "Diagnostic journal close failed", {
+          cause: failure
+        });
+      }
+    }
+  };
+}
+
+// src/application/diagnostic-journal-manager.ts
+function waitBudget(options) {
+  if (options.timeoutMs === undefined)
+    return;
+  if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs <= 0) {
+    throw new TypeError("Diagnostic journal timeoutMs must be a positive safe integer");
+  }
+  return options.timeoutMs;
+}
+function createDiagnosticJournalManager(config, storage) {
+  const limits = DiagnosticJournalLimitsSchema.parse(config.limits);
+  const encoder = new TextEncoder;
+  const channel = createBoundedChannel({
+    policy: "ordered",
+    maxItems: limits.maxPendingItems,
+    maxBytes: limits.maxPendingBytes,
+    sizeOf: (frame) => frame.bytes.byteLength
+  });
+  const refusals = {
+    closed: 0,
+    failed: 0,
+    invalid: 0,
+    oversized: 0,
+    "item-capacity": 0,
+    "byte-capacity": 0
+  };
+  const progressWaiters = new Set;
+  let state = "open";
+  let received = 0;
+  let accepted = 0;
+  let refused = 0;
+  let written = 0;
+  let failedRecords = 0;
+  let pendingItems = 0;
+  let pendingBytes = 0;
+  let inFlight = false;
+  let rotationFailures = 0;
+  let lastAcceptedSequence = 0;
+  let lastWrittenSequence = 0;
+  let lastSettledSequence = 0;
+  let lastFailure;
+  let physicalClosed = false;
+  const isFailed = () => state === "failed";
+  const notifyProgress = () => {
+    for (const waiter of progressWaiters)
+      waiter();
+  };
+  const reportFailure = (failure) => {
+    if (!config.onFailure)
+      return;
+    Promise.resolve().then(() => config.onFailure?.(failure)).catch(() => {
+      return;
+    });
+  };
+  const markFailure = (error, fallbackPhase, sequence) => {
+    const phase = error instanceof DiagnosticJournalStorageError ? error.phase : fallbackPhase;
+    if (phase === "rotation")
+      rotationFailures += 1;
+    lastFailure = { phase, ...sequence !== undefined && { sequence } };
+    state = "failed";
+    channel.close({ mode: "drain" });
+    reportFailure({ phase, error, ...sequence !== undefined && { sequence } });
+  };
+  const worker = (async () => {
+    for await (const frame of channel) {
+      inFlight = true;
+      if (isFailed()) {
+        failedRecords += 1;
+      } else {
+        try {
+          await storage.append(frame.bytes);
+          written += 1;
+          lastWrittenSequence = frame.sequence;
+        } catch (error) {
+          failedRecords += 1;
+          markFailure(error, "write", frame.sequence);
+        }
+      }
+      pendingItems -= 1;
+      pendingBytes -= frame.bytes.byteLength;
+      lastSettledSequence = frame.sequence;
+      inFlight = false;
+      notifyProgress();
+    }
+    try {
+      await storage.close();
+    } catch (error) {
+      markFailure(error, "close");
+    }
+    physicalClosed = true;
+    if (!isFailed())
+      state = "closed";
+    notifyProgress();
+  })();
+  worker.catch((error) => {
+    markFailure(error, "close");
+    physicalClosed = true;
+    notifyProgress();
+  });
+  const refuse = (reason) => {
+    refused += 1;
+    refusals[reason] += 1;
+    return DiagnosticJournalSubmitResultSchema.parse({ outcome: "refused", reason });
+  };
+  const waitUntil = (predicate, options) => {
+    const timeoutMs = waitBudget(options);
+    if (predicate())
+      return Promise.resolve("settled");
+    if (options.signal?.aborted)
+      return Promise.resolve("cancelled");
+    return new Promise((resolve2) => {
+      let settled = false;
+      let timer;
+      const finish = (outcome) => {
+        if (settled)
+          return;
+        settled = true;
+        progressWaiters.delete(onProgress);
+        options.signal?.removeEventListener("abort", onAbort);
+        if (timer)
+          clearTimeout(timer);
+        resolve2(outcome);
+      };
+      const onProgress = () => {
+        if (predicate())
+          finish("settled");
+      };
+      const onAbort = () => finish("cancelled");
+      progressWaiters.add(onProgress);
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+      if (timeoutMs !== undefined)
+        timer = setTimeout(() => finish("timed-out"), timeoutMs);
+      onProgress();
+    });
+  };
+  const getStatus = () => {
+    const file = storage.snapshot();
+    return DiagnosticJournalStatusSchema.parse({
+      state,
+      epoch: config.epoch,
+      limits,
+      lock: config.lock,
+      received,
+      accepted,
+      refused,
+      refusals,
+      written,
+      failedRecords,
+      pendingItems,
+      pendingBytes,
+      inFlight,
+      rotations: file.rotations,
+      rotationFailures,
+      partialTails: file.partialTails,
+      currentFileBytes: file.currentFileBytes,
+      retainedFiles: file.retainedFiles,
+      ...lastAcceptedSequence > 0 && { lastAcceptedSequence },
+      ...lastWrittenSequence > 0 && { lastWrittenSequence },
+      ...lastSettledSequence > 0 && { lastSettledSequence },
+      ...lastFailure && { lastFailure }
+    });
+  };
+  return {
+    submit(event) {
+      received += 1;
+      if (state === "failed")
+        return refuse("failed");
+      if (state !== "open")
+        return refuse("closed");
+      const parsed = config.eventSchema.safeParse(event);
+      if (!parsed.success)
+        return refuse("invalid");
+      const json = z2.json().safeParse(parsed.data);
+      if (!json.success)
+        return refuse("invalid");
+      const payload = encoder.encode(JSON.stringify(json.data));
+      if (payload.byteLength > limits.maxEventBytes)
+        return refuse("oversized");
+      if (pendingItems >= limits.maxPendingItems)
+        return refuse("item-capacity");
+      const sequence = lastAcceptedSequence + 1;
+      const frame = DiagnosticJournalFrameSchema.parse({
+        schemaVersion: 1,
+        epoch: config.epoch,
+        sequence,
+        event: json.data
+      });
+      const bytes = encoder.encode(`${JSON.stringify(frame)}
+`);
+      if (bytes.byteLength > limits.maxFileBytes)
+        return refuse("oversized");
+      if (pendingBytes + bytes.byteLength > limits.maxPendingBytes) {
+        return refuse("byte-capacity");
+      }
+      const offered = channel.offer({ sequence, bytes });
+      if (offered.outcome === "refused") {
+        return refuse(offered.reason === "not-open" ? "closed" : "item-capacity");
+      }
+      accepted += 1;
+      pendingItems += 1;
+      pendingBytes += bytes.byteLength;
+      lastAcceptedSequence = sequence;
+      return DiagnosticJournalSubmitResultSchema.parse({
+        outcome: "accepted",
+        epoch: config.epoch,
+        sequence
+      });
+    },
+    async flush(options = {}) {
+      const throughSequence = lastAcceptedSequence;
+      const outcome = await waitUntil(() => lastSettledSequence >= throughSequence, options);
+      return DiagnosticJournalWaitResultSchema.parse({
+        outcome,
+        state,
+        throughSequence,
+        settledSequence: lastSettledSequence
+      });
+    },
+    getStatus,
+    async close(options = {}) {
+      if (state === "open") {
+        state = "draining";
+        channel.close({ mode: "drain" });
+      }
+      const wait = await waitUntil(() => physicalClosed, options);
+      return DiagnosticJournalCloseResultSchema.parse({
+        outcome: wait === "settled" ? "closed" : wait,
+        state,
+        pendingItems
+      });
+    }
+  };
+}
+
+// src/application/diagnostic-journal.ts
+async function createDiagnosticJournal(config) {
+  const limits = DiagnosticJournalLimitsSchema.parse(config.limits);
+  const lock = DiagnosticJournalLockPolicySchema.parse(config.lock ?? "refuse");
+  const storage = await createRotatingDiagnosticJournalStorage({
+    path: config.path,
+    maxFileBytes: limits.maxFileBytes,
+    maxFiles: limits.maxFiles,
+    mode: parseDiagnosticJournalMode(config.mode),
+    lock,
+    ...config.machineIdentity !== undefined && { machineIdentity: config.machineIdentity }
+  });
+  return createDiagnosticJournalManager({
+    eventSchema: config.eventSchema,
+    epoch: randomUUID(),
+    limits,
+    lock: { policy: lock, reclaimedStale: storage.reclaimedStale },
+    ...config.onFailure && { onFailure: config.onFailure }
+  }, storage);
+}
+export {
+  createDiagnosticJournal
+};