@bgord/bun 1.6.6 → 1.7.0

package/src/event-handler-with-logger.strategy.ts

@@ -0,0 +1,31 @@
+import type { z } from "zod/v4";
+import type { ClockPort } from "./clock.port";
+import type { GenericEventSchema } from "./event.types";
+import type { EventHandlerStrategy } from "./event-handler.strategy";
+import type { LoggerPort } from "./logger.port";
+import { formatError } from "./logger-format-error.service";
+import { Stopwatch } from "./stopwatch.service";
+
+type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
+
+export class EventHandlerWithLoggerStrategy implements EventHandlerStrategy {
+  constructor(private readonly deps: Dependencies) {}
+
+  handle<T extends { name: z.infer<GenericEventSchema["shape"]["name"]> }>(fn: (event: T) => Promise<void>) {
+    return async (event: T) => {
+      const stopwatch = new Stopwatch(this.deps);
+
+      try {
+        await fn(event);
+      } catch (error) {
+        this.deps.Logger.error({
+          message: `Unknown ${event.name} event handler error`,
+          component: "infra",
+          operation: "event_handler",
+          metadata: { name: event.name, duration: stopwatch.stop() },
+          error: formatError(error),
+        });
+      }
+    };
+  }
+}

package/src/event-handler.strategy.ts

@@ -0,0 +1,8 @@
+import type { z } from "zod/v4";
+import type { GenericEventSchema } from "./event.types";
+
+export interface EventHandlerStrategy {
+  handle<T extends { name: z.infer<GenericEventSchema["shape"]["name"]> }>(
+    fn: (event: T) => Promise<void>,
+  ): (event: T) => Promise<void>;
+}

package/src/event-store-like.types.ts

@@ -1,7 +1,3 @@
-import type * as tools from "@bgord/tools";
-
 export type EventStoreLike<E extends { name: string }> = {
   save(events: E[]): Promise<unknown>;
-
-  saveAfter(events: E[], offset: tools.Duration): Promise<unknown>;
 };

package/src/event-store.ts

@@ -1,4 +1,3 @@
-import type * as tools from "@bgord/tools";
 import type { z } from "zod/v4";
 import type { GenericEventSchema, GenericParsedEventSchema } from "./event.types";
 import type { EventStreamType } from "./event-stream.vo";
@@ -53,11 +52,6 @@ export class EventStore<AllEvents extends GenericEventSchema> {
       payload: JSON.parse(event.payload),
     })) as z.infer<AllEvents>[];
   }
-
-  async saveAfter(events: z.infer<AllEvents>[], offset: tools.Duration): Promise<z.infer<AllEvents>[]> {
-    await Bun.sleep(offset.ms);
-    return this.save(events);
-  }
 }
 
 export class EventStoreSaveUniqueStream extends Error {

package/src/file-reader-json-bun-forgiving.adapter.ts

@@ -0,0 +1,14 @@
+import type * as tools from "@bgord/tools";
+import type { FileReaderJsonOutputType, FileReaderJsonPort } from "./file-reader-json.port";
+
+export class FileReaderJsonBunForgivingAdapter implements FileReaderJsonPort {
+  async read(
+    path: tools.FilePathRelative | tools.FilePathAbsolute | string,
+  ): Promise<FileReaderJsonOutputType> {
+    try {
+      return Bun.file(typeof path === "string" ? path : path.get()).json();
+    } catch {
+      return {};
+    }
+  }
+}

package/src/file-reader-json-bun.adapter.ts

@@ -0,0 +1,10 @@
+import type * as tools from "@bgord/tools";
+import type { FileReaderJsonOutputType, FileReaderJsonPort } from "./file-reader-json.port";
+
+export class JsonFileReaderBunAdapter implements FileReaderJsonPort {
+  async read(
+    path: tools.FilePathRelative | tools.FilePathAbsolute | string,
+  ): Promise<FileReaderJsonOutputType> {
+    return Bun.file(typeof path === "string" ? path : path.get()).json();
+  }
+}

package/src/file-reader-json-noop.adapter.ts

@@ -0,0 +1,12 @@
+import type * as tools from "@bgord/tools";
+import type { FileReaderJsonOutputType, FileReaderJsonPort } from "./file-reader-json.port";
+
+export class FileReaderJsonNoopAdapter implements FileReaderJsonPort {
+  constructor(private readonly json: Record<string, any>) {}
+
+  async read(
+    _path: tools.FilePathRelative | tools.FilePathAbsolute | string,
+  ): Promise<FileReaderJsonOutputType> {
+    return this.json;
+  }
+}

package/src/file-reader-json-with-cache.adapter.ts

@@ -0,0 +1,34 @@
+import type * as tools from "@bgord/tools";
+import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import { CacheSubjectResolver } from "./cache-subject-resolver.vo";
+import { CacheSubjectSegmentFixedStrategy } from "./cache-subject-segment-fixed.strategy";
+import type { FileReaderJsonOutputType, FileReaderJsonPort } from "./file-reader-json.port";
+import type { HashContentStrategy } from "./hash-content.strategy";
+
+type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy };
+
+export class FileReaderJsonWithCacheAdapter implements FileReaderJsonPort {
+  constructor(
+    private readonly config: { id: string; inner: FileReaderJsonPort },
+    private readonly deps: Dependencies,
+  ) {}
+
+  async read(
+    path: tools.FilePathRelative | tools.FilePathAbsolute | string,
+  ): Promise<FileReaderJsonOutputType> {
+    const resolver = new CacheSubjectResolver(
+      [
+        new CacheSubjectSegmentFixedStrategy("file_reader_json"),
+        new CacheSubjectSegmentFixedStrategy(this.config.id),
+        new CacheSubjectSegmentFixedStrategy(typeof path === "string" ? path : path.get()),
+      ],
+      this.deps,
+    );
+
+    const subject = await resolver.resolve();
+
+    return this.deps.CacheResolver.resolve<FileReaderJsonOutputType>(subject.hex, () =>
+      this.config.inner.read(path),
+    );
+  }
+}

package/src/file-reader-json.port.ts

@@ -0,0 +1,7 @@
+import type * as tools from "@bgord/tools";
+
+export type FileReaderJsonOutputType = Record<string, any>;
+
+export interface FileReaderJsonPort {
+  read(path: tools.FilePathRelative | tools.FilePathAbsolute | string): Promise<FileReaderJsonOutputType>;
+}

package/src/hash-content-noop.strategy.ts

@@ -0,0 +1,8 @@
+import { Hash } from "./hash.vo";
+import type { HashContentStrategy } from "./hash-content.strategy";
+
+export class HashContentNoopStrategy implements HashContentStrategy {
+  async hash(_content: string) {
+    return Hash.fromString("0000000000000000000000000000000000000000000000000000000000000000");
+  }
+}

package/src/hash-content-sha256-bun.strategy.ts

@@ -0,0 +1,11 @@
+import { Hash } from "./hash.vo";
+import type { HashContentStrategy } from "./hash-content.strategy";
+
+export class HashContentSha256BunStrategy implements HashContentStrategy {
+  async hash(content: string) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(content));
+    const etag = Buffer.from(digest).toString("hex");
+
+    return Hash.fromString(etag);
+  }
+}

package/src/hash-content.strategy.ts

@@ -0,0 +1,5 @@
+import type { Hash } from "./hash.vo";
+
+export interface HashContentStrategy {
+  hash(content: string): Promise<Hash>;
+}

package/src/hash-file-sha256-bun.adapter.ts

@@ -1,8 +1,8 @@
 import * as tools from "@bgord/tools";
-import type { HashContentPort } from "./hash-content.port";
+import type { HashContentStrategy } from "./hash-content.strategy";
 import type { HashFilePort } from "./hash-file.port";
 
-type Dependencies = { HashContent: HashContentPort };
+type Dependencies = { HashContent: HashContentStrategy };
 
 export class HashFileSha256BunAdapter implements HashFilePort {
   constructor(private readonly deps: Dependencies) {}

package/src/healthcheck.service.ts

@@ -1,62 +1,101 @@
+import os from "node:os";
 import * as tools from "@bgord/tools";
 import { createFactory } from "hono/factory";
 import { BuildInfoRepository } from "./build-info-repository.service";
 import type { ClockPort } from "./clock.port";
-import type { JsonFileReaderPort } from "./json-file-reader.port";
+import type { FileReaderJsonPort } from "./file-reader-json.port";
 import type { LoggerPort } from "./logger.port";
 import { MemoryConsumption } from "./memory-consumption.service";
-import { PrerequisiteSelf } from "./prerequisites/self";
-import * as prereqs from "./prerequisites.service";
+import type { NodeEnvironmentEnum } from "./node-env.vo";
+import { Prerequisite, type PrerequisiteLabelType } from "./prerequisite.vo";
+import {
+  PrerequisiteVerificationOutcome,
+  type PrerequisiteVerificationResult,
+} from "./prerequisite-verifier.port";
+import { PrerequisiteVerifierSelfAdapter } from "./prerequisite-verifier-self.adapter";
+import { Stopwatch } from "./stopwatch.service";
 import { Uptime, type UptimeResultType } from "./uptime.service";
 
 const handler = createFactory();
+const self = new Prerequisite("self", new PrerequisiteVerifierSelfAdapter());
 
 type HealthcheckResultType = {
-  ok: prereqs.PrerequisiteStatusEnum;
-  version: string;
-  details: { label: prereqs.PrerequisiteLabelType; outcome: prereqs.VerifyOutcome }[];
-  uptime: Omit<UptimeResultType, "duration"> & { durationMs: tools.DurationMsType };
-  memory: { bytes: tools.Size["bytes"]; formatted: ReturnType<tools.Size["format"]> };
+  ok: boolean;
+  deployment: {
+    version: string;
+    environment: NodeEnvironmentEnum;
+  };
+  server: {
+    pid: typeof process.pid;
+    hostname: ReturnType<typeof os.hostname>;
+    cpus: number;
+    startup: tools.TimestampValueType;
+    uptime: Omit<UptimeResultType, "duration"> & { durationMs: tools.DurationMsType };
+    memory: { bytes: tools.Size["bytes"]; formatted: ReturnType<tools.Size["format"]> };
+  };
+  details: {
+    label: PrerequisiteLabelType;
+    outcome: PrerequisiteVerificationResult;
+    durationMs: tools.DurationMsType;
+  }[];
   durationMs: tools.Duration["ms"];
+  timestamp: tools.TimestampValueType;
 };
 
-type Dependencies = { Clock: ClockPort; JsonFileReader: JsonFileReaderPort; Logger: LoggerPort };
+type Dependencies = { Clock: ClockPort; JsonFileReader: FileReaderJsonPort; Logger: LoggerPort };
 
 export class Healthcheck {
-  static build = (prerequisites: prereqs.Prerequisite[], deps: Dependencies) =>
+  static build = (Env: NodeEnvironmentEnum, _prerequisites: Prerequisite[], deps: Dependencies) =>
     handler.createHandlers(async (c) => {
-      const stopwatch = new tools.Stopwatch(deps.Clock.now());
+      const stopwatch = new Stopwatch(deps);
 
-      const buildInfo = await BuildInfoRepository.extract(deps);
+      const prerequisites = [self, ..._prerequisites]
+        .filter((prerequisite) => prerequisite.enabled)
+        .filter((prerequisite) => prerequisite.kind !== "port");
 
-      const details: HealthcheckResultType["details"][number][] = [];
+      const details: HealthcheckResultType["details"][number][] = await Promise.all(
+        prerequisites.map(async (prerequisite) => {
+          const stopwatch = new Stopwatch(deps);
 
-      for (const prerequisite of [new PrerequisiteSelf({ label: "self" }), ...prerequisites].filter(
-        (prerequisite) => prerequisite.kind !== "port",
-      )) {
-        details.push({ label: prerequisite.label, outcome: await prerequisite.verify(deps.Clock) });
-      }
+          return {
+            label: prerequisite.label,
+            outcome: await prerequisite.build().verify(),
+            durationMs: stopwatch.stop().ms,
+          };
+        }),
+      );
 
-      const ok = details.every((result) => result.outcome.status !== prereqs.PrerequisiteStatusEnum.failure)
-        ? prereqs.PrerequisiteStatusEnum.success
-        : prereqs.PrerequisiteStatusEnum.failure;
+      const ok = details.every(
+        (result) => result.outcome.outcome !== PrerequisiteVerificationOutcome.failure,
+      );
 
-      const code = ok === prereqs.PrerequisiteStatusEnum.success ? 200 : 424;
+      const code = ok ? 200 : 424;
 
+      const buildInfo = await BuildInfoRepository.extract(deps);
       const uptime = Uptime.get(deps.Clock);
 
-      const result: HealthcheckResultType = {
+      const response: HealthcheckResultType = {
         ok,
         details,
-        version: buildInfo.BUILD_VERSION ?? "unknown",
-        uptime: { durationMs: uptime.duration.ms, formatted: uptime.formatted },
-        memory: {
-          bytes: MemoryConsumption.get().toBytes(),
-          formatted: MemoryConsumption.get().format(tools.Size.unit.MB),
+        deployment: {
+          version: buildInfo.BUILD_VERSION ?? "unknown",
+          environment: Env,
+        },
+        server: {
+          pid: process.pid,
+          hostname: os.hostname(),
+          cpus: os.cpus().length,
+          startup: deps.Clock.now().subtract(uptime.duration).ms,
+          uptime: { durationMs: uptime.duration.ms, formatted: uptime.formatted },
+          memory: {
+            bytes: MemoryConsumption.get().toBytes(),
+            formatted: MemoryConsumption.get().format(tools.Size.unit.MB),
+          },
         },
         durationMs: stopwatch.stop().ms,
+        timestamp: deps.Clock.now().ms,
       };
 
-      return c.json(result, code);
+      return c.json(response, code);
     });
 }

package/src/http-logger.middleware.ts

@@ -1,10 +1,10 @@
-import * as tools from "@bgord/tools";
 import { createMiddleware } from "hono/factory";
-import { CacheSourceEnum } from "./cache-resolver.port";
+import { CacheSourceEnum } from "./cache-resolver.strategy";
 import { CacheResponse } from "./cache-response.middleware";
-import { Client } from "./client.vo";
+import { ClientFromHono } from "./client-from-hono.adapter";
 import type { ClockPort } from "./clock.port";
 import type { LoggerPort } from "./logger.port";
+import { Stopwatch } from "./stopwatch.service";
 
 const UNINFORMATIVE_HEADERS = [
   "accept",
@@ -45,7 +45,7 @@ export class HttpLogger {
       }
 
       const correlationId = context.get("requestId");
-      const client = Client.fromHonoContext(context).toJSON();
+      const client = ClientFromHono.translate(context).toJSON();
 
       const httpRequestBeforeMetadata = {
         params: context.req.param(),
@@ -77,7 +77,7 @@ export class HttpLogger {
         ),
       });
 
-      const stopwatch = new tools.Stopwatch(deps.Clock.now());
+      const stopwatch = new Stopwatch(deps);
       await next();
       const duration = stopwatch.stop();
 

package/src/i18n.service.ts

@@ -1,5 +1,5 @@
 import * as tools from "@bgord/tools";
-import type { JsonFileReaderPort } from "../src/json-file-reader.port";
+import type { FileReaderJsonPort } from "../src/file-reader-json.port";
 import type { LoggerPort } from "../src/logger.port";
 
 export type TranslationsKeyType = string;
@@ -17,7 +17,7 @@ export type I18nConfigType = {
   defaultLanguage?: string;
 };
 
-type Dependencies = { JsonFileReader: JsonFileReaderPort; Logger: LoggerPort };
+type Dependencies = { JsonFileReader: FileReaderJsonPort; Logger: LoggerPort };
 
 export class I18n {
   private readonly base = { component: "infra", operation: "translations" };

package/src/index.ts

@@ -7,29 +7,36 @@ export * from "./basic-auth-password.vo";
 export * from "./basic-auth-username.vo";
 export * from "./better-auth-logger.service";
 export * from "./binary.vo";
+export * from "./bots.vo";
 export * from "./build-info-repository.service";
 export * from "./cache-file.service";
 export * from "./cache-repository.port";
+export * from "./cache-repository-lru-cache.adapter";
 export * from "./cache-repository-node-cache.adapter";
 export * from "./cache-repository-noop.adapter";
-export * from "./cache-resolver.port";
-export * from "./cache-resolver-simple.adapter";
+export * from "./cache-resolver.strategy";
+export * from "./cache-resolver-simple.strategy";
 export * from "./cache-response.middleware";
 export * from "./cache-subject-resolver.vo";
-export * from "./cache-subject-segment.port";
-export * from "./cache-subject-segment-cookie";
-export * from "./cache-subject-segment-fixed";
-export * from "./cache-subject-segment-header";
-export * from "./cache-subject-segment-path";
-export * from "./cache-subject-segment-query";
-export * from "./cache-subject-segment-user";
+export * from "./cache-subject-segment.strategy";
+export * from "./cache-subject-segment-cookie.strategy";
+export * from "./cache-subject-segment-fixed.strategy";
+export * from "./cache-subject-segment-header.strategy";
+export * from "./cache-subject-segment-ip.strategy";
+export * from "./cache-subject-segment-path.strategy";
+export * from "./cache-subject-segment-query.strategy";
+export * from "./cache-subject-segment-user.strategy";
 export * from "./certificate-inspector.port";
 export * from "./certificate-inspector-noop.adapter";
 export * from "./certificate-inspector-tls.adapter";
 export * from "./checksum.service";
 export * from "./client.vo";
+export * from "./client-from-hono.adapter";
+export * from "./client-ip.vo";
+export * from "./client-user-agent.vo";
 export * from "./clock.port";
 export * from "./clock-fixed.adapter";
+export * from "./clock-offset.adapter";
 export * from "./clock-system.adapter";
 export * from "./command.types";
 export * from "./command-envelope";
@@ -41,6 +48,7 @@ export * from "./crypto-key-provider.port";
 export * from "./crypto-key-provider-file.adapter";
 export * from "./crypto-key-provider-memory.adapter";
 export * from "./crypto-key-provider-noop.adapter";
+export * from "./crypto-key-provider-with-cache.adapter";
 export * from "./csv-stringifier.adapter";
 export * from "./csv-stringifier.port";
 export * from "./decorators.service";
@@ -49,22 +57,23 @@ export * from "./disk-space-checker-bun.adapter";
 export * from "./disk-space-checker-noop.adapter";
 export * from "./dispatching-event-store";
 export * from "./encryption.port";
-export * from "./encryption-bun.adapter";
+export * from "./encryption-aes-gcm.adapter";
 export * from "./encryption-key.vo";
 export * from "./encryption-key-value.vo";
 export * from "./encryption-noop.adapter";
 export * from "./environment-loader.port";
 export * from "./environment-loader-encrypted.adapter";
+export * from "./environment-loader-noop.adapter";
 export * from "./environment-loader-process.adapter";
 export * from "./environment-loader-process-safe.adapter";
 export * from "./etag-extractor.middleware";
 export * from "./event.types";
 export * from "./event-bus-like.types";
 export * from "./event-envelope";
-export * from "./event-handler.port";
-export * from "./event-handler-bare.adapter";
-export * from "./event-handler-noop.adapter";
-export * from "./event-handler-with-logger.adapter";
+export * from "./event-handler.strategy";
+export * from "./event-handler-bare.strategy";
+export * from "./event-handler-noop.strategy";
+export * from "./event-handler-with-logger.strategy";
 export * from "./event-logger.service";
 export * from "./event-store";
 export * from "./event-store-like.types";
@@ -75,6 +84,11 @@ export * from "./file-cleaner-bun-forgiving.adapter";
 export * from "./file-cleaner-noop.adapter";
 export * from "./file-draft.service";
 export * from "./file-draft-zip.service";
+export * from "./file-reader-json.port";
+export * from "./file-reader-json-bun.adapter";
+export * from "./file-reader-json-bun-forgiving.adapter";
+export * from "./file-reader-json-noop.adapter";
+export * from "./file-reader-json-with-cache.adapter";
 export * from "./file-renamer.port";
 export * from "./file-renamer.port";
 export * from "./file-renamer-fs.adapter";
@@ -90,9 +104,9 @@ export * from "./gzip-bun.adapter";
 export * from "./gzip-noop.adapter";
 export * from "./gzip-stream.adapter";
 export * from "./hash.vo";
-export * from "./hash-content.port";
-export * from "./hash-content-noop.adapter";
-export * from "./hash-content-sha256-bun.adapter";
+export * from "./hash-content.strategy";
+export * from "./hash-content-noop.strategy";
+export * from "./hash-content-sha256-bun.strategy";
 export * from "./hash-file.port";
 export * from "./hash-file-noop.adapter";
 export * from "./hash-file-sha256-bun.adapter";
@@ -131,15 +145,11 @@ export * from "./image-resizer-noop.adapter";
 export * from "./image-resizer-sharp.adapter";
 export * from "./invariant.service";
 export * from "./invariant-error-handler.service";
-export * from "./job-handler.port";
-export * from "./job-handler-bare.adapter";
-export * from "./job-handler-noop.adapter";
-export * from "./job-handler-with-logger.adapter";
+export * from "./job-handler.strategy";
+export * from "./job-handler-bare.strategy";
+export * from "./job-handler-noop.strategy";
+export * from "./job-handler-with-logger.strategy";
 export * from "./jobs.service";
-export * from "./json-file-reader.port";
-export * from "./json-file-reader-bun.adapter";
-export * from "./json-file-reader-bun-forgiving.adapter";
-export * from "./json-file-reader-noop.adapter";
 export * from "./logger.port";
 export * from "./logger-format-error.service";
 export * from "./logger-noop.adapter";
@@ -152,6 +162,7 @@ export * from "./mailer.vo";
 export * from "./mailer-noop.adapter";
 export * from "./mailer-smtp.adapter";
 export * from "./mailer-smtp-with-logger.adapter";
+export * from "./maintenance-mode.middleware";
 export * from "./memory-consumption.service";
 export * as History from "./modules/history";
 export * as Preferences from "./modules/preferences";
@@ -160,36 +171,94 @@ export * from "./node-env.vo";
 export * from "./pdf-generator.port";
 export * from "./pdf-generator-noop.adapter";
 export * from "./port.vo";
-export * from "./prerequisites/index";
-export * from "./prerequisites.service";
+export * from "./prerequisite.vo";
+export * from "./prerequisite-runner-startup.service";
+export * from "./prerequisite-verifier.decorator";
+export * from "./prerequisite-verifier.port";
+export * from "./prerequisite-verifier-binary.adapter";
+export * from "./prerequisite-verifier-bun.adapter";
+export * from "./prerequisite-verifier-clock-drift.adapter";
+export * from "./prerequisite-verifier-dependency-vulnerabilities.adapter";
+export * from "./prerequisite-verifier-directory.adapter";
+export * from "./prerequisite-verifier-dns.adapter";
+export * from "./prerequisite-verifier-external-api.adapter";
+export * from "./prerequisite-verifier-file.adapter";
+export * from "./prerequisite-verifier-jobs.adapter";
+export * from "./prerequisite-verifier-log-file.adapter";
+export * from "./prerequisite-verifier-mailer.adapter";
+export * from "./prerequisite-verifier-memory.adapter";
+export * from "./prerequisite-verifier-node.adapter";
+export * from "./prerequisite-verifier-os.adapter";
+export * from "./prerequisite-verifier-outside-connectivity.adapter";
+export * from "./prerequisite-verifier-port.adapter";
+export * from "./prerequisite-verifier-ram.adapter";
+export * from "./prerequisite-verifier-running-user.adapter";
+export * from "./prerequisite-verifier-self.adapter";
+export * from "./prerequisite-verifier-space.adapter";
+export * from "./prerequisite-verifier-sqlite.adapter";
+export * from "./prerequisite-verifier-ssl-certificate-expiry.adapter";
+export * from "./prerequisite-verifier-timezone-utc.adapter";
+export * from "./prerequisite-verifier-translations.adapter";
 export * from "./recaptcha-secret-key.vo";
 export * from "./recaptcha-site-key.vo";
-export * from "./redactor.port";
-export * from "./redactor-compact-array.adapter";
-export * from "./redactor-compact-object.adapter";
-export * from "./redactor-composite.adapter";
-export * from "./redactor-encrypt.adapter";
-export * from "./redactor-mask.adapter";
-export * from "./redactor-noop.adapter";
+export * from "./redactor.strategy";
+export * from "./redactor-compact-array.strategy";
+export * from "./redactor-compact-object.strategy";
+export * from "./redactor-composite.strategy";
+// export * from "./redactor-encrypt.strategy";
+export * from "./redactor-mask.strategy";
+export * from "./redactor-noop.strategy";
 export * from "./remote-file-storage.port";
 export * from "./remote-file-storage-disk.adapter";
 export * from "./remote-file-storage-noop.adapter";
+export * from "./retry.service";
+export * from "./retry-backoff.strategy";
+export * from "./retry-backoff-exponential.strategy";
+export * from "./retry-backoff-fibonacci.strategy";
+export * from "./retry-backoff-linear.strategy";
+export * from "./retry-backoff-noop.strategy";
 export * from "./safe-parse-body.service";
-export * from "./secret.vo";
+export * from "./sealer.port";
+export * from "./sealer-aes-gcm.adapter";
+export * from "./sealer-noop.adapter";
+export * from "./security-context.vo";
+export * from "./security-countermeasure.strategy";
+export * from "./security-countermeasure-ban.strategy";
+export * from "./security-countermeasure-mirage.strategy";
+export * from "./security-countermeasure-name.vo";
+export * from "./security-countermeasure-noop.strategy";
+export * from "./security-countermeasure-report.strategy";
+export * from "./security-countermeasure-tarpit.strategy";
+export * from "./security-policy.vo";
+export * from "./security-rule.strategy";
+export * from "./security-rule-and.strategy";
+export * from "./security-rule-bait-routes.strategy";
+export * from "./security-rule-fail.strategy";
+export * from "./security-rule-honey-pot-field.strategy";
+export * from "./security-rule-name.vo";
+export * from "./security-rule-or.strategy";
+export * from "./security-rule-pass.strategy";
+export * from "./security-rule-user-agent.strategy";
+export * from "./security-rule-violation-threshold.strategy";
 export * from "./setup.service";
-export * from "./shield.port";
-export * from "./shield-api-key.adapter";
-export * from "./shield-auth.middleware";
-export * from "./shield-basic-auth.adapter";
-export * from "./shield-captcha-hcaptcha.adapter";
-export * from "./shield-captcha-hcaptcha-local.adapter";
-export * from "./shield-captcha-recaptcha.adapter";
-export * from "./shield-noop.adapter";
-export * from "./shield-rate-limit.adapter";
-export * from "./shield-timeout.adapter";
+export * from "./shield.strategy";
+export * from "./shield-api-key.strategy";
+export * from "./shield-auth.strategy";
+export * from "./shield-basic-auth.strategy";
+export * from "./shield-captcha-hcaptcha.strategy";
+export * from "./shield-captcha-hcaptcha-local.strategy";
+export * from "./shield-captcha-recaptcha.strategy";
+export * from "./shield-noop.strategy";
+export * from "./shield-rate-limit.strategy";
+export * from "./shield-security.strategy";
+export * from "./shield-timeout.strategy";
 export * from "./simulated-error.middleware";
+export * from "./sleeper.port";
+export * from "./sleeper-noop.adapter";
+export * from "./sleeper-system.adapter";
 export * from "./slower.middleware";
 export * from "./static-files.service";
+export * from "./stopwatch.service";
 export * from "./temporary-file.port";
 export * from "./temporary-file-absolute.adapter";
 export * from "./temporary-file-noop.adapter";
@@ -197,11 +266,18 @@ export * from "./time-zone-offset.middleware";
 export * from "./timekeeper.port";
 export * from "./timekeeper-google.adapter";
 export * from "./timekeeper-noop.adapter";
-export * from "./timeout.service";
+export * from "./timeout-cancellable-runner.port";
+export * from "./timeout-cancellable-runner-bare.adapter";
+export * from "./timeout-cancellable-runner-noop.adapter";
+export * from "./timeout-runner.port";
+export * from "./timeout-runner-bare.adapter";
+export * from "./timeout-runner-error.adapter";
+export * from "./timeout-runner-monitor.adapter";
+export * from "./timeout-runner-noop.adapter";
 export * from "./to-event-map.types";
 export * from "./translations.service";
 export * from "./uptime.service";
 export * from "./uuid.vo";
-export * from "./visitor-id.port";
-export * from "./visitor-id-client.adapter";
+export * from "./visitor-id.strategy";
+export * from "./visitor-id-client.strategy";
 export * from "./weak-etag-extractor.middleware";