@bgord/bun 1.20.5 → 1.21.1

package/src/security-rule.strategy.ts

@@ -1,10 +1,8 @@
-import type { HasRequestJSON, HasRequestPath } from "./request-context.port";
+import type { HasRequestForm, HasRequestJson, HasRequestPath } from "./request-context.port";
 import type { SecurityRuleNameType } from "./security-rule-name.vo";
 
-type RequestContextCapabilities = HasRequestPath & HasRequestJSON;
-
 export interface SecurityRuleStrategy {
-  isViolated(context: RequestContextCapabilities): Promise<boolean>;
+  isViolated(context: HasRequestPath & HasRequestJson & HasRequestForm): Promise<boolean>;
 
   get name(): SecurityRuleNameType;
 }

package/src/semaphore.service.ts

@@ -3,24 +3,27 @@ import type * as tools from "@bgord/tools";
 export type SemaphoreConfig = { limit: tools.IntegerPositiveType };
 
 export class Semaphore {
-  private readonly slots: Array<Promise<void>>;
+  private readonly limit: tools.IntegerPositiveType;
+
+  private active = 0;
+
+  private readonly waiting: Array<() => void> = [];
 
   constructor(config: SemaphoreConfig) {
-    this.slots = Array.from({ length: config.limit }, () => Promise.resolve());
+    this.limit = config.limit;
   }
 
   async run<T>(action: () => Promise<T>): Promise<T> {
-    const slot = this.slots.shift();
-    const { promise, resolve } = Promise.withResolvers<void>();
-
-    this.slots.push(promise);
-
-    await slot;
+    if (this.active >= this.limit) await new Promise<void>((resolve) => this.waiting.push(resolve));
+    else this.active++;
 
     try {
       return await action();
     } finally {
-      resolve();
+      const next = this.waiting.shift();
+
+      if (next) next();
+      else this.active--;
     }
   }
 }

package/src/setup-hono.service.ts

@@ -53,6 +53,7 @@ export class SetupHono {
       new ShieldMaintenanceHonoStrategy(config.maintenanceMode).handle(),
       new TrailingSlashHonoMiddleware().handle(),
       new CorrelationHonoMiddleware(deps).handle(),
+      new TimingHonoMiddleware(deps).handle(),
       new ApiVersionHonoMiddleware(deps).handle(),
       new ShieldCsrfHonoStrategy(config.csrf).handle(),
       secureHeaders({
@@ -76,7 +77,6 @@ export class SetupHono {
       new LanguageDetectorHonoMiddleware(config.I18n).handle(),
       new TimeZoneOffsetHonoMiddleware().handle(),
       new HttpLoggerHonoMiddleware(deps, config.httpLogger).handle(),
-      new TimingHonoMiddleware(deps).handle(),
     ];
   }
 }

package/src/shield-api-key-hono.strategy.ts

@@ -20,7 +20,7 @@ export class ShieldApiKeyHonoStrategy implements MiddlewareHonoPort {
       const context = new RequestContextHonoAdapter(c);
 
       if (this.strategy.evaluate(context)) return next();
-      throw new HTTPException(403, { message: ShieldApiKeyStrategyError.Rejected });
+      throw new HTTPException(401, { message: ShieldApiKeyStrategyError.Rejected });
     };
   }
 }

package/src/shield-api-key.strategy.ts

@@ -1,5 +1,6 @@
 import { timingSafeEqual } from "node:crypto";
-import type * as tools from "@bgord/tools";
+import * as tools from "@bgord/tools";
+import * as v from "valibot";
 import type { HasRequestHeader } from "./request-context.port";
 
 export type ApiKeyShieldConfig = { API_KEY: tools.ApiKeyType };
@@ -12,11 +13,10 @@ export class ShieldApiKeyStrategy {
   constructor(private readonly config: ApiKeyShieldConfig) {}
 
   evaluate(context: HasRequestHeader): boolean {
-    const header = context.request.header(ShieldApiKeyStrategy.HEADER_NAME);
-    const config = this.config.API_KEY;
+    const header = v.safeParse(tools.ApiKey, context.request.header(ShieldApiKeyStrategy.HEADER_NAME));
 
-    if (header?.length !== config.length) return false;
+    if (!header.success) return false;
 
-    return timingSafeEqual(Buffer.from(header), Buffer.from(config));
+    return timingSafeEqual(Buffer.from(header.output), Buffer.from(this.config.API_KEY));
   }
 }

package/src/shield-auth.strategy.ts

@@ -3,7 +3,10 @@ import type { HasRequestHeaders } from "./request-context.port";
 
 type Dependencies<User, Session> = { AuthSessionReader: AuthSessionReaderPort<User, Session> };
 
-export const ShieldAuthStrategyError = { Rejected: "shield.auth.rejected" };
+export const ShieldAuthStrategyError = {
+  Rejected: "shield.auth.rejected",
+  NotAttached: "shield.auth.not.attached",
+};
 
 export class ShieldAuthStrategy<User, Session> {
   constructor(private readonly deps: Dependencies<User, Session>) {}
@@ -12,11 +15,13 @@ export class ShieldAuthStrategy<User, Session> {
     return await this.deps.AuthSessionReader.getSession(context);
   }
 
-  verify(user: User | null): boolean {
-    return user !== null && user !== undefined;
+  verify(user: User | null | undefined): boolean {
+    if (user === undefined) throw new Error(ShieldAuthStrategyError.NotAttached);
+    return user !== null;
   }
 
-  reverse(user: User | null): boolean {
-    return !user;
+  reverse(user: User | null | undefined): boolean {
+    if (user === undefined) throw new Error(ShieldAuthStrategyError.NotAttached);
+    return user === null;
   }
 }

package/src/shield-basic-auth-hono.strategy.ts

@@ -11,7 +11,7 @@ import {
 export class ShieldBasicAuthHonoStrategy implements MiddlewareHonoPort {
   private readonly strategy: ShieldBasicAuthStrategy;
 
-  constructor(config: ShieldBasicAuthConfig) {
+  constructor(private readonly config: ShieldBasicAuthConfig) {
     this.strategy = new ShieldBasicAuthStrategy(config);
   }
 
@@ -20,7 +20,13 @@ export class ShieldBasicAuthHonoStrategy implements MiddlewareHonoPort {
       const context = new RequestContextHonoAdapter(c);
 
       if (this.strategy.evaluate(context)) return next();
-      throw new HTTPException(401, { message: ShieldBasicAuthStrategyError.Rejected });
+
+      throw new HTTPException(401, {
+        message: ShieldBasicAuthStrategyError.Rejected,
+        res: new Response(ShieldBasicAuthStrategyError.Rejected, {
+          headers: { "WWW-Authenticate": `Basic realm="${this.config.realm}"` },
+        }),
+      });
     };
   }
 }

package/src/shield-basic-auth.strategy.ts

@@ -3,7 +3,11 @@ import type { BasicAuthPasswordType } from "./basic-auth-password.vo";
 import type { BasicAuthUsernameType } from "./basic-auth-username.vo";
 import type { HasRequestHeader } from "./request-context.port";
 
-export type ShieldBasicAuthConfig = { username: BasicAuthUsernameType; password: BasicAuthPasswordType };
+export type ShieldBasicAuthConfig = {
+  username: BasicAuthUsernameType;
+  password: BasicAuthPasswordType;
+  realm: string;
+};
 
 export const ShieldBasicAuthStrategyError = { Rejected: "shield.basic.auth.rejected" };
 
@@ -16,11 +20,20 @@ export class ShieldBasicAuthStrategy {
     try {
       const credentials = atob(String(header).replace("Basic ", ""));
 
-      const [username, password] = credentials.split(":");
+      const index = credentials.indexOf(":");
 
-      if (username !== this.config.username) return false;
+      if (index === -1) return false;
 
-      if (password?.length !== this.config.password.length) return false;
+      const username = credentials.slice(0, index);
+      const password = credentials.slice(index + 1);
+
+      // Stryker disable next-line ConditionalExpression
+      if (username.length !== this.config.username.length) return false;
+
+      if (!timingSafeEqual(Buffer.from(username), Buffer.from(this.config.username))) return false;
+
+      // Stryker disable next-line ConditionalExpression
+      if (password.length !== this.config.password.length) return false;
 
       return timingSafeEqual(Buffer.from(password), Buffer.from(this.config.password));
     } catch {

package/src/shield-csrf.strategy.ts

@@ -1,6 +1,6 @@
 import type { HasRequestHeader, HasRequestMethod } from "./request-context.port";
 
-const STATE_CHANGING_METHODS = ["POST", "PUT", "PATCH", "DELETE"];
+const SAFE_METHODS = ["GET", "HEAD", "OPTIONS", "TRACE"];
 
 export type ShieldCsrfConfig = { origin: ReadonlyArray<string> };
 
@@ -10,7 +10,7 @@ export class ShieldCsrfStrategy {
   constructor(private readonly config: ShieldCsrfConfig) {}
 
   evaluate(context: HasRequestMethod & HasRequestHeader): boolean {
-    if (!STATE_CHANGING_METHODS.includes(context.request.method)) return true;
+    if (SAFE_METHODS.includes(context.request.method)) return true;
 
     const origin = context.request.header("origin");
 

package/src/shield-hcaptcha-hono-local.strategy.ts

@@ -3,7 +3,7 @@ import { HTTPException } from "hono/http-exception";
 import * as v from "valibot";
 import { HCaptchaSecretKey } from "./hcaptcha-secret-key.vo";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
-import type { HasRequestForm } from "./request-context.port";
+import type { HasRequestForm, HasRequestJson } from "./request-context.port";
 import { ShieldHcaptchaStrategy, ShieldHcaptchaStrategyField } from "./shield-hcaptcha.strategy";
 
 export const ShieldHcaptchaLocalStrategyError = { Rejected: "shield.hcaptcha.local.rejected" };
@@ -26,7 +26,9 @@ export class ShieldHcaptchaLocalHonoStrategy implements MiddlewareHonoPort {
     return async (_c, next) => {
       const form = new FormData();
       form.set(ShieldHcaptchaStrategyField, ShieldHcaptchaLocalHonoStrategy.TOKEN_LOCAL);
-      const context: HasRequestForm = { request: { form: async () => form } };
+      const context: HasRequestForm & HasRequestJson = {
+        request: { form: async () => form, json: async () => ({}) },
+      };
 
       if (await this.strategy.evaluate(context)) return next();
       throw new HTTPException(403, { message: ShieldHcaptchaLocalStrategyError.Rejected });

package/src/shield-hcaptcha.strategy.ts

@@ -1,6 +1,6 @@
 import { HCaptchaService } from "./hcaptcha.service";
 import type { HCaptchaSecretKeyType } from "./hcaptcha-secret-key.vo";
-import type { HasRequestForm } from "./request-context.port";
+import type { HasRequestForm, HasRequestJson } from "./request-context.port";
 
 export const ShieldHcaptchaStrategyError = { Rejected: "shield.hcaptcha.rejected" };
 
@@ -11,12 +11,19 @@ export class ShieldHcaptchaStrategy {
 
   constructor(private readonly secretKey: HCaptchaSecretKeyType) {}
 
-  async evaluate(context: HasRequestForm): Promise<boolean> {
+  async evaluate(context: HasRequestForm & HasRequestJson): Promise<boolean> {
     try {
       const form = await context.request.form();
-      const token = form.get(ShieldHcaptchaStrategyField);
+      const json = await context.request.json();
 
-      const result = await this.hcaptcha.verify(this.secretKey, token?.toString());
+      const fromForm = form.get(ShieldHcaptchaStrategyField)?.toString();
+      const fromJson = json[ShieldHcaptchaStrategyField];
+
+      const token = fromForm ?? (typeof fromJson === "string" ? fromJson : undefined);
+
+      if (!token) return false;
+
+      const result = await this.hcaptcha.verify(this.secretKey, token);
 
       return result.success;
     } catch {

package/src/shield-ip-blacklist.strategy.ts

@@ -1,6 +1,6 @@
 import * as v from "valibot";
 import { ClientIp, type ClientIpType } from "./client-ip.vo";
-import type { HasIdentityIp } from "./request-context.port";
+import type { HasIdentityRemoteIp } from "./request-context.port";
 
 export type ShieldIpBlacklistConfig = { blacklist: ReadonlyArray<ClientIpType> };
 
@@ -9,10 +9,10 @@ export const ShieldIpBlacklistStrategyError = { Rejected: "shield.ip.blacklist.r
 export class ShieldIpBlacklistStrategy {
   constructor(private readonly config: ShieldIpBlacklistConfig) {}
 
-  evaluate(context: HasIdentityIp): boolean {
-    const ip = v.safeParse(ClientIp, context.identity.ip());
+  evaluate(context: HasIdentityRemoteIp): boolean {
+    const ip = v.safeParse(ClientIp, context.identity.remoteIp());
 
-    if (!ip.success) return false;
+    if (!ip.success) return true;
     return !this.config.blacklist.includes(ip.output);
   }
 }

package/src/shield-ip-whitelist.strategy.ts

@@ -1,6 +1,6 @@
 import * as v from "valibot";
 import { ClientIp, type ClientIpType } from "./client-ip.vo";
-import type { HasIdentityIp } from "./request-context.port";
+import type { HasIdentityRemoteIp } from "./request-context.port";
 
 export type ShieldIpWhitelistConfig = { whitelist: ReadonlyArray<ClientIpType> };
 
@@ -9,8 +9,8 @@ export const ShieldIpWhitelistStrategyError = { Rejected: "shield.ip.whitelist.r
 export class ShieldIpWhitelistStrategy {
   constructor(private readonly config: ShieldIpWhitelistConfig) {}
 
-  evaluate(context: HasIdentityIp): boolean {
-    const ip = v.safeParse(ClientIp, context.identity.ip());
+  evaluate(context: HasIdentityRemoteIp): boolean {
+    const ip = v.safeParse(ClientIp, context.identity.remoteIp());
 
     if (!ip.success) return false;
     return this.config.whitelist.includes(ip.output);

package/src/shield-maintenance-hono.strategy.ts

@@ -1,5 +1,6 @@
 import type { MiddlewareHandler } from "hono";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
 import { type ShieldMaintenanceConfig, ShieldMaintenanceStrategy } from "./shield-maintenance.strategy";
 
 export class ShieldMaintenanceHonoStrategy implements MiddlewareHonoPort {
@@ -11,13 +12,15 @@ export class ShieldMaintenanceHonoStrategy implements MiddlewareHonoPort {
 
   handle(): MiddlewareHandler {
     return async (c, next) => {
-      const maintenance = this.strategy.evaluate();
+      const context = new RequestContextHonoAdapter(c);
+
+      if (this.strategy.shouldSkip(context)) return next();
+
+      const maintenance = await this.strategy.evaluate();
 
       if (!maintenance.enabled) return next();
 
-      return c.json({ reason: "maintenance" }, 503, {
-        "Retry-After": maintenance.RetryAfter.seconds.toString(),
-      });
+      return c.json(maintenance.body, maintenance.code, maintenance.headers);
     };
   }
 }

package/src/shield-maintenance.strategy.ts

@@ -1,17 +1,53 @@
 import * as tools from "@bgord/tools";
+import * as v from "valibot";
+import type { ReactiveConfigPort } from "./reactive-config.port";
+import type { HasRequestPath } from "./request-context.port";
 
-export type ShieldMaintenanceConfig = { enabled: boolean; RetryAfter?: tools.Duration };
+export const Maintenance = v.object({ enabled: tools.FeatureFlagValue });
+
+export type MaintenanceType = v.InferOutput<typeof Maintenance>;
+
+export type ShieldMaintenanceConfig = {
+  MaintenanceConfig: ReactiveConfigPort<MaintenanceType>;
+  RetryAfter?: tools.Duration;
+  skip?: ReadonlyArray<string | URLPattern>;
+};
+
+export type ShieldMaintenanceResult = {
+  enabled: boolean;
+  code: 503;
+  body: { reason: string };
+  headers: Record<string, string>;
+};
 
 export class ShieldMaintenanceStrategy {
-  private readonly enabled: boolean;
+  private readonly rounding = new tools.RoundingUpStrategy();
+  private readonly MaintenanceConfig?: ReactiveConfigPort<MaintenanceType>;
   private readonly RetryAfter: tools.Duration;
 
-  constructor(config?: ShieldMaintenanceConfig) {
-    this.enabled = config?.enabled ?? false;
+  constructor(private readonly config?: ShieldMaintenanceConfig) {
+    this.MaintenanceConfig = config?.MaintenanceConfig;
     this.RetryAfter = config?.RetryAfter ?? tools.Duration.Hours(1);
   }
 
-  evaluate(): { enabled: boolean; RetryAfter: tools.Duration } {
-    return { enabled: this.enabled, RetryAfter: this.RetryAfter };
+  shouldSkip(context: HasRequestPath): boolean {
+    return (
+      this.config?.skip?.some((rule) => {
+        if (rule instanceof URLPattern) return rule.test({ pathname: context.request.path });
+        return context.request.path.startsWith(rule);
+      }) ?? false
+    );
+  }
+
+  async evaluate(): Promise<ShieldMaintenanceResult> {
+    const maintenance = await this.MaintenanceConfig?.get();
+    const enabled = maintenance ? tools.FeatureFlag.from(maintenance.enabled).isEnabled() : false;
+
+    return {
+      enabled,
+      code: 503,
+      body: { reason: "maintenance" },
+      headers: { "Retry-After": this.rounding.round(this.RetryAfter.seconds).toString() },
+    };
   }
 }

package/src/shield-rate-limit.strategy.ts

@@ -4,7 +4,7 @@ import type { ClockPort } from "./clock.port";
 import type { RequestContext } from "./request-context.port";
 import type { SubjectRequestResolver } from "./subject-request-resolver.vo";
 
-export type ShieldRateLimitConfig = { resolver: SubjectRequestResolver; window: tools.Duration };
+export type ShieldRateLimitConfig = { resolver: SubjectRequestResolver; interval: tools.Duration };
 type ShieldRateLimitResult = { allowed: true } | { allowed: false; retryAfter: tools.Duration };
 
 type Dependencies = { Clock: ClockPort; CacheResolver: CacheResolverStrategy };
@@ -24,7 +24,7 @@ export class ShieldRateLimitStrategy {
 
     const limiter = await this.deps.CacheResolver.resolve(
       subject.hex,
-      async () => new tools.RateLimiter(this.config.window),
+      async () => new tools.RateLimiter(this.config.interval),
     );
 
     const decision = limiter.verify(this.deps.Clock.now());

package/src/shield-recaptcha.strategy.ts

@@ -2,7 +2,7 @@
 import * as tools from "@bgord/tools";
 import * as v from "valibot";
 import type { RecaptchaSecretKeyType } from "./recaptcha-secret-key.vo";
-import type { HasRequestForm, HasRequestHeader, HasRequestQuery } from "./request-context.port";
+import type { HasIdentityIp, HasRequestForm, HasRequestJson } from "./request-context.port";
 
 export type ShieldRecaptchaConfig = { secretKey: RecaptchaSecretKeyType; threshold?: number };
 export type RecaptchaResult = { success: boolean; score: number };
@@ -21,21 +21,25 @@ export class ShieldRecaptchaStrategy {
 
   constructor(private readonly config: ShieldRecaptchaConfig) {}
 
-  async evaluate(context: HasRequestHeader & HasRequestQuery & HasRequestForm): Promise<boolean> {
+  async evaluate(context: HasIdentityIp & HasRequestForm & HasRequestJson): Promise<boolean> {
     const threshold = this.config.threshold ?? ShieldRecaptchaStrategy.DEFAULT_THRESHOLD;
 
     try {
-      const header = context.request.header("x-recaptcha-token");
-      const query = context.request.query()["recaptchaToken"];
-      const remoteip = context.request.header("x-forwarded-for")?.split(",")[0] ?? "";
       const form = await context.request.form();
-      const formToken = form.get(ShieldRecaptchaStrategyField)?.toString();
+      const json = await context.request.json();
 
-      const token = header ?? query ?? formToken;
+      const fromForm = form.get(ShieldRecaptchaStrategyField)?.toString();
+      const fromJson = json[ShieldRecaptchaStrategyField];
+
+      const token = fromForm ?? (typeof fromJson === "string" ? fromJson : undefined);
 
       if (!token) return false;
 
-      const params = new URLSearchParams({ secret: this.config.secretKey, response: token, remoteip });
+      const remoteip = context.identity.ip();
+
+      const params = new URLSearchParams({ secret: this.config.secretKey, response: token });
+
+      if (remoteip) params.set("remoteip", remoteip);
 
       const response = await fetch(ShieldRecaptchaStrategy.URL, {
         method: "POST",
@@ -45,7 +49,9 @@ export class ShieldRecaptchaStrategy {
 
       const result: RecaptchaResult = await response.json();
 
-      if (!result.success || result.score < threshold) return false;
+      if (!result.success) return false;
+      if (typeof result.score !== "number" || result.score < threshold) return false;
+
       return true;
     } catch {
       return false;

package/src/shield-timeout-hono.strategy.ts

@@ -13,7 +13,7 @@ export class ShieldTimeoutHonoStrategy implements MiddlewareHonoPort {
 
     this.timeout = timeout(
       strategy.config.ms,
-      new HTTPException(408, { message: ShieldTimeoutStrategyError.Rejected }),
+      new HTTPException(504, { message: ShieldTimeoutStrategyError.Rejected }),
     );
   }
 

package/src/shield-webhook-hono.strategy.ts

@@ -20,7 +20,7 @@ export class ShieldWebhookHonoStrategy implements MiddlewareHonoPort {
       const context = new RequestContextHonoAdapter(c);
 
       if (await this.strategy.evaluate(context)) return next();
-      throw new HTTPException(403, { message: ShieldWebhookStrategyError.Rejected });
+      throw new HTTPException(401, { message: ShieldWebhookStrategyError.Rejected });
     };
   }
 }

package/src/shield-webhook.strategy.ts

@@ -1,4 +1,4 @@
-import type { RequestContext } from "./request-context.port";
+import type { HasRequestHeader, HasRequestText } from "./request-context.port";
 import type { WebhookBodyBuilderStrategy } from "./webhook-body-builder.strategy";
 import type { WebhookSignatureExtractorStrategy } from "./webhook-signature-extractor.strategy";
 import type { WebhookVerifierStrategy } from "./webhook-verifier.strategy";
@@ -14,7 +14,7 @@ export type ShieldWebhookStrategyConfig = {
 export class ShieldWebhookStrategy {
   constructor(private readonly config: ShieldWebhookStrategyConfig) {}
 
-  async evaluate(context: RequestContext): Promise<boolean> {
+  async evaluate(context: HasRequestHeader & HasRequestText): Promise<boolean> {
     const signature = this.config.WebhookSignatureExtractor.extract(context);
 
     if (!signature) return false;

package/src/simulated-error.middleware.ts

@@ -1,5 +1,7 @@
+export const SimulatedErrorMiddlewareError = { Simulated: "simulated.error" };
+
 export class SimulatedErrorMiddleware {
   evaluate(): never {
-    throw new Error("Simulated error");
+    throw new Error(SimulatedErrorMiddlewareError.Simulated);
   }
 }

package/src/sitemap-entry.vo.ts

@@ -28,7 +28,7 @@ export class SitemapEntry {
     const lastmod = this.entry.lastmod ? `<lastmod>${this.entry.lastmod}</lastmod>` : "";
     const changefreq = this.entry.changefreq ? `<changefreq>${this.entry.changefreq}</changefreq>` : "";
     const priority =
-      this.entry.priority !== undefined ? `<priority>${this.entry.priority.toFixed(1)}</priority>` : "";
+      this.entry.priority !== undefined ? `<priority>${this.entry.priority.toFixed(2)}</priority>` : "";
 
     return ["<url>", loc, lastmod, changefreq, priority, "</url>"].join("");
   }

package/src/sitemap-priority.vo.ts

@@ -6,6 +6,7 @@ export const SitemapPriority = v.pipe(
   v.number(SitemapPriorityError.Invalid),
   v.minValue(0, SitemapPriorityError.Invalid),
   v.maxValue(1, SitemapPriorityError.Invalid),
+  v.check((value) => Number(value.toFixed(2)) === value, SitemapPriorityError.Invalid),
   // Stryker disable next-line StringLiteral
   v.brand("SitemapPriority"),
 );

package/src/slower-hono.middleware.ts

@@ -1,15 +1,12 @@
 import type * as tools from "@bgord/tools";
 import type { MiddlewareHandler } from "hono";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
-import type { SleeperPort } from "./sleeper.port";
-import { SlowerMiddleware } from "./slower.middleware";
-
-type Dependencies = { Sleeper: SleeperPort };
+import { SlowerMiddleware, type SlowerMiddlewareDependencies } from "./slower.middleware";
 
 export class SlowerHonoMiddleware implements MiddlewareHonoPort {
   private readonly middleware: SlowerMiddleware;
 
-  constructor(offset: tools.Duration, deps: Dependencies) {
+  constructor(offset: tools.Duration, deps: SlowerMiddlewareDependencies) {
     this.middleware = new SlowerMiddleware(offset, deps);
   }
 

package/src/slower.middleware.ts

@@ -1,12 +1,12 @@
 import type * as tools from "@bgord/tools";
 import type { SleeperPort } from "./sleeper.port";
 
-type Dependencies = { Sleeper: SleeperPort };
+export type SlowerMiddlewareDependencies = { Sleeper: SleeperPort };
 
 export class SlowerMiddleware {
   constructor(
     private readonly offset: tools.Duration,
-    private readonly deps: Dependencies,
+    private readonly deps: SlowerMiddlewareDependencies,
   ) {}
 
   async evaluate(): Promise<void> {

package/src/sms-with-logger.adapter.ts

@@ -19,7 +19,7 @@ export class SmsWithLoggerAdapter implements SmsPort {
       this.deps.Logger.info({
         message: "SMS attempt",
         correlationId: CorrelationStorage.get(),
-        metadata: message.toJSON(),
+        metadata: { message: message.toJSON() },
         ...this.base,
       });
 

package/src/sse-hono.handler.ts

@@ -34,13 +34,15 @@ export class SseHonoHandler<Messages extends Message> implements HandlerHonoPort
           await stream.writeSSE({ event: message.name, data: JSON.stringify(message) });
         };
 
-        this.deps.registry.register(subject.hex.get(), send);
+        const registered = this.deps.registry.register(subject.hex.get(), send);
+
+        if (!registered) return;
 
         // Stryker disable all
         stream.onAbort(() => this.deps.registry.unregister(subject.hex.get(), send));
         // Stryker restore all
 
-        while (!stream.closed) {
+        while (!(stream.closed || stream.aborted)) {
           await stream.sleep(this.config.keepalive.ms);
           await stream.writeSSE({ event: "ping", data: JSON.stringify({ keepalive: true }) });
         }

package/src/sse-registry-collecting.adapter.ts

@@ -5,7 +5,9 @@ import type { SseRegistryPort, SseSenderType } from "./sse-registry.port";
 export class SseRegistryCollectingAdapter<Messages extends Message> implements SseRegistryPort<Messages> {
   public emitted: Array<{ identity: HashValueType; message: Messages }> = [];
 
-  register(_identity: HashValueType, _sender: SseSenderType<Messages>): void {}
+  register(_identity: HashValueType, _sender: SseSenderType<Messages>): boolean {
+    return true;
+  }
 
   unregister(_identity: HashValueType, _sender: SseSenderType<Messages>): void {}
 

package/src/sse-registry-noop.adapter.ts

@@ -3,7 +3,9 @@ import type { Message } from "./message.types";
 import type { SseRegistryPort, SseSenderType } from "./sse-registry.port";
 
 export class SseRegistryNoopAdapter<Messages extends Message> implements SseRegistryPort<Messages> {
-  register(_identity: HashValueType, _sender: SseSenderType<Messages>): void {}
+  register(_identity: HashValueType, _sender: SseSenderType<Messages>): boolean {
+    return true;
+  }
 
   unregister(_identity: HashValueType, _sender: SseSenderType<Messages>): void {}
 

package/src/sse-registry-with-limit.adapter.ts

@@ -11,10 +11,10 @@ type Dependencies<Messages extends Message> = {
 export class SseRegistryWithLimitAdapter<Messages extends Message> implements SseRegistryPort<Messages> {
   constructor(private readonly deps: Dependencies<Messages>) {}
 
-  register(identity: HashValueType, sender: SseSenderType<Messages>): void {
-    if (this.deps.inner.count(identity) >= this.deps.limit) return;
+  register(identity: HashValueType, sender: SseSenderType<Messages>): boolean {
+    if (this.deps.inner.count(identity) >= this.deps.limit) return false;
 
-    this.deps.inner.register(identity, sender);
+    return this.deps.inner.register(identity, sender);
   }
 
   unregister(identity: HashValueType, sender: SseSenderType<Messages>): void {