akanjs 3.0.0-beta.2 → 3.0.0-beta.21

package/server/imageOptimizer.ts

@@ -61,6 +61,7 @@ export class ImageOptimizer {
   static readonly #avif = "image/avif";
   static readonly #heic = "image/heic";
   static readonly #bypassTypes = new Set(["image/x-icon", "image/x-icns", "image/bmp", "image/jxl", "image/heic"]);
+  static readonly #encodableTypes = new Set(["image/jpeg", "image/png", "image/webp", "image/avif"]);
 
   #publicDir: string;
   #cacheDir: string;
@@ -84,20 +85,10 @@ export class ImageOptimizer {
     this.#semaphore = new Semaphore(ImageOptimizer.#resolveConcurrency(this.#config.maxConcurrency));
   }
 
-  /**
-   * Bun.Image encodes on the worker pool that fs, hashing and every other off-thread call also queue on, and the
-   * pool is sized by the CPU count Bun sees — 1 under a container `cpu` limit. Holding image work to half the
-   * slots leaves a stat or a bcrypt waiting behind a couple of encodes instead of behind the whole flood.
-   */
   static #resolveConcurrency(configured: number): number {
     return configured > 0 ? configured : Math.max(1, Math.floor(navigator.hardwareConcurrency / 2));
   }
 
-  /**
-   * AVIF, HEIC and TIFF ride the OS codec, which only the `system` backend has — macOS and Windows.
-   * A Linux container runs the `bun` backend, where both encode and decode raise
-   * `ERR_IMAGE_FORMAT_UNSUPPORTED`, so those types are decided up front rather than thrown at.
-   */
   static #isCodecAvailable(contentType: string): boolean {
     if (contentType !== ImageOptimizer.#avif && contentType !== ImageOptimizer.#heic && contentType !== "image/tiff")
       return true;
@@ -117,10 +108,6 @@ export class ImageOptimizer {
     }
   }
 
-  /**
-   * A cold `srcSet` puts the same width in flight several times over, and the cache file only exists once
-   * the first of them has finished, so identical requests join one run instead of each fetching and encoding.
-   */
   async #loadOptimizedImage(parsed: ParsedImageRequest): Promise<OptimizedImage> {
     const key = `${parsed.href}|${parsed.width}|${parsed.quality}|${parsed.outputType}`;
     const joined = this.#inflight.get(key);
@@ -149,12 +136,6 @@ export class ImageOptimizer {
     return optimized;
   }
 
-  /**
-   * The bytes are keyed by the source's own etag/mtime, so finding them means reading the source first — free for
-   * a local file, a full re-download for a remote one. This pointer is keyed by the request alone and carries the
-   * TTL (upstream `max-age`, floored by `minimumCacheTTL`), so a warm remote image never touches the origin.
-   * Dev is left out: re-fetching every time is what makes an upstream edit show up immediately.
-   */
   async #readRemotePointer(parsed: ParsedImageRequest): Promise<OptimizedImage | null> {
     let pointer: RemoteCachePointer;
     try {
@@ -250,11 +231,12 @@ export class ImageOptimizer {
       return { error: `"q" parameter (quality) of ${quality} is not allowed` };
     }
 
+    const accept = req.headers.get("accept") ?? "";
     return {
       href,
       width,
       quality,
-      outputType: ImageOptimizer.#getPreferredOutputType(req.headers.get("accept") ?? "", this.#config.formats),
+      outputType: this.#config.formats.find((format) => accept.includes(format)) ?? "",
       isRemote,
     };
   }
@@ -329,6 +311,7 @@ export class ImageOptimizer {
       shouldBypass || !params.outputType || inputType === ImageOptimizer.#webp || inputType === ImageOptimizer.#avif
         ? inputType
         : params.outputType;
+    const shouldEncode = !shouldBypass && ImageOptimizer.#encodableTypes.has(outputType);
     const cachePath = this.#getCachePath({
       href: params.href,
       width: params.width,
@@ -351,7 +334,7 @@ export class ImageOptimizer {
     let buffer = source.buffer;
     let contentType = inputType;
     let cacheable = true;
-    if (!shouldBypass) {
+    if (shouldEncode) {
       try {
         buffer = await this.#semaphore.run(() =>
           ImageOptimizer.#optimize(source.buffer, {
@@ -415,10 +398,6 @@ export class ImageOptimizer {
     return await image.jpeg({ quality: options.quality }).toBuffer();
   }
 
-  static #getPreferredOutputType(accept: string, formats: AkanImageFormat[]): AkanImageFormat | "" {
-    return formats.find((format) => accept.includes(format)) ?? "";
-  }
-
   static #hasRemoteMatch(patterns: AkanImagePattern[], url: URL): boolean {
     return patterns.some((pattern) => {
       if (pattern.protocol && `${pattern.protocol}:` !== url.protocol) return false;

package/server/index.ts

@@ -6,7 +6,7 @@ export * from "./artifact";
 export * from "./console";
 export * from "./decorators";
 export * from "./devtools";
-export type { ChangeBatch, ChangeKind } from "./hmr/changeBatch";
+export type { ChangeBatch, ChangeKind } from "./hmr/wsHub";
 export * from "./oauth";
 export * from "./processMetricsCollector";
 export * from "./proxy";

package/server/lifecycle/portInUse.ts

@@ -1,7 +1,4 @@
-/**
- * Detects "address already in use" listen failures across the shapes Bun throws them in
- * (`code: "EADDRINUSE"` on newer versions, message-only on older ones).
- */
+/** Bun reports EADDRINUSE as `code` on newer versions and only in the message on older ones; both count. */
 export const isPortInUseError = (error: unknown): boolean => {
   if (!error || typeof error !== "object") return false;
   const candidate = error as { code?: unknown; message?: unknown };

package/server/lifecycle/runtimeDir.ts

@@ -1,9 +1,5 @@
 import path from "node:path";
 
-/**
- * Where a replica keeps its child sockets and rotating logs. Both the gateway and a solo server resolve it,
- * and they must land on the same directory: switching between the two modes must not move the log file.
- */
 export const resolveRuntimeDir = (runtimeDir?: string): string =>
   path.resolve(
     runtimeDir ??

package/server/lifecycle/shutdownManager.ts

@@ -1,15 +1,6 @@
 import type { Logger } from "akanjs/common";
 
 export class ShutdownManager {
-  /**
-   * Registers process-level handlers that drive `onShutdown` on:
-   *   - SIGTERM / SIGINT (graceful stop → exit(0) on success, exit(1) on error)
-   *   - uncaughtException (best-effort stop → exit(1))
-   *   - unhandledRejection (logged at error, process kept alive; see `#isFatalUnhandledRejection`)
-   *
-   * Kept separate from `AkanServer` so the server class doesn't have to know about
-   * Node-level process events, and so tests can opt out by not calling it.
-   */
   static register(logger: Logger, onShutdown: () => Promise<void>): void {
     const signals: NodeJS.Signals[] = ["SIGTERM", "SIGINT"];
 
@@ -28,34 +19,18 @@ export class ShutdownManager {
 
     process.on("uncaughtException", async (error) => {
       logger.error(`Uncaught exception: ${ShutdownManager.#formatError(error)}`);
-      try {
-        await onShutdown();
-        process.exit(1);
-      } catch {
-        process.exit(1);
-      }
+      await onShutdown().catch(() => undefined);
+      process.exit(1);
     });
 
     process.on("unhandledRejection", async (reason) => {
       logger.error(`Unhandled rejection: ${ShutdownManager.#formatError(reason)}`);
       if (!ShutdownManager.#isFatalUnhandledRejection()) return;
-      try {
-        await onShutdown();
-        process.exit(1);
-      } catch {
-        process.exit(1);
-      }
+      await onShutdown().catch(() => undefined);
+      process.exit(1);
     });
   }
 
-  /**
-   * A rejected promise nobody awaited is scoped to whatever built it, so it cannot leave the process in the
-   * unknown state an `uncaughtException` does — while exiting over one drops every other in-flight request,
-   * every websocket, and (under federation) restarts the replica. React's streaming SSR is the case that forced
-   * this: it rejects `stream.allReady` for a post-shell render failure and holds no handler of its own, so one
-   * page's boundary error used to kill a whole child. Set `AKAN_FATAL_UNHANDLED_REJECTION=1` to restore the
-   * exit for a deployment that would rather crash than serve on.
-   */
   static #isFatalUnhandledRejection(): boolean {
     const flag = process.env.AKAN_FATAL_UNHANDLED_REJECTION;
     return flag === "1" || flag === "true";

package/server/logging/childOutputReader.ts

@@ -3,9 +3,7 @@ import { Logger, type LogLevel, type LogRecord, logSeverity } from "akanjs/commo
 export type ChildOutputType = "stdout" | "stderr";
 
 export interface ChildOutputReaderOptions {
-  /** A complete stdout line, newline included. */
   onLine: (line: string) => void;
-  /** A stderr block of newline-terminated lines; one stack trace arrives as one block. */
   onBlock: (lines: string[]) => void;
   blockMaxLines?: number;
   blockIdleMs?: number;
@@ -20,11 +18,6 @@ export interface ChildRecordInput {
   pid: number | null;
 }
 
-/**
- * Splits a child process's stdout and stderr into lines. stderr is block-buffered — a runtime writes a stack
- * trace in many small writes and a reader wants it whole — and a block closes on a blank line, at
- * `blockMaxLines`, after `blockIdleMs` of silence, or when the stream ends.
- */
 export class ChildOutputReader {
   static readonly defaultBlockMaxLines = 64;
   static readonly defaultBlockIdleMs = 50;
@@ -44,10 +37,6 @@ export class ChildOutputReader {
     this.#blockIdleMs = blockIdleMs ?? ChildOutputReader.defaultBlockIdleMs;
   }
 
-  /**
-   * Wraps what a child wrote past its Logger — a `console.*` call, a runtime error, a crash — as a record of the
-   * process that read it, so an ndjson stdout stays one JSON line per event even for the line that killed a child.
-   */
   static toRecord({ type, text, name, role, replicaIdx, pid }: ChildRecordInput): LogRecord {
     const level: LogLevel = type === "stderr" ? "error" : "info";
     const at = Date.now();
@@ -98,7 +87,6 @@ export class ChildOutputReader {
     this.#partial[type] = buffered;
   }
 
-  /** Ends the stream's partial line and, for stderr, the block it belongs to. */
   flush(type: ChildOutputType) {
     const partial = this.#partial[type];
     this.#partial[type] = "";

package/server/logging/hubFileSink.ts

@@ -1,4 +1,4 @@
-import { Logger } from "akanjs/common";
+import { Logger, logSeverity } from "akanjs/common";
 import type { LogHub, LogHubEntry } from "./logHub";
 import { LogStdoutWriter } from "./logStdoutWriter";
 import type { RotatingLogWriter } from "./rotatingLogWriter";
@@ -9,11 +9,6 @@ export interface HubFileSinkOptions {
   json: boolean;
 }
 
-/**
- * The rotating log file fed from the hub instead of from this process's own Logger. In an ndjson deployment a
- * child writes no text line the owner could relay, so the file is written from the records that reached the
- * hub — every process in one place, keyed the way the text-mode files were.
- */
 export class HubFileSink {
   #subscription: { unsubscribe(): void } | null;
 
@@ -26,6 +21,15 @@ export class HubFileSink {
     });
   }
 
+  static attach(writer: RotatingLogWriter, hub: LogHub | null, label: string): () => void {
+    if (!hub || !Logger.isNdjson) return Logger.addSink((entry) => void writer.write(label, entry.plainMessage));
+    const sink = new HubFileSink(hub, writer, {
+      minSev: logSeverity[Logger.fileLevel],
+      json: Logger.format === "ndjson-only",
+    });
+    return () => sink.close();
+  }
+
   static processKey({ record }: LogHubEntry): string {
     const role = record.role ?? "app";
     if (role === "gateway" || record.replicaIdx === null) return role;

package/server/logging/logControlSocket.ts

@@ -26,13 +26,6 @@ interface ClientState {
   subscriptions: Map<string, () => void>;
 }
 
-/**
- * A unix domain socket in the runtime directory, `0600`, speaking NDJSON both ways. Filesystem permission is
- * the whole authentication: no TCP port is opened. `akan logs` and the console's `.tail` are its clients.
- *
- * Nothing in here logs per delivered record — a subscriber asking for everything would otherwise receive the
- * line about its own delivery, forever.
- */
 export class LogControlSocket {
   static readonly fileName = "akan-control.sock";
   static readonly maxPendingBytes = 1024 * 1024;
@@ -52,6 +45,19 @@ export class LogControlSocket {
     this.path = LogControlSocket.pathIn(runtimeDir);
   }
 
+  static async open(hub: LogHub, runtimeDir: string, logger: Logger): Promise<LogControlSocket | null> {
+    const control = new LogControlSocket(hub, runtimeDir);
+    try {
+      await control.start();
+      return control;
+    } catch (error) {
+      logger.warn(
+        `Log control socket unavailable at ${control.path}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      return null;
+    }
+  }
+
   async start() {
     await mkdir(path.dirname(this.path), { recursive: true });
     await rm(this.path, { force: true });

package/server/logging/logForwarder.ts

@@ -9,30 +9,22 @@ export interface LogForwarderOptions {
   maxMessageChars?: number;
 }
 
-/**
- * The child side of the log channel: a Logger sink that batches records over IPC to whoever owns the hub.
- * Installed only while the owner has asked for a level (`log.level`), so a process nobody is watching sends
- * nothing; `AKAN_LOG_STREAM=1` keeps it on regardless.
- */
 export class LogForwarder {
   static readonly defaultFlushMs = 20;
   static readonly defaultMaxRecords = 64;
-  /**
-   * Bun IPC loses a message outright when the sender exits soon after and the payload is large — measured from
-   * 16KB for one long string — and a small message queued behind it dies with it. Batches stay well under that.
-   */
   static readonly defaultMaxBytes = 32 * 1024;
   static readonly defaultMaxQueue = 1_000;
   static readonly defaultMaxMessageChars = 16 * 1024;
+  static readonly #closeTimeoutMs = 1_000;
 
-  readonly #send: (message: AkanIpcMessage) => void;
+  readonly #send: (message: AkanIpcMessage, onSent?: () => void) => void;
   readonly #flushMs: number;
   readonly #maxRecords: number;
   readonly #maxBytes: number;
   readonly #maxQueue: number;
   readonly #maxMessageChars: number;
   readonly #alwaysOn = process.env.AKAN_LOG_STREAM === "1";
-  /** In an ndjson deployment this process writes nothing itself, so what the stdout level admits must go up. */
+  
   readonly #baseSev: number | null = Logger.isNdjson ? logSeverity[Logger.level] : null;
   #queue: LogRecord[] = [];
   #dropped = 0;
@@ -40,7 +32,7 @@ export class LogForwarder {
   #removeSink: (() => void) | null = null;
   #minSev: number | null = null;
 
-  constructor(send: (message: AkanIpcMessage) => void, options: LogForwarderOptions = {}) {
+  constructor(send: (message: AkanIpcMessage, onSent?: () => void) => void, options: LogForwarderOptions = {}) {
     this.#send = send;
     this.#flushMs = options.flushMs ?? LogForwarder.defaultFlushMs;
     this.#maxRecords = options.maxRecords ?? LogForwarder.defaultMaxRecords;
@@ -50,7 +42,6 @@ export class LogForwarder {
     if (this.minSev !== null) this.setMinSev(null);
   }
 
-  /** The severity floor in force, or `null` when nothing is forwarded. */
   get minSev(): number | null {
     const base = this.#alwaysOn ? 0 : this.#baseSev;
     if (base === null) return this.#minSev;
@@ -61,10 +52,6 @@ export class LogForwarder {
     return this.#removeSink !== null;
   }
 
-  get dropped() {
-    return this.#dropped;
-  }
-
   setMinSev(minSev: number | null) {
     this.#minSev = minSev;
     const floor = this.minSev;
@@ -79,7 +66,6 @@ export class LogForwarder {
     });
   }
 
-  /** Enqueues a record this process produced or relays for one below it; dropped when nobody is listening. */
   push(record: LogRecord) {
     const floor = this.minSev;
     if (floor === null) return;
@@ -97,9 +83,10 @@ export class LogForwarder {
     for (const record of records) this.push(record);
   }
 
-  flush() {
+  flush(onSent?: () => void) {
     if (this.#timer) clearTimeout(this.#timer);
     this.#timer = null;
+    if (!this.#queue.length) onSent?.();
     while (this.#queue.length) {
       const batch: LogRecord[] = [];
       let bytes = 0;
@@ -113,14 +100,24 @@ export class LogForwarder {
       }
       const dropped = this.#dropped;
       this.#dropped = 0;
-      this.#send({ type: "log.records", records: batch, ...(dropped ? { dropped } : {}), pid: process.pid });
+      this.#send(
+        { type: "log.records", records: batch, ...(dropped ? { dropped } : {}), pid: process.pid },
+        this.#queue.length ? undefined : onSent,
+      );
     }
   }
 
-  close() {
+  close(): Promise<void> {
     this.#removeSink?.();
     this.#removeSink = null;
-    this.flush();
+    return new Promise((resolve) => {
+      const timer = setTimeout(resolve, LogForwarder.#closeTimeoutMs);
+      timer.unref?.();
+      this.flush(() => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
   }
 
   #clip(record: LogRecord): LogRecord {

package/server/logging/logQuery.ts

@@ -1,6 +1,6 @@
 import { Logger, type LogLevelInput, type LogRecord, logSeverity } from "akanjs/common";
 
-/** Fields AND together; a list inside a field is an OR. One shape serves live tail, history and the SSE query string. */
+/** Fields AND together; a list inside a field is an OR. */
 export interface LogQuery {
   minSev?: number;
   text?: string;
@@ -30,7 +30,7 @@ export class LogQueryMatcher {
 
   matches(record: LogRecord): boolean {
     const q = this.query;
-
+    
     if (q.minSev !== undefined && (record.level === null || (record.sev < q.minSev && !Logger.isPromoted(record))))
       return false;
     if (q.text !== undefined && !record.message.includes(q.text)) return false;
@@ -49,7 +49,7 @@ export class LogQueryMatcher {
     return true;
   }
 
-  /** `*` is the only wildcard: `mutation:*`, `*:userList`. Everything else is literal. */
+  /** `*` is the only wildcard (`mutation:*`, `*:userList`); everything else is literal. */
   static compileGlob(pattern: string): RegExp {
     const source = pattern
       .split("*")
@@ -75,10 +75,7 @@ export class LogQueryMatcher {
     return level in logSeverity ? logSeverity[level] : undefined;
   }
 
-  /**
-   * Reads a query off `URLSearchParams` or a parsed JSON object. Lists accept repeated keys and comma-separated
-   * values; `level=warn` is sugar for `minSev`; `since` accepts a duration.
-   */
+  /** Lists take repeated keys or comma-separated values; `level` is sugar for `minSev`; `since` takes a duration. */
   static parse(input: URLSearchParams | Record<string, unknown>, now = Date.now()): LogQuery {
     const list = (key: string): string[] => {
       const raw =

package/server/logging/logStdoutWriter.ts

@@ -5,25 +5,15 @@ export interface LogStdoutWriterOptions {
   write?: (line: string) => void;
 }
 
-/**
- * The container's stdout in an ndjson deployment: one JSON record per line for everything the hub sees at or
- * above the stdout level, from this process and every one it fronts. It is the only writer — `Logger.consoleOutput`
- * is off in every server process — so a collector's parser is `json` and nothing else.
- */
 export class LogStdoutWriter {
   readonly #write: (line: string) => void;
   #subscription: { unsubscribe(): void } | null;
 
   constructor(hub: LogHub, { minSev, write }: LogStdoutWriterOptions) {
-    this.#write =
-      write ??
-      ((line) => {
-        process.stdout.write(line);
-      });
+    this.#write = write ?? ((line) => void process.stdout.write(line));
     this.#subscription = hub.subscribe({ minSev }, (entry) => this.#write(LogStdoutWriter.line(entry)));
   }
 
-  /** `seq` rides along: `at` comes from several clocks, so it is what orders records from different processes. */
   static json(entry: LogHubEntry) {
     return { seq: entry.seq, ...entry.record };
   }

package/server/logging/logStreamRoute.ts

@@ -1,18 +1,9 @@
 import { timingSafeEqual } from "node:crypto";
-import { EventStream } from "../routing/eventStream";
+import { EventStream } from "akanjs/common";
 import type { LogHub, LogHubEntry } from "./logHub";
 import { LogQueryMatcher } from "./logQuery";
 import { LogStdoutWriter } from "./logStdoutWriter";
 
-/**
- * `GET /_akan/app/logs?level=warn&endpoint=mutation:*` — the hub as a `text/event-stream`, for a monitor watching
- * one process from outside the pod. Every event carries the hub `seq` as its `id:`, so a client that reconnects
- * with `Last-Event-ID` gets what it missed while the ring still holds it, and an explicit gap event when it does
- * not — never a silent skip a monitor would read as a quiet interval.
- *
- * The route exists only when `AKAN_LOG_STREAM_TOKEN` is set, and answers only a matching bearer token. It logs
- * nothing itself: a stream that logged its own subscriptions at the level it delivers would feed on itself.
- */
 export class LogStreamRoute {
   static readonly path = "/_akan/app/logs";
   static readonly retryMs = 2_000;
@@ -37,8 +28,7 @@ export class LogStreamRoute {
       return new Response("Unauthorized", { status: 401, headers: { "www-authenticate": "Bearer" } });
     const hub = this.#hub();
     if (!hub) return new Response("Log hub is not running", { status: 503 });
-    const url = new URL(req.url);
-    const query = LogQueryMatcher.parse(url.searchParams);
+    const query = LogQueryMatcher.parse(new URL(req.url).searchParams);
     const matcher = new LogQueryMatcher(query);
     let subscription: { unsubscribe(): void } | null = null;
     const stream = new EventStream(
@@ -49,8 +39,8 @@ export class LogStreamRoute {
       { keepAliveMs: LogStreamRoute.heartbeatMs, keepAliveChunk: ": heartbeat\n\n" },
     );
     stream.retry(LogStreamRoute.retryMs);
-    const lastEventId = LogStreamRoute.#lastEventId(req);
-    if (lastEventId !== null) LogStreamRoute.#resume(hub, stream, matcher, lastEventId);
+    const lastEventId = req.headers.get("last-event-id")?.trim();
+    if (lastEventId && /^\d+$/.test(lastEventId)) LogStreamRoute.#resume(hub, stream, matcher, Number(lastEventId));
     subscription = hub.subscribe(query, (entry) => LogStreamRoute.#send(stream, entry));
     return stream.response();
   }
@@ -63,13 +53,6 @@ export class LogStreamRoute {
     return presented.length === this.#token.length && timingSafeEqual(presented, this.#token);
   }
 
-  static #lastEventId(req: Request): number | null {
-    const value = req.headers.get("last-event-id");
-    if (value === null || !/^\d+$/.test(value.trim())) return null;
-    return Number(value.trim());
-  }
-
-  /** What arrived after `lastEventId`, preceded by a gap event when the ring no longer reaches back that far. */
   static #resume(hub: LogHub, stream: EventStream, matcher: LogQueryMatcher, lastEventId: number) {
     if (lastEventId > hub.seq) {
       

package/server/logging/logTailClient.ts

@@ -8,8 +8,6 @@ export interface LogTailHandlers {
   onClose?: () => void;
 }
 
-type Pending = { resolve: (response: LogControlResponse) => void; reject: (error: Error) => void };
-
 /** Says the app is not running at all, as opposed to a request that failed once connected. */
 export class LogControlUnavailableError extends Error {
   readonly socketPath: string;
@@ -20,11 +18,6 @@ export class LogControlUnavailableError extends Error {
   }
 }
 
-/**
- * The client half of `LogControlSocket`: `akan logs` and the console's `.tail` both speak through it. Records
- * stream to `onRecord`; every other line answers the oldest request still waiting, in order, because the
- * socket answers in order.
- */
 export class LogTailClient {
   static socketPath(runtimeDir: string) {
     return LogControlSocket.pathIn(runtimeDir);
@@ -63,7 +56,7 @@ export class LogTailClient {
   }
 
   readonly #handlers: LogTailHandlers;
-  readonly #pending: Pending[] = [];
+  readonly #pending: { resolve: (response: LogControlResponse) => void; reject: (error: Error) => void }[] = [];
   #socket: Bun.Socket<undefined> | null = null;
   #inbox = "";
   #closed = false;

package/server/logging/rotatingLogWriter.ts

@@ -122,12 +122,10 @@ export class RotatingLogWriter {
   async #createState(processKey: string, date: string): Promise<RotatingLogWriterState> {
     const sequence = await this.#getNextSequence(processKey, date);
     const filePath = this.#getFilePath(processKey, date, sequence);
-    let sizeBytes = 0;
-    try {
-      sizeBytes = (await stat(filePath)).size;
-    } catch {
-      sizeBytes = 0;
-    }
+    const sizeBytes = await stat(filePath).then(
+      (file) => file.size,
+      () => 0,
+    );
     return { date, sequence, sizeBytes };
   }