@bgord/bun 1.20.5 → 1.21.1

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

@@ -11,15 +11,17 @@ export class SseRegistryWithLoggerAdapter<Messages extends Message> implements S
 
   constructor(private readonly deps: Dependencies<Messages>) {}
 
-  register(identity: HashValueType, sender: SseSenderType<Messages>): void {
+  register(identity: HashValueType, sender: SseSenderType<Messages>): boolean {
+    const registered = this.deps.inner.register(identity, sender);
+
     this.deps.Logger.info({
-      message: "SSE sender registered",
-      metadata: { identity },
+      message: registered ? "SSE sender registered" : "SSE sender rejected",
+      metadata: { identity, registered },
       correlationId: CorrelationStorage.get(),
       ...this.base,
     });
 
-    this.deps.inner.register(identity, sender);
+    return registered;
   }
 
   unregister(identity: HashValueType, sender: SseSenderType<Messages>): void {

package/src/sse-registry.adapter.ts

@@ -5,14 +5,22 @@ import type { SseRegistryPort, SseSenderType } from "./sse-registry.port";
 export class SseRegistryAdapter<Messages extends Message> implements SseRegistryPort<Messages> {
   private readonly senders = new Map<HashValueType, Set<SseSenderType<Messages>>>();
 
-  register(identity: HashValueType, connection: SseSenderType<Messages>): void {
+  register(identity: HashValueType, connection: SseSenderType<Messages>): boolean {
     if (!this.senders.has(identity)) this.senders.set(identity, new Set());
 
     this.senders.get(identity)?.add(connection);
+
+    return true;
   }
 
   unregister(identity: HashValueType, connection: SseSenderType<Messages>): void {
-    this.senders.get(identity)?.delete(connection);
+    const senders = this.senders.get(identity);
+
+    if (!senders) return;
+
+    senders.delete(connection);
+
+    if (senders.size === 0) this.senders.delete(identity);
   }
 
   async emit<M extends Messages>(identity: HashValueType, message: M): Promise<void> {

package/src/sse-registry.port.ts

@@ -4,7 +4,7 @@ import type { Message } from "./message.types";
 export type SseSenderType<Messages extends Message> = <M extends Messages>(message: M) => Promise<void>;
 
 export interface SseRegistryPort<Messages extends Message> {
-  register(identity: HashValueType, sender: SseSenderType<Messages>): void;
+  register(identity: HashValueType, sender: SseSenderType<Messages>): boolean;
 
   unregister(identity: HashValueType, sender: SseSenderType<Messages>): void;
 

package/src/ssr-bun.service.ts

@@ -13,7 +13,7 @@ export class SSRBun {
     const service = new SSRService(deps, config);
 
     return async (request: Request): Promise<Response> => {
-      const nonce = service.nonce;
+      const nonce = service.generateNonce();
 
       const response = await handler(request, nonce);
 

package/src/ssr.service.ts

@@ -33,7 +33,7 @@ export class SSRService {
     private readonly config?: SSRConfig,
   ) {}
 
-  get nonce(): NonceValueType {
+  generateNonce(): NonceValueType {
     return this.deps.NonceProvider.generate();
   }
 

package/src/standard-schema-validator.service.ts

@@ -8,7 +8,7 @@ export class StandardSchemaValidator {
   static validate<Output>(schema: StandardSchemaV1<unknown, Output>, raw: unknown): Output {
     const result = schema["~standard"].validate(raw);
 
-    if (result instanceof Promise) throw new Error(StandardSchemaValidatorError.NoAsyncSchema);
+    if ("then" in result) throw new Error(StandardSchemaValidatorError.NoAsyncSchema);
     if (result.issues) throw new Error(result.issues[0]?.message);
     return result.value;
   }

package/src/static-config.adapter.ts

@@ -4,6 +4,6 @@ export class StaticConfigAdapter<T> implements StaticConfigPort<T> {
   constructor(private readonly value: T) {}
 
   get(): Readonly<T> {
-    return this.value;
+    return Object.freeze(this.value);
   }
 }

package/src/static-files-hono.service.ts

@@ -73,8 +73,8 @@ export class StaticFilesHono {
 
           const contentType = context.res.headers.get("Content-Type");
 
-          if (contentType?.startsWith("text/html")) staticDocumentHeaders(context, noop);
-          else staticAssetHeaders(context, noop);
+          if (contentType?.startsWith("text/html")) await staticDocumentHeaders(context, noop);
+          else await staticAssetHeaders(context, noop);
         },
         etag(),
         serveStatic({ root, precompressed: true, onFound: strategy }),

package/src/subject-application-resolver.vo.ts

@@ -1,7 +1,7 @@
 import type { Hash } from "./hash.vo";
 import type { HashContentStrategy } from "./hash-content.strategy";
 import type { SubjectSegmentApplicationStrategy } from "./subject-segment-application.strategy";
-import type { SubjectSegmentType } from "./subject-segment-request.strategy";
+import type { SubjectSegmentsRawType } from "./subject-segment-request.strategy";
 
 type Dependencies = { HashContent: HashContentStrategy };
 
@@ -19,8 +19,8 @@ export class SubjectApplicationResolver {
     if (this.segments.length > 10) throw new Error(SubjectApplicationResolverError.TooManySegments);
   }
 
-  async resolve(): Promise<{ hex: Hash; raw: ReadonlyArray<SubjectSegmentType> }> {
-    const segments = this.segments.map((segment) => segment.create());
+  async resolve(): Promise<{ hex: Hash; raw: SubjectSegmentsRawType }> {
+    const segments = this.segments.map((segment) => [segment.label, segment.create()] as const);
     const subject = JSON.stringify(segments);
 
     const hex = await this.deps.HashContent.hash(subject);

package/src/subject-request-resolver.vo.ts

@@ -1,7 +1,10 @@
 import type { Hash } from "./hash.vo";
 import type { HashContentStrategy } from "./hash-content.strategy";
 import type { RequestContext } from "./request-context.port";
-import type { SubjectSegmentRequestStrategy, SubjectSegmentType } from "./subject-segment-request.strategy";
+import type {
+  SubjectSegmentRequestStrategy,
+  SubjectSegmentsRawType,
+} from "./subject-segment-request.strategy";
 
 type Dependencies = { HashContent: HashContentStrategy };
 
@@ -19,8 +22,8 @@ export class SubjectRequestResolver {
     if (this.segments.length > 10) throw new Error(SubjectRequestResolverError.TooManySegments);
   }
 
-  async resolve(context: RequestContext): Promise<{ hex: Hash; raw: ReadonlyArray<SubjectSegmentType> }> {
-    const segments = this.segments.map((segment) => segment.create(context));
+  async resolve(context: RequestContext): Promise<{ hex: Hash; raw: SubjectSegmentsRawType }> {
+    const segments = this.segments.map((segment) => [segment.label, segment.create(context)] as const);
     const subject = JSON.stringify(segments);
 
     const hex = await this.deps.HashContent.hash(subject);

package/src/subject-segment-application.strategy.ts

@@ -1,7 +1,8 @@
 import type { SubjectSegmentType } from "./subject-segment-request.strategy";
 
-export const SubjectSegmentApplicationEmpty: SubjectSegmentType = "__absent__";
+export const SubjectSegmentApplicationEmpty: SubjectSegmentType = null;
 
 export interface SubjectSegmentApplicationStrategy {
+  readonly label: string;
   create(): SubjectSegmentType;
 }

package/src/subject-segment-build.strategy.ts

@@ -6,6 +6,8 @@ import {
 import type { SubjectSegmentType } from "./subject-segment-request.strategy";
 
 export class SubjectSegmentBuildStrategy implements SubjectSegmentApplicationStrategy {
+  readonly label = "build";
+
   constructor(private readonly build?: tools.PackageVersion) {}
 
   create(): SubjectSegmentType {

package/src/subject-segment-cookie.strategy.ts

@@ -8,6 +8,10 @@ import {
 export class SubjectSegmentCookieStrategy implements SubjectSegmentRequestStrategy {
   constructor(private readonly name: string) {}
 
+  get label(): string {
+    return `cookie:${this.name}`;
+  }
+
   create(context: HasRequestCookie): SubjectSegmentType {
     return context.request.cookie(this.name) ?? SubjectSegmentRequestEmpty;
   }

package/src/subject-segment-env.strategy.ts

@@ -3,6 +3,8 @@ import type { SubjectSegmentApplicationStrategy } from "./subject-segment-applic
 import type { SubjectSegmentType } from "./subject-segment-request.strategy";
 
 export class SubjectSegmentEnvStrategy implements SubjectSegmentApplicationStrategy {
+  readonly label = "env";
+
   constructor(private readonly type: NodeEnvironmentEnum) {}
 
   create(): SubjectSegmentType {

package/src/subject-segment-fixed.strategy.ts

@@ -4,6 +4,8 @@ import type { SubjectSegmentRequestStrategy, SubjectSegmentType } from "./subjec
 export class SubjectSegmentFixedStrategy
   implements SubjectSegmentRequestStrategy, SubjectSegmentApplicationStrategy
 {
+  readonly label = "fixed";
+
   constructor(private readonly value: string) {}
 
   create(): SubjectSegmentType {

package/src/subject-segment-header.strategy.ts

@@ -8,6 +8,10 @@ import {
 export class SubjectSegmentHeaderStrategy implements SubjectSegmentRequestStrategy {
   constructor(private readonly name: string) {}
 
+  get label(): string {
+    return `header:${this.name}`;
+  }
+
   create(context: HasRequestHeader): SubjectSegmentType {
     return context.request.header(this.name) ?? SubjectSegmentRequestEmpty;
   }

package/src/subject-segment-ip.strategy.ts

@@ -6,6 +6,8 @@ import {
 } from "./subject-segment-request.strategy";
 
 export class SubjectSegmentIpStrategy implements SubjectSegmentRequestStrategy {
+  readonly label = "ip";
+
   create(context: HasIdentityIp): SubjectSegmentType {
     return context.identity.ip() ?? SubjectSegmentRequestEmpty;
   }

package/src/subject-segment-method.strategy.ts

@@ -0,0 +1,10 @@
+import type { HasRequestMethod } from "./request-context.port";
+import type { SubjectSegmentRequestStrategy, SubjectSegmentType } from "./subject-segment-request.strategy";
+
+export class SubjectSegmentMethodStrategy implements SubjectSegmentRequestStrategy {
+  readonly label = "method";
+
+  create(context: HasRequestMethod): SubjectSegmentType {
+    return context.request.method;
+  }
+}

package/src/subject-segment-param.strategy.ts

@@ -8,6 +8,10 @@ import {
 export class SubjectSegmentParamStrategy implements SubjectSegmentRequestStrategy {
   constructor(private readonly param: string) {}
 
+  get label(): string {
+    return `param:${this.param}`;
+  }
+
   create(context: HasRequestParam): SubjectSegmentType {
     return context.request.param(this.param) ?? SubjectSegmentRequestEmpty;
   }

package/src/subject-segment-path.strategy.ts

@@ -2,6 +2,8 @@ import type { HasRequestPath } from "./request-context.port";
 import type { SubjectSegmentRequestStrategy, SubjectSegmentType } from "./subject-segment-request.strategy";
 
 export class SubjectSegmentPathStrategy implements SubjectSegmentRequestStrategy {
+  readonly label = "path";
+
   create(context: HasRequestPath): SubjectSegmentType {
     return context.request.path;
   }

package/src/subject-segment-query.strategy.ts

@@ -1,4 +1,4 @@
-import type { HasRequestQuery } from "./request-context.port";
+import type { HasRequestQueries } from "./request-context.port";
 import type { SubjectSegmentType } from "./subject-segment-request.strategy";
 import {
   SubjectSegmentRequestEmpty,
@@ -6,14 +6,14 @@ import {
 } from "./subject-segment-request.strategy";
 
 export class SubjectSegmentQueryStrategy implements SubjectSegmentRequestStrategy {
-  create(context: HasRequestQuery): SubjectSegmentType {
-    const query = context.request.query();
+  readonly label = "query";
 
-    const keys = Object.keys(query).toSorted();
+  create(context: HasRequestQueries): SubjectSegmentType {
+    const queries = context.request.queries();
 
-    const result = keys.map((key) => `${key}=${query[key]}`).join("&");
+    const keys = Object.keys(queries).toSorted();
 
-    if (!result) return SubjectSegmentRequestEmpty;
-    return result;
+    if (keys.length === 0) return SubjectSegmentRequestEmpty;
+    return JSON.stringify(keys.map((key) => [key, queries[key]]));
   }
 }

package/src/subject-segment-request.strategy.ts

@@ -3,23 +3,27 @@ import type {
   HasIdentityUserId,
   HasRequestCookie,
   HasRequestHeader,
+  HasRequestMethod,
   HasRequestParam,
   HasRequestPath,
-  HasRequestQuery,
+  HasRequestQueries,
 } from "./request-context.port";
 
-export type SubjectSegmentType = string;
+export type SubjectSegmentType = string | null;
+export type SubjectSegmentsRawType = ReadonlyArray<readonly [string, SubjectSegmentType]>;
 
-export const SubjectSegmentRequestEmpty: SubjectSegmentType = "__absent__";
+export const SubjectSegmentRequestEmpty: SubjectSegmentType = null;
 
 type RequestContextCapabilities = HasRequestCookie &
   HasRequestHeader &
+  HasRequestMethod &
   HasRequestPath &
-  HasRequestQuery &
+  HasRequestQueries &
   HasRequestParam &
   HasIdentityIp &
   HasIdentityUserId;
 
 export interface SubjectSegmentRequestStrategy {
+  readonly label: string;
   create(context: RequestContextCapabilities): SubjectSegmentType;
 }

package/src/subject-segment-user.strategy.ts

@@ -6,6 +6,8 @@ import {
 } from "./subject-segment-request.strategy";
 
 export class SubjectSegmentUserStrategy implements SubjectSegmentRequestStrategy {
+  readonly label = "user";
+
   create(context: HasIdentityUserId): SubjectSegmentType {
     return context.identity.userId() ?? SubjectSegmentRequestEmpty;
   }

package/src/time-zone-offset-hono.middleware.ts

@@ -13,7 +13,7 @@ export class TimeZoneOffsetHonoMiddleware implements MiddlewareHonoPort {
     this.middleware = new TimeZoneOffsetMiddleware();
   }
 
-  handle(): MiddlewareHandler {
+  handle(): MiddlewareHandler<{ Variables: TimeZoneOffsetVariables }> {
     return async (c, next) => {
       const context = new RequestContextHonoAdapter(c);
       const offset = this.middleware.evaluate(context);

package/src/time-zone-offset.middleware.ts

@@ -1,12 +1,14 @@
 import * as tools from "@bgord/tools";
 import * as v from "valibot";
-import type { RequestContext } from "./request-context.port";
+import type { HasRequestHeader } from "./request-context.port";
 
 export class TimeZoneOffsetMiddleware {
+  // Matches Date.prototype.getTimezoneOffset(): the negation of the UTC offset,
+  // so a client in UTC+2 sends -120 and one in UTC-5 sends 300
   static readonly TIME_ZONE_OFFSET_HEADER_NAME = "time-zone-offset";
   static readonly DEFAULT = tools.Duration.Minutes(0);
 
-  evaluate(context: RequestContext): tools.Duration {
+  evaluate(context: HasRequestHeader): tools.Duration {
     const header = context.request.header(TimeZoneOffsetMiddleware.TIME_ZONE_OFFSET_HEADER_NAME);
     const offset = v.safeParse(tools.TimeZoneOffsetValue, header);
 

package/src/timekeeper-google.adapter.ts

@@ -3,7 +3,7 @@ import * as v from "valibot";
 import type { TimekeeperPort } from "./timekeeper.port";
 
 export class TimekeeperGoogleAdapter implements TimekeeperPort {
-  static URL = v.parse(tools.UrlWithoutSlash, "https://www.google.com/generate_204");
+  static readonly URL = v.parse(tools.UrlWithoutSlash, "https://www.google.com/generate_204");
 
   async get(): Promise<tools.Timestamp | null> {
     try {

package/src/timing-hono.middleware.ts

@@ -1,15 +1,12 @@
 import { createMiddleware } from "hono/factory";
-import type { ClockPort } from "./clock.port";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
 import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
-import { TimingMiddleware } from "./timing.middleware";
-
-type Dependencies = { Clock: ClockPort };
+import { TimingMiddleware, type TimingMiddlewareDependencies } from "./timing.middleware";
 
 export class TimingHonoMiddleware implements MiddlewareHonoPort {
   private readonly middleware: TimingMiddleware;
 
-  constructor(deps: Dependencies) {
+  constructor(deps: TimingMiddlewareDependencies) {
     this.middleware = new TimingMiddleware(deps);
   }
 
@@ -21,7 +18,7 @@ export class TimingHonoMiddleware implements MiddlewareHonoPort {
 
       if (!timing) return next();
 
-      c.header(TimingMiddleware.HEADER_NAME, timing);
+      c.header(TimingMiddleware.HEADER_NAME, timing, { append: true });
     });
   }
 }

package/src/timing.middleware.ts

@@ -1,21 +1,30 @@
 import type { ClockPort } from "./clock.port";
-import type { RequestContext } from "./request-context.port";
+import type { HasRequestHeader } from "./request-context.port";
 import { Stopwatch } from "./stopwatch.service";
 
-type Dependencies = { Clock: ClockPort };
+export type TimingMiddlewareDependencies = { Clock: ClockPort };
 
 export class TimingMiddleware {
   static readonly HEADER_NAME = "Server-Timing";
 
-  constructor(private readonly deps: Dependencies) {}
+  constructor(private readonly deps: TimingMiddlewareDependencies) {}
 
-  async measure(context: RequestContext, action: () => void | Promise<void>): Promise<string | null> {
-    if (context.request.header("accept")?.toLowerCase().startsWith("text/event-stream")) return null;
+  async measure(context: HasRequestHeader, action: () => void | Promise<void>): Promise<string | null> {
+    if (TimingMiddleware.isEventStream(context.request.header("accept"))) return null;
 
     const stopwatch = new Stopwatch(this.deps);
 
     await action();
 
-    return `total;dur=${stopwatch.stop().ms}`;
+    return `total;dur=${Math.max(0, stopwatch.stop().ms)}`;
+  }
+
+  private static isEventStream(accept: string | undefined): boolean {
+    if (!accept) return false;
+
+    return accept
+      .toLowerCase()
+      .split(",")
+      .some((type) => type.split(";")[0]?.trim() === "text/event-stream");
   }
 }

package/src/trailing-slash-hono.middleware.ts

@@ -19,9 +19,9 @@ export class TrailingSlashHonoMiddleware implements MiddlewareHonoPort {
       if (!result.redirect) return next();
 
       const url = new URL(context.request.url());
-      url.pathname = result.pathname;
+      const location = result.pathname + url.search + url.hash;
 
-      return c.redirect(url.toString(), 301);
+      return c.redirect(location, result.status);
     });
   }
 }

package/src/trailing-slash.middleware.ts

@@ -1,11 +1,23 @@
 import type { HasRequestPath } from "./request-context.port";
 
-export type TrailingSlashResult = { redirect: false } | { redirect: true; pathname: string };
+export type TrailingSlashResult = { redirect: false } | { redirect: true; pathname: string; status: 308 };
+
+const TRAILING_SLASHES = /\/+$/;
+const LEADING_SLASHES = /^\/+/;
 
 export class TrailingSlashMiddleware {
+  // RFC 7231 6.4.7 - 308 preserves the request method and body, unlike 301.
+  static readonly STATUS = 308;
+
   evaluate(context: HasRequestPath): TrailingSlashResult {
     if (!context.request.path.endsWith("/")) return { redirect: false };
     if (context.request.path === "/") return { redirect: false };
-    return { redirect: true, pathname: context.request.path.slice(0, -1) };
+
+    const pathname = (context.request.path.replace(TRAILING_SLASHES, "") || "/").replace(
+      LEADING_SLASHES,
+      "/",
+    );
+
+    return { redirect: true, pathname, status: TrailingSlashMiddleware.STATUS };
   }
 }

package/src/translations-provider-json.adapter.ts

@@ -1,7 +1,11 @@
 import * as tools from "@bgord/tools";
 import * as v from "valibot";
 import type { FileReaderJsonPort } from "./file-reader-json.port";
-import type { TranslationsProviderPort, TranslationsType } from "./translations-provider.port";
+import {
+  Translations,
+  type TranslationsProviderPort,
+  type TranslationsType,
+} from "./translations-provider.port";
 
 type Config = { path?: tools.DirectoryPathRelativeType };
 type Dependencies = { FileReaderJson: FileReaderJsonPort };
@@ -20,10 +24,6 @@ export class TranslationsProviderJsonAdapter implements TranslationsProviderPort
       tools.Filename.fromParts(language, "json"),
     );
 
-    try {
-      return await this.deps.FileReaderJson.read(path);
-    } catch (error) {
-      return {};
-    }
+    return v.parse(Translations, await this.deps.FileReaderJson.read(path));
   }
 }

package/src/translations-provider.port.ts

@@ -1,4 +1,9 @@
 import type * as tools from "@bgord/tools";
+import * as v from "valibot";
+
+export const TranslationsError = { Invalid: "translations.invalid" };
+
+export const Translations = v.record(v.string(), v.string(TranslationsError.Invalid));
 
 export type TranslationsKeyType = string;
 export type TranslationsValueType = string;

package/src/weak-etag-extractor-header.strategy.ts

@@ -3,10 +3,14 @@ import type { HasRequestHeader } from "./request-context.port";
 import type { WeakETagExtractorStrategy } from "./weak-etag-extractor.strategy";
 
 export class WeakETagExtractorHeaderStrategy implements WeakETagExtractorStrategy {
+  private static readonly PREFIX = "W/";
+
   detect(context: HasRequestHeader): tools.WeakETag | null {
     try {
       const header = context.request.header(tools.WeakETag.IF_MATCH_HEADER_NAME);
 
+      if (!header?.replace(WeakETagExtractorHeaderStrategy.PREFIX, "").trim()) return null;
+
       return tools.WeakETag.fromHeader(header);
     } catch {
       return null;

package/src/weak-etag-extractor-hono.middleware.ts

@@ -16,7 +16,7 @@ export class WeakETagExtractorHonoMiddleware implements MiddlewareHonoPort {
     this.middleware = new WeakETagExtractorMiddleware(config);
   }
 
-  handle(): MiddlewareHandler {
+  handle(): MiddlewareHandler<{ Variables: WeakETagVariables }> {
     return async (c, next) => {
       const context = new RequestContextHonoAdapter(c);
       const weakETag = this.middleware.evaluate(context);

package/src/weak-etag-extractor-param.strategy.ts

@@ -9,6 +9,8 @@ export class WeakETagExtractorParamStrategy implements WeakETagExtractorStrategy
     try {
       const value = context.request.param(this.name);
 
+      if (!value?.trim()) return null;
+
       return tools.WeakETag.fromHeader(`W/${value}`);
     } catch {
       return null;

package/src/weak-etag-extractor.strategy.ts

@@ -1,6 +1,6 @@
 import type * as tools from "@bgord/tools";
-import type { RequestContext } from "./request-context.port";
+import type { HasRequestHeader, HasRequestParam } from "./request-context.port";
 
 export interface WeakETagExtractorStrategy {
-  detect(context: RequestContext): tools.WeakETag | null;
+  detect(context: HasRequestHeader & HasRequestParam): tools.WeakETag | null;
 }

package/src/webhook-signature-extractor.strategy.ts

@@ -1,6 +1,6 @@
-import type { RequestContext } from "./request-context.port";
+import type { HasRequestHeader } from "./request-context.port";
 import type { WebhookSignatureType } from "./webhook-signature.vo";
 
 export interface WebhookSignatureExtractorStrategy {
-  extract(context: RequestContext): WebhookSignatureType | null;
+  extract(context: HasRequestHeader): WebhookSignatureType | null;
 }

package/src/woodchopper-dispatcher-async.strategy.ts

@@ -8,11 +8,6 @@ enum WoodchopperDispatcherAsyncState {
   closed = "closed",
 }
 
-export const WoodchopperDispatcherAsyncError = {
-  ClosedWithBufferedEntries: (count: tools.IntegerPositiveType) =>
-    `woodchopper.dispatcher.async.closed.with.buffered.entries.${count}`,
-};
-
 export class WoodchopperDispatcherAsync implements WoodchopperDispatcher {
   onError?: (error: unknown) => void;
 
@@ -46,12 +41,12 @@ export class WoodchopperDispatcherAsync implements WoodchopperDispatcher {
 
     this.state = WoodchopperDispatcherAsyncState.closed;
 
-    if (this.buffer.length > 0) {
-      const message = WoodchopperDispatcherAsyncError.ClosedWithBufferedEntries(
-        tools.Int.positive(this.buffer.length),
-      );
-
-      this.onError?.(new Error(message));
+    for (const entry of this.buffer) {
+      try {
+        this.sink.write(entry);
+      } catch (error) {
+        this.onError?.(error);
+      }
     }
 
     this.buffer.length = 0;

package/dist/cron-scheduler-croner.adapter.d.ts

@@ -1,15 +0,0 @@
-import type { CronSchedulerPort } from "./cron-scheduler.port";
-import type { CronTask } from "./cron-task.vo";
-export declare const CronSchedulerCronerAdapterError: {
-    MissingDependency: string;
-};
-export declare class CronSchedulerCronerAdapter implements CronSchedulerPort {
-    private readonly croner;
-    private static readonly importer;
-    private readonly tasks;
-    private constructor();
-    static build(): Promise<CronSchedulerCronerAdapter>;
-    schedule(task: CronTask): void;
-    verify(): Promise<boolean>;
-}
-//# sourceMappingURL=cron-scheduler-croner.adapter.d.ts.map

package/dist/cron-scheduler-croner.adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cron-scheduler-croner.adapter.d.ts","sourceRoot":"","sources":["../src/cron-scheduler-croner.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG/C,eAAO,MAAM,+BAA+B;IAC1C,iBAAiB;CAClB,CAAC;AAIF,qBAAa,0BAA2B,YAAW,iBAAiB;IAQ9C,OAAO,CAAC,QAAQ,CAAC,MAAM;IAP3C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAG9B;IAEF,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkD;IAExE,OAAO,eAAuD;IAE9D,OAAa,KAAK,IAAI,OAAO,CAAC,0BAA0B,CAAC,CAIxD;IAED,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAE7B;IAEK,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAE/B;CACF"}