@bgord/bun 1.20.5 → 1.21.1

package/src/language-detector-cookie.strategy.ts

@@ -9,7 +9,7 @@ export class LanguageDetectorCookieStrategy<T extends tools.LanguageType>
   constructor(private readonly name: string) {}
 
   detect(context: HasRequestCookie, languages: Languages<T>): T | null {
-    const detected = context.request.cookie(this.name);
+    const detected = context.request.cookie(this.name)?.toLowerCase();
 
     return languages.isSupported(detected) ? detected : null;
   }

package/src/language-detector-header.strategy.ts

@@ -14,7 +14,19 @@ export class LanguageDetectorHeaderStrategy<T extends tools.LanguageType>
     // Example Accept-Language header: en-US,en;q=0.9,pl;q=0.8
     const incoming = header
       .split(",")
-      .map((language) => language.split(";")[0]?.trim().toLowerCase().split("-")[0]);
+      .map((part) => {
+        // Stryker disable next-line StringLiteral
+        const [tag = "", quality = "q=1"] = part.split(";");
+
+        return {
+          language: tag.trim().toLowerCase().split("-")[0],
+          quality: Number(quality.replace("q=", "")),
+        };
+      })
+      // Quality of 0 means the language is explicitly not acceptable
+      .filter((candidate) => candidate.quality > 0)
+      .sort((first, second) => second.quality - first.quality)
+      .map((candidate) => candidate.language);
 
     return incoming.find((language) => languages.isSupported(language)) ?? null;
   }

package/src/language-detector-hono.middleware.ts

@@ -16,7 +16,7 @@ export class LanguageDetectorHonoMiddleware<T extends tools.LanguageType> implem
     this.middleware = new LanguageDetectorMiddleware(config);
   }
 
-  handle(): MiddlewareHandler {
+  handle(): MiddlewareHandler<{ Variables: LanguageDetectorVariables }> {
     return async (c, next) => {
       const context = new RequestContextHonoAdapter(c);
 

package/src/language-detector-query.strategy.ts

@@ -9,7 +9,7 @@ export class LanguageDetectorQueryStrategy<T extends tools.LanguageType>
   constructor(private readonly name: string) {}
 
   detect(context: HasRequestQuery, languages: Languages<T>): T | null {
-    const detected = context.request.query()[this.name];
+    const detected = context.request.query()[this.name]?.toLowerCase();
 
     return languages.isSupported(detected) ? detected : null;
   }

package/src/language-detector.middleware.ts

@@ -1,7 +1,7 @@
 import type * as tools from "@bgord/tools";
 import type { LanguageDetectorStrategy } from "./language-detector.strategy";
 import type { Languages } from "./languages.vo";
-import type { RequestContext } from "./request-context.port";
+import type { HasRequestCookie, HasRequestHeaders, HasRequestQuery } from "./request-context.port";
 
 export const LanguageDetectorMiddlewareError = {
   MaxStrategies: "language.detector.middleware.max.strategies",
@@ -17,7 +17,7 @@ export class LanguageDetectorMiddleware<T extends tools.LanguageType> {
     if (config.strategies.length > 5) throw new Error(LanguageDetectorMiddlewareError.MaxStrategies);
   }
 
-  evaluate(context: RequestContext): T {
+  evaluate(context: HasRequestCookie & HasRequestHeaders & HasRequestQuery): T {
     for (const strategy of this.config.strategies) {
       const detected = strategy.detect(context, this.config.languages);
       if (detected !== null) return detected;

package/src/language-detector.strategy.ts

@@ -1,7 +1,7 @@
 import type * as tools from "@bgord/tools";
 import type { Languages } from "./languages.vo";
-import type { RequestContext } from "./request-context.port";
+import type { HasRequestCookie, HasRequestHeaders, HasRequestQuery } from "./request-context.port";
 
 export interface LanguageDetectorStrategy<T extends tools.LanguageType> {
-  detect(context: RequestContext, languages: Languages<T>): T | null;
+  detect(context: HasRequestCookie & HasRequestHeaders & HasRequestQuery, languages: Languages<T>): T | null;
 }

package/src/liveness-hono.handler.ts

@@ -8,6 +8,10 @@ export class LivenessHonoHandler implements HandlerHonoPort {
   private readonly handler = new LivenessHandler();
 
   handle() {
-    return factory.createHandlers(async (c) => c.json(this.handler.execute(), 200));
+    return factory.createHandlers(async (c) => {
+      const { headers, ...body } = this.handler.execute();
+
+      return c.json(body, 200, headers);
+    });
   }
 }

package/src/liveness.handler.ts

@@ -1,5 +1,5 @@
 export class LivenessHandler {
-  execute(): { ok: true } {
-    return { ok: true };
+  execute(): { ok: true; headers: Record<string, string> } {
+    return { ok: true, headers: { "Cache-Control": "no-store" } };
   }
 }

package/src/mailer-content-html.vo.ts

@@ -5,10 +5,9 @@ export const MailerContentHtmlError = { Invalid: "mailer.content.html.invalid" }
 export const MailerContentHtml = v.pipe(
   v.string(MailerContentHtmlError.Invalid),
   v.minLength(1, MailerContentHtmlError.Invalid),
-  v.maxLength(10_000, MailerContentHtmlError.Invalid),
+  v.maxLength(100_000, MailerContentHtmlError.Invalid),
   // Stryker disable next-line StringLiteral
   v.brand("MailerContentHtml"),
 );
 
 export type MailerContentHtmlType = v.InferOutput<typeof MailerContentHtml>;
-export type EmailAttachmentType = { filename: string; path: string };

package/src/mailer-smtp.adapter.ts

@@ -36,6 +36,7 @@ export class MailerSmtpAdapter implements MailerPort {
         host: config.SMTP_HOST,
         port: config.SMTP_PORT,
         auth: { user: config.SMTP_USER, pass: config.SMTP_PASS },
+        requireTLS: true,
       }),
     );
   }

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

@@ -19,7 +19,7 @@ export class MailerWithLoggerAdapter implements MailerPort {
       this.deps.Logger.info({
         message: "Mailer attempt",
         correlationId: CorrelationStorage.get(),
-        metadata: template.toJSON(),
+        metadata: { template: template.toJSON() },
         ...this.base,
       });
 
@@ -36,7 +36,7 @@ export class MailerWithLoggerAdapter implements MailerPort {
         message: "Mailer error",
         correlationId: CorrelationStorage.get(),
         error,
-        metadata: duration.stop(),
+        metadata: { duration: duration.stop() },
         ...this.base,
       });
 

package/src/markdown-generator.adapter.ts

@@ -2,6 +2,6 @@ import type { MarkdownGeneratorPort } from "./markdown-generator.port";
 
 export class MarkdownGeneratorAdapter implements MarkdownGeneratorPort {
   generate(template: string): string {
-    return Bun.markdown.html(template);
+    return Bun.markdown.html(template, { tagFilter: true, noHtmlBlocks: true, noHtmlSpans: true });
   }
 }

package/src/memory-consumption.service.ts

@@ -7,10 +7,6 @@ type MemoryConsumptionSnapshotType = { total: tools.Size; heap: { used: tools.Si
 // Heap used - how much of the reserved memory is actually used for the JS heap
 
 export class MemoryConsumption {
-  static get(): tools.Size {
-    return tools.Size.fromBytes(process.memoryUsage().rss);
-  }
-
   static snapshot(): MemoryConsumptionSnapshotType {
     const { rss, heapUsed, heapTotal } = process.memoryUsage();
 

package/src/nonce-provider-crypto.adapter.ts

@@ -4,7 +4,7 @@ import { NonceValue, type NonceValueType } from "./nonce-value.vo";
 
 export class NonceProviderCryptoAdapter implements NonceProviderPort {
   generate(): NonceValueType {
-    const buffer = new Uint8Array(8);
+    const buffer = new Uint8Array(16);
     crypto.getRandomValues(buffer);
 
     return v.parse(NonceValue, buffer.toHex());

package/src/nonce-provider-noop.adapter.ts

@@ -4,6 +4,6 @@ import { NonceValue, type NonceValueType } from "./nonce-value.vo";
 
 export class NonceProviderNoopAdapter implements NonceProviderPort {
   generate(): NonceValueType {
-    return v.parse(NonceValue, "0000000000000000");
+    return v.parse(NonceValue, "00000000000000000000000000000000");
   }
 }

package/src/nonce-value.vo.ts

@@ -5,8 +5,8 @@ export const NonceValueError = {
   InvalidHex: "nonce.value.invalid.hex",
 };
 
-// 16 hex chars allowed
-const CHARS_WHITELIST = /^[a-fA-F0-9]{16}$/;
+// 32 hex chars allowed
+const CHARS_WHITELIST = /^[a-fA-F0-9]{32}$/;
 
 export const NonceValue = v.pipe(
   v.string(NonceValueError.Type),

package/src/pdf-generator-with-logger.adapter.ts

@@ -39,7 +39,7 @@ export class PdfGeneratorWithLoggerAdapter implements PdfGeneratorPort {
         message: "PDF generator error",
         correlationId: CorrelationStorage.get(),
         error,
-        metadata: duration.stop(),
+        metadata: { duration: duration.stop() },
         ...this.base,
       });
 

package/src/prerequisite-verifier-memory.adapter.ts

@@ -12,7 +12,7 @@ export class PrerequisiteVerifierMemoryAdapter implements PrerequisiteVerifierPo
   constructor(private readonly config: Config) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
-    const memoryConsumption = MemoryConsumption.get();
+    const memoryConsumption = MemoryConsumption.snapshot().total;
 
     if (memoryConsumption.isSmallerThan(this.config.maximum)) return PrerequisiteVerification.success;
     return PrerequisiteVerification.failure(

package/src/prerequisite-verifier-translations.adapter.ts

@@ -26,12 +26,12 @@ export class PrerequisiteVerifierTranslationsAdapter<T extends tools.LanguageTyp
   async verify(): Promise<PrerequisiteVerificationResult> {
     const languages = this.config.values;
 
-    const dictionary: Partial<Record<T, ReadonlyArray<TranslationsKeyType>>> = {};
+    const translations = new Map<T, Set<TranslationsKeyType>>();
 
     for (const language of languages) {
       try {
-        const translations = await this.deps.TranslationsProvider.getTranslationsFor(language);
-        dictionary[language] = Object.keys(translations);
+        const dictionary = await this.deps.TranslationsProvider.getTranslationsFor(language);
+        translations.set(language, new Set(Object.keys(dictionary)));
       } catch {
         return PrerequisiteVerification.failure(`${language} translations not available`);
       }
@@ -39,16 +39,10 @@ export class PrerequisiteVerifierTranslationsAdapter<T extends tools.LanguageTyp
 
     const problems: Array<PrerequisiteTranslationsProblemType> = [];
 
-    for (const language in dictionary) {
-      // Stryker disable all
-      const translations = dictionary[language] ?? [];
-      // Stryker restore all
-
-      for (const key of translations) {
-        for (const supportedLanguage of languages) {
-          const exists = new Set(dictionary[supportedLanguage]).has(key);
-
-          if (!exists) problems.push({ key, existsIn: language, missingIn: supportedLanguage });
+    for (const [language, keys] of translations) {
+      for (const key of keys) {
+        for (const [supportedLanguage, supported] of translations) {
+          if (!supported.has(key)) problems.push({ key, existsIn: language, missingIn: supportedLanguage });
         }
       }
     }

package/src/prerequisite-verifier-with-logger.adapter.ts

@@ -16,7 +16,7 @@ export class PrerequisiteVerifierWithLoggerAdapter implements PrerequisiteVerifi
   private readonly base = (duration: tools.Duration) => ({
     component: "infra",
     operation: "prerequisite_verify",
-    metadata: duration,
+    metadata: { duration },
   });
 
   constructor(

package/src/randomness.strategy.ts

@@ -1,3 +1,4 @@
 export interface RandomnessStrategy {
+  // Returns a number in the [0, 1) range
   next(): number;
 }

package/src/reactive-config-noop.adapter.ts

@@ -2,12 +2,13 @@ import type { ReactiveConfigPort, ReactiveConfigSchema } from "./reactive-config
 import { StandardSchemaValidator } from "./standard-schema-validator.service";
 
 export class ReactiveConfigNoopAdapter<T extends object> implements ReactiveConfigPort<T> {
-  constructor(
-    private readonly schema: ReactiveConfigSchema<T>,
-    private readonly value: T,
-  ) {}
+  private readonly value: Readonly<T>;
+
+  constructor(schema: ReactiveConfigSchema<T>, value: T) {
+    this.value = Object.freeze(StandardSchemaValidator.validate(schema, value));
+  }
 
   async get(): Promise<Readonly<T>> {
-    return Object.freeze(StandardSchemaValidator.validate(this.schema, this.value));
+    return this.value;
   }
 }

package/src/reactive-config-with-cache.adapter.ts

@@ -14,6 +14,6 @@ export class ReactiveConfigWithCacheAdapter<T extends object> implements Reactiv
   async get(): Promise<Readonly<T>> {
     const key = await this.deps.HashContent.hash(this.subject);
 
-    return this.deps.CacheResolver.resolve(key, () => this.inner.get());
+    return Object.freeze(await this.deps.CacheResolver.resolve(key, () => this.inner.get()));
   }
 }

package/src/reactive-config-with-fallback.adapter.ts

@@ -2,17 +2,21 @@ import type { ReactiveConfigPort, ReactiveConfigSchema } from "./reactive-config
 import { StandardSchemaValidator } from "./standard-schema-validator.service";
 
 export class ReactiveConfigWithFallbackAdapter<T extends object> implements ReactiveConfigPort<T> {
+  private readonly fallback: Readonly<T>;
+
   constructor(
     private readonly inner: ReactiveConfigPort<T>,
-    private readonly schema: ReactiveConfigSchema<T>,
-    private readonly fallback: T,
-  ) {}
+    schema: ReactiveConfigSchema<T>,
+    fallback: T,
+  ) {
+    this.fallback = Object.freeze(StandardSchemaValidator.validate(schema, fallback));
+  }
 
   async get(): Promise<Readonly<T>> {
     try {
       return await this.inner.get();
     } catch {
-      return Object.freeze(StandardSchemaValidator.validate(this.schema, this.fallback));
+      return this.fallback;
     }
   }
 }

package/src/reactive-config-with-logger.adapter.ts

@@ -0,0 +1,50 @@
+import type { ClockPort } from "./clock.port";
+import { CorrelationStorage } from "./correlation-storage.service";
+import type { LoggerPort } from "./logger.port";
+import type { ReactiveConfigPort } from "./reactive-config.port";
+import { Stopwatch } from "./stopwatch.service";
+
+export type ReactiveConfigWithLoggerAdapterDependencies<T extends object> = {
+  inner: ReactiveConfigPort<T>;
+  Logger: LoggerPort;
+  Clock: ClockPort;
+};
+
+export class ReactiveConfigWithLoggerAdapter<T extends object> implements ReactiveConfigPort<T> {
+  private readonly base = { component: "infra", operation: "reactive_config" };
+
+  constructor(private readonly deps: ReactiveConfigWithLoggerAdapterDependencies<T>) {}
+
+  async get(): Promise<Readonly<T>> {
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Reactive config read attempt",
+        correlationId: CorrelationStorage.get(),
+        ...this.base,
+      });
+
+      const result = await this.deps.inner.get();
+
+      this.deps.Logger.info({
+        message: "Reactive config read success",
+        correlationId: CorrelationStorage.get(),
+        metadata: { duration: duration.stop() },
+        ...this.base,
+      });
+
+      return result;
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Reactive config read error",
+        correlationId: CorrelationStorage.get(),
+        error,
+        metadata: { duration: duration.stop() },
+        ...this.base,
+      });
+
+      throw error;
+    }
+  }
+}

package/src/readiness-hono.handler.ts

@@ -13,10 +13,9 @@ export class ReadinessHonoHandler implements HandlerHonoPort {
 
   handle() {
     return factory.createHandlers(async (c) => {
-      const readiness = await this.handler.check();
-      const code = readiness.ok ? 200 : 503;
+      const result = await this.handler.check();
 
-      return c.json(readiness, code);
+      return c.json(result.details, result.code, result.headers);
     });
   }
 }

package/src/readiness.handler.ts

@@ -6,9 +6,15 @@ import {
 
 export type ReadinessConfig = { prerequisites: ReadonlyArray<Prerequisite> };
 
+export enum ReadinessStatusCode {
+  Ready = 200,
+  NotReady = 503,
+}
+
 type ReadinessResult = {
-  ok: boolean;
+  code: ReadinessStatusCode;
   details: ReadonlyArray<{ label: PrerequisiteLabelType; outcome: PrerequisiteVerificationResult }>;
+  headers: Record<string, string>;
 };
 
 export class ReadinessHandler {
@@ -26,8 +32,13 @@ export class ReadinessHandler {
       })),
     );
 
+    // Undetermined keeps traffic flowing here, unlike healthcheck where it degrades to 207
     const ok = details.every((detail) => detail.outcome.outcome !== PrerequisiteVerificationOutcome.failure);
 
-    return { ok, details };
+    return {
+      code: ok ? ReadinessStatusCode.Ready : ReadinessStatusCode.NotReady,
+      details,
+      headers: { "Cache-Control": "no-store" },
+    };
   }
 }

package/src/redactor-metadata-compact-array.strategy.ts

@@ -14,6 +14,7 @@ export class RedactorMetadataCompactArray implements RedactorStrategy {
 
   redact<T>(input: T): T {
     if (!tools.isPlainObject(input)) return input;
+    if (!("metadata" in input)) return input;
 
     return {
       ...input,

package/src/redactor-metadata-compact-object.strategy.ts

@@ -14,6 +14,7 @@ export class RedactorMetadataCompactObject implements RedactorStrategy {
 
   redact<T>(input: T): T {
     if (!tools.isPlainObject(input)) return input;
+    if (!("metadata" in input)) return input;
 
     return {
       ...input,

package/src/redactor-url-query.strategy.ts

@@ -0,0 +1,33 @@
+import * as tools from "@bgord/tools";
+import type { RedactorStrategy } from "./redactor.strategy";
+import { RedactorMask } from "./redactor-mask.strategy";
+
+export class RedactorUrlQuery implements RedactorStrategy {
+  private readonly keys: Set<string>;
+
+  constructor(keys?: ReadonlyArray<string>) {
+    this.keys = new Set((keys?.length ? keys : RedactorMask.DEFAULT_KEYS).map((key) => key.toLowerCase()));
+  }
+
+  redact<T>(input: T): T {
+    if (!tools.isPlainObject(input)) return input;
+    if (typeof input["url"] !== "string") return input;
+
+    return { ...input, url: this.mask(input["url"]) };
+  }
+
+  private mask(url: string): string {
+    const [base, query] = url.split("?");
+
+    if (!query) return url;
+
+    const masked = new URLSearchParams(
+      Array.from(new URLSearchParams(query), ([key, value]) => [
+        key,
+        this.keys.has(key.toLowerCase()) ? "***" : value,
+      ]),
+    );
+
+    return `${base}?${masked.toString()}`;
+  }
+}

package/src/remote-file-storage-disk.adapter.ts

@@ -3,6 +3,7 @@ import * as v from "valibot";
 import type { DirectoryEnsurerPort } from "./directory-ensurer.port";
 import type { FileCleanerPort } from "./file-cleaner.port";
 import type { FileCopierPort } from "./file-copier.port";
+import type { FileInspectionPort } from "./file-inspection.port";
 import type { FileRenamerPort } from "./file-renamer.port";
 import type { HashFilePort } from "./hash-file.port";
 import type { NonceProviderPort } from "./nonce-provider.port";
@@ -15,6 +16,7 @@ import type {
 
 type Dependencies = {
   HashFile: HashFilePort;
+  FileInspection: FileInspectionPort;
   FileCleaner: FileCleanerPort;
   FileRenamer: FileRenamerPort;
   FileCopier: FileCopierPort;
@@ -71,11 +73,9 @@ export class RemoteFileStorageDiskAdapter implements RemoteFileStoragePort {
   async getStream(key: tools.ObjectKeyType): Promise<ReadableStream | null> {
     const path = this.resolveKeyToAbsoluteFilePath(key);
 
-    try {
-      return Bun.file(path.get()).stream();
-    } catch {
-      return null;
-    }
+    if (!(await this.deps.FileInspection.exists(path))) return null;
+
+    return Bun.file(path.get()).stream();
   }
 
   async delete(key: tools.ObjectKeyType): Promise<tools.ObjectKeyType> {

package/src/request-context-hono.adapter.ts

@@ -26,6 +26,7 @@ export class RequestContextHonoAdapter implements RequestContext {
         return headers;
       },
       query: () => context.req.query(),
+      queries: () => context.req.queries(),
       params: () => context.req.param(),
       param: (name: string) => context.req.param(name),
       cookie: (name) => getCookie(context)[name],
@@ -65,6 +66,7 @@ export class RequestContextHonoAdapter implements RequestContext {
         context.req.header("x-real-ip") ||
         context.req.header("x-forwarded-for")?.split(",")[0]?.trim() ||
         getConnInfo(context).remote.address,
+      remoteIp: () => getConnInfo(context).remote.address,
       ua: () => context.req.header("user-agent"),
     };
 

package/src/request-context.port.ts

@@ -8,6 +8,7 @@ export interface RequestContext {
     url(): string;
     header(name: string): string | undefined;
     query(): Record<string, string>;
+    queries(): Record<string, ReadonlyArray<string>>;
     params(): Record<string, string>;
     param(name: string): string | undefined;
     cookie(name: string): string | undefined;
@@ -21,6 +22,7 @@ export interface RequestContext {
   readonly identity: {
     userId(): UUIDType | undefined;
     ip(): string | undefined;
+    remoteIp(): string | undefined;
     ua(): string | undefined;
   };
 
@@ -59,6 +61,10 @@ export interface HasRequestQuery {
   readonly request: { query(): Record<string, string> };
 }
 
+export interface HasRequestQueries {
+  readonly request: { queries(): Record<string, ReadonlyArray<string>> };
+}
+
 export interface HasRequestParams {
   readonly request: { params(): Record<string, string> };
 }
@@ -71,7 +77,7 @@ export interface HasRequestCookie {
   readonly request: { cookie(name: string): string | undefined };
 }
 
-export interface HasRequestJSON {
+export interface HasRequestJson {
   readonly request: { json(): Promise<Record<string, unknown>> };
 }
 
@@ -91,6 +97,10 @@ export interface HasIdentityIp {
   readonly identity: { ip(): string | undefined };
 }
 
+export interface HasIdentityRemoteIp {
+  readonly identity: { remoteIp(): string | undefined };
+}
+
 export interface HasIdentityUa {
   readonly identity: { ua(): string | undefined };
 }

package/src/sealer-aes-gcm.adapter.ts

@@ -5,7 +5,10 @@ import type { SealerPort } from "./sealer.port";
 
 type Dependencies = { CryptoKeyProvider: CryptoKeyProviderPort };
 
-export const SealerAesGcmAdapterError = { InvalidPayload: "sealer.aes.gcm.adapter.invalid.payload" };
+export const SealerAesGcmAdapterError = {
+  InvalidPayload: "sealer.aes.gcm.adapter.invalid.payload",
+  Undefined: "sealer.aes.gcm.adapter.undefined.value",
+};
 
 export class SealerAesGcmAdapter implements SealerPort {
   private static readonly PREFIX = "sealed:gcm:";
@@ -13,6 +16,8 @@ export class SealerAesGcmAdapter implements SealerPort {
   constructor(private readonly deps: Dependencies) {}
 
   async seal(value: unknown): Promise<string> {
+    if (value === undefined) throw new Error(SealerAesGcmAdapterError.Undefined);
+
     const key = await this.deps.CryptoKeyProvider.get();
     const iv = EncryptionIV.generate();
 

package/src/secure-key-generator-crypto.adapter.ts

@@ -2,9 +2,17 @@ import type * as tools from "@bgord/tools";
 import type { SecureKeyGeneratorPort } from "./secure-key-generator.port";
 
 export class SecureKeyGeneratorCryptoAdapter implements SecureKeyGeneratorPort {
+  // crypto.getRandomValues is spec-limited to a 65536-byte view
+  static readonly MAX_BYTES = 65_536;
+
   generate(bytes: tools.IntegerPositiveType): Uint8Array {
     const buffer = new Uint8Array(bytes);
-    crypto.getRandomValues(buffer);
+
+    // Stryker disable next-line EqualityOperator
+    for (let offset = 0; offset < bytes; offset += SecureKeyGeneratorCryptoAdapter.MAX_BYTES) {
+      crypto.getRandomValues(buffer.subarray(offset, offset + SecureKeyGeneratorCryptoAdapter.MAX_BYTES));
+    }
+
     return buffer;
   }
 }

package/src/security-rule-bait-routes.strategy.ts

@@ -7,7 +7,7 @@ export class SecurityRuleBaitRoutesStrategy implements SecurityRuleStrategy {
   constructor(private readonly routes: ReadonlyArray<string>) {}
 
   async isViolated(context: HasRequestPath): Promise<boolean> {
-    return this.routes.includes(context.request.path);
+    return this.routes.includes(context.request.path.toLowerCase().replace(/\/+$/, ""));
   }
 
   get name(): SecurityRuleNameType {

package/src/security-rule-honey-pot-field.strategy.ts

@@ -1,17 +1,18 @@
 import * as v from "valibot";
-import type { HasRequestJSON } from "./request-context.port";
+import type { HasRequestForm, HasRequestJson } from "./request-context.port";
 import type { SecurityRuleStrategy } from "./security-rule.strategy";
 import { SecurityRuleName, type SecurityRuleNameType } from "./security-rule-name.vo";
 
 export class SecurityRuleHoneyPotFieldStrategy implements SecurityRuleStrategy {
   constructor(private readonly field: string) {}
 
-  async isViolated(context: HasRequestJSON): Promise<boolean> {
+  async isViolated(context: HasRequestJson & HasRequestForm): Promise<boolean> {
     const body = await context.request.json();
+    const form = await context.request.form();
 
-    const value = body[this.field];
+    const value = body[this.field] ?? form.get(this.field);
 
-    return value !== undefined && value !== null && value !== "";
+    return value !== null && value !== "";
   }
 
   get name(): SecurityRuleNameType {