@bgord/bun 1.6.6 → 1.7.0

package/src/cache-repository-node-cache.adapter.ts

@@ -1,15 +1,13 @@
-import type * as tools from "@bgord/tools";
 import NodeCache from "node-cache";
-import type { CacheRepositoryPort } from "./cache-repository.port";
+import type { CacheRepositoryPort, CacheRepositoryTtlType } from "./cache-repository.port";
 import type { Hash } from "./hash.vo";
 
 export class CacheRepositoryNodeCacheAdapter implements CacheRepositoryPort {
   private readonly store: NodeCache;
 
-  constructor(private readonly config: { ttl: tools.Duration }) {
+  constructor(config: CacheRepositoryTtlType) {
     this.store = new NodeCache({
-      stdTTL: config.ttl.seconds,
-      checkperiod: config.ttl.seconds,
+      stdTTL: config.type === "finite" ? config.ttl.seconds : 0,
       deleteOnExpire: true,
       maxKeys: 100_000,
       useClones: false,
@@ -31,8 +29,4 @@ export class CacheRepositoryNodeCacheAdapter implements CacheRepositoryPort {
   async flush() {
     this.store.flushAll();
   }
-
-  get ttl() {
-    return this.config.ttl;
-  }
 }

package/src/cache-repository-noop.adapter.ts

@@ -1,8 +1,7 @@
-import type * as tools from "@bgord/tools";
-import type { CacheRepositoryPort } from "./cache-repository.port";
+import type { CacheRepositoryPort, CacheRepositoryTtlType } from "./cache-repository.port";
 
 export class CacheRepositoryNoopAdapter implements CacheRepositoryPort {
-  constructor(private readonly config: { ttl: tools.Duration }) {}
+  constructor(_config: CacheRepositoryTtlType) {}
 
   async get<T>(): Promise<T | null> {
     return null;
@@ -13,8 +12,4 @@ export class CacheRepositoryNoopAdapter implements CacheRepositoryPort {
   async delete() {}
 
   async flush() {}
-
-  get ttl() {
-    return this.config.ttl;
-  }
 }

package/src/cache-repository.port.ts

@@ -1,10 +1,11 @@
 import type * as tools from "@bgord/tools";
 import type { Hash } from "./hash.vo";
 
+export type CacheRepositoryTtlType = { type: "finite"; ttl: tools.Duration } | { type: "infinite" };
+
 export interface CacheRepositoryPort {
   get<T>(subject: Hash): Promise<T | null>;
   set<T>(subject: Hash, value: T): Promise<void>;
   delete(subject: Hash): Promise<void>;
   flush(): Promise<void>;
-  get ttl(): tools.Duration;
 }

package/src/cache-resolver-simple.strategy.ts

@@ -0,0 +1,33 @@
+import type { CacheRepositoryPort } from "./cache-repository.port";
+import { type CacheResolverStrategy, CacheSourceEnum } from "./cache-resolver.strategy";
+import type { Hash } from "./hash.vo";
+
+type Dependencies = { CacheRepository: CacheRepositoryPort };
+
+export class CacheResolverSimpleStrategy implements CacheResolverStrategy {
+  constructor(private readonly deps: Dependencies) {}
+
+  async resolve<T>(subject: Hash, producer: () => Promise<T>): Promise<T> {
+    const result = await this.resolveWithContext(subject, producer);
+
+    return result.value;
+  }
+
+  async resolveWithContext<T>(
+    subject: Hash,
+    producer: () => Promise<T>,
+  ): Promise<{ value: T; source: CacheSourceEnum }> {
+    const cached = await this.deps.CacheRepository.get<T>(subject);
+
+    if (cached !== null) return { value: cached, source: CacheSourceEnum.hit };
+
+    const value = await producer();
+    await this.deps.CacheRepository.set(subject, value);
+
+    return { value, source: CacheSourceEnum.miss };
+  }
+
+  async flush() {
+    await this.deps.CacheRepository.flush();
+  }
+}

package/src/cache-resolver.strategy.ts

@@ -0,0 +1,17 @@
+import type { Hash } from "./hash.vo";
+
+export enum CacheSourceEnum {
+  hit = "hit",
+  miss = "",
+}
+
+export interface CacheResolverStrategy {
+  resolve<T>(subject: Hash, producer: () => Promise<T>): Promise<T>;
+
+  resolveWithContext<T>(
+    subject: Hash,
+    producer: () => Promise<T>,
+  ): Promise<{ value: T; source: CacheSourceEnum }>;
+
+  flush(): Promise<void>;
+}

package/src/cache-response.middleware.ts

@@ -1,9 +1,9 @@
 import { createMiddleware } from "hono/factory";
 import type { ContentfulStatusCode } from "hono/utils/http-status";
-import type { CacheResolverPort } from "./cache-resolver.port";
+import type { CacheResolverStrategy } from "./cache-resolver.strategy";
 import type { CacheSubjectResolver } from "./cache-subject-resolver.vo";
 
-type Dependencies = { CacheResolver: CacheResolverPort };
+type Dependencies = { CacheResolver: CacheResolverStrategy };
 
 type CacheResponseOptions = { enabled: boolean; resolver: CacheSubjectResolver };
 

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

@@ -1,9 +1,9 @@
 import type { Context } from "hono";
-import type { CacheSubjectSegmentPort, CacheSubjectSegmentType } from "./cache-subject-segment.port";
+import type { CacheSubjectSegmentStrategy, CacheSubjectSegmentType } from "./cache-subject-segment.strategy";
 import type { Hash } from "./hash.vo";
-import type { HashContentPort } from "./hash-content.port";
+import type { HashContentStrategy } from "./hash-content.strategy";
 
-type Dependencies = { HashContent: HashContentPort };
+type Dependencies = { HashContent: HashContentStrategy };
 
 export const CacheSubjectResolverError = { NoSegments: "cache.subject.no.segments" };
 
@@ -11,7 +11,7 @@ export class CacheSubjectResolver {
   private readonly SEPARATOR = "|";
 
   constructor(
-    private readonly segments: CacheSubjectSegmentPort[],
+    private readonly segments: CacheSubjectSegmentStrategy[],
     private readonly deps: Dependencies,
   ) {
     if (this.segments.length === 0) throw new Error(CacheSubjectResolverError.NoSegments);

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

@@ -0,0 +1,12 @@
+import type { Context } from "hono";
+import { getCookie } from "hono/cookie";
+import type { CacheSubjectSegmentStrategy } from "./cache-subject-segment.strategy";
+
+export class CacheSubjectSegmentCookieStrategy implements CacheSubjectSegmentStrategy {
+  constructor(private readonly name: string) {}
+
+  create(context?: Context) {
+    if (!context) return "";
+    return getCookie(context, this.name) ?? "";
+  }
+}

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

@@ -0,0 +1,9 @@
+import type { CacheSubjectSegmentStrategy } from "./cache-subject-segment.strategy";
+
+export class CacheSubjectSegmentFixedStrategy implements CacheSubjectSegmentStrategy {
+  constructor(private readonly value: string) {}
+
+  create() {
+    return this.value;
+  }
+}

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

@@ -0,0 +1,10 @@
+import type { Context } from "hono";
+import type { CacheSubjectSegmentStrategy } from "./cache-subject-segment.strategy";
+
+export class CacheSubjectSegmentHeaderStrategy implements CacheSubjectSegmentStrategy {
+  constructor(private readonly name: string) {}
+
+  create(context?: Context) {
+    return context?.req.header(this.name) ?? "";
+  }
+}

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

@@ -0,0 +1,10 @@
+import type { Context } from "hono";
+import type { CacheSubjectSegmentStrategy } from "./cache-subject-segment.strategy";
+import { ClientFromHono } from "./client-from-hono.adapter";
+
+export class CacheSubjectSegmentIpStrategy implements CacheSubjectSegmentStrategy {
+  create(context?: Context) {
+    if (!context) return "";
+    return ClientFromHono.translate(context).ip;
+  }
+}

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

@@ -0,0 +1,8 @@
+import type { Context } from "hono";
+import type { CacheSubjectSegmentStrategy } from "./cache-subject-segment.strategy";
+
+export class CacheSubjectSegmentPathStrategy implements CacheSubjectSegmentStrategy {
+  create(context?: Context) {
+    return context?.req.path ?? "";
+  }
+}

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

@@ -0,0 +1,13 @@
+import type { Context } from "hono";
+import type { CacheSubjectSegmentStrategy } from "./cache-subject-segment.strategy";
+
+export class CacheSubjectSegmentQueryStrategy implements CacheSubjectSegmentStrategy {
+  create(context?: Context) {
+    const query = context?.req.query() ?? {};
+
+    const keys = Object.keys(query).toSorted();
+
+    if (keys.length === 0) return "";
+    return keys.map((key) => `${key}=${query[key]}`).join("&");
+  }
+}

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

@@ -0,0 +1,8 @@
+import type { Context } from "hono";
+import type { CacheSubjectSegmentStrategy } from "./cache-subject-segment.strategy";
+
+export class CacheSubjectSegmentUserStrategy implements CacheSubjectSegmentStrategy {
+  create(context?: Context) {
+    return context?.get("user")?.id ?? "anon";
+  }
+}

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

@@ -0,0 +1,7 @@
+import type { Context } from "hono";
+
+export type CacheSubjectSegmentType = string;
+
+export interface CacheSubjectSegmentStrategy {
+  create(context?: Context): CacheSubjectSegmentType;
+}

package/src/certificate-inspector-tls.adapter.ts

@@ -6,7 +6,7 @@ import type { ClockPort } from "./clock.port";
 type Dependencies = { Clock: ClockPort };
 
 export class CertificateInspectorTLSAdapter implements CertificateInspectorPort {
-  private static readonly rounding = new tools.RoundToNearest();
+  private static readonly rounding = new tools.RoundingToNearestStrategy();
 
   constructor(private readonly deps: Dependencies) {}
 
@@ -28,8 +28,9 @@ export class CertificateInspectorTLSAdapter implements CertificateInspectorPort
 
           if (!certificate?.valid_to) return settle({ success: false });
 
-          const validToMs = new Date(certificate.valid_to).getTime();
-          const daysRemaining = tools.Duration.Ms(validToMs - this.deps.Clock.nowMs()).days;
+          const daysRemaining = tools.Timestamp.fromDateLike(certificate.valid_to).difference(
+            this.deps.Clock.now(),
+          ).days;
 
           settle({
             success: true,

package/src/client-from-hono.adapter.ts

@@ -0,0 +1,16 @@
+import type { Context } from "hono";
+import { getConnInfo } from "hono/bun";
+import { Client } from "./client.vo";
+
+export class ClientFromHono {
+  static translate(context: Context): Client {
+    const info = getConnInfo(context);
+
+    const ip =
+      context.req.header("x-real-ip") || context.req.header("x-forwarded-for") || info?.remote?.address;
+
+    const ua = context.req.header("user-agent");
+
+    return Client.fromParts(ip, ua);
+  }
+}

package/src/client-ip.vo.ts

@@ -0,0 +1,10 @@
+import { z } from "zod/v4";
+
+export const ClientIpError = { Type: "client.ip.type", InvalidUnknown: "client.ip.invalid.unknown" };
+
+export const ClientIp = z
+  .ipv4(ClientIpError.Type)
+  .or(z.literal("anon", ClientIpError.InvalidUnknown))
+  .brand("ClientUserAgent");
+
+export type ClientIpType = z.infer<typeof ClientIp>;

package/src/client-user-agent.vo.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/v4";
+
+export const ClientUserAgentError = {
+  Type: "client.user.agent.type",
+  Empty: "client.user.agent.empty",
+  TooLong: "client.user.agent.too.long",
+};
+
+export const ClientUserAgent = z
+  .string(ClientUserAgentError.Type)
+  .min(1, ClientUserAgentError.Empty)
+  .max(128, ClientUserAgentError.TooLong)
+  .brand("ClientUserAgent");
+
+export type ClientUserAgentType = z.infer<typeof ClientUserAgent>;

package/src/client.vo.ts

@@ -1,26 +1,48 @@
-import type { Context } from "hono";
-import { getConnInfo } from "hono/bun";
+import { ClientIp, type ClientIpType } from "./client-ip.vo";
+import { ClientUserAgent, type ClientUserAgentType } from "./client-user-agent.vo";
 
-export type ClientIpType = string;
-export type ClientUaType = string;
-export type ClientType = { ip: ClientIpType; ua: ClientUaType };
+export type ClientType = { ip: ClientIpType; ua: ClientUserAgentType };
 
 export class Client {
+  private static DEFAULT_IP = ClientIp.parse("anon");
+
   private constructor(private readonly value: ClientType) {}
 
-  static fromParts(ip: ClientIpType | null | undefined, ua: ClientUaType | null | undefined): Client {
-    return new Client({ ip: ip ?? "anon", ua: ua ?? "anon" });
+  static fromPartsSafe(
+    ip: ClientIpType | null | undefined,
+    ua: ClientUserAgentType | null | undefined,
+  ): Client {
+    return new Client({
+      ip: ip ?? Client.DEFAULT_IP,
+      ua: ClientUserAgent.parse((ua ?? "anon").toLowerCase()),
+    });
+  }
+
+  static fromParts(ip: string | null | undefined, ua: string | null | undefined): Client {
+    return new Client({
+      ip: ClientIp.parse(ip ?? "anon"),
+      ua: ClientUserAgent.parse((ua ?? "anon").toLowerCase()),
+    });
+  }
+
+  equals(another: Client): boolean {
+    return this.value.ip === another.value.ip && this.value.ua === another.value.ua;
   }
 
-  static fromHonoContext(context: Context): Client {
-    const info = getConnInfo(context);
+  matchesUa(ua: ClientUserAgentType): boolean {
+    return this.value.ua.includes(ua.toLowerCase());
+  }
 
-    const ip =
-      context.req.header("x-real-ip") || context.req.header("x-forwarded-for") || info?.remote?.address;
+  matchesIp(ip: ClientIpType): boolean {
+    return this.value.ip.includes(ip.toLowerCase());
+  }
 
-    const ua = context.req.header("user-agent");
+  get ip(): ClientIpType {
+    return this.value.ip;
+  }
 
-    return Client.fromParts(ip, ua);
+  get ua(): ClientUserAgentType {
+    return this.value.ua;
   }
 
   toJSON(): ClientType {

package/src/clock-fixed.adapter.ts

@@ -4,10 +4,6 @@ import type { ClockPort } from "./clock.port";
 export class ClockFixedAdapter implements ClockPort {
   constructor(private value: tools.Timestamp) {}
 
-  nowMs() {
-    return this.value.ms;
-  }
-
   now() {
     return this.value;
   }

package/src/clock-offset.adapter.ts

@@ -0,0 +1,15 @@
+import type * as tools from "@bgord/tools";
+import type { ClockPort } from "./clock.port";
+
+type Dependencies = { Clock: ClockPort };
+
+export class ClockOffsetAdapter implements ClockPort {
+  constructor(
+    private readonly offset: tools.Duration,
+    private readonly deps: Dependencies,
+  ) {}
+
+  now() {
+    return this.deps.Clock.now().add(this.offset);
+  }
+}

package/src/clock-system.adapter.ts

@@ -2,10 +2,6 @@ import * as tools from "@bgord/tools";
 import type { ClockPort } from "./clock.port";
 
 export class ClockSystemAdapter implements ClockPort {
-  nowMs() {
-    return tools.TimestampValue.parse(Date.now());
-  }
-
   now() {
     return tools.Timestamp.fromNumber(Date.now());
   }

package/src/clock.port.ts

@@ -1,7 +1,5 @@
 import type * as tools from "@bgord/tools";
 
 export interface ClockPort {
-  nowMs(): tools.TimestampValueType;
-
   now(): tools.Timestamp;
 }

package/src/command-envelope.ts

@@ -12,5 +12,5 @@ export const createCommandEnvelope = (deps: Dependencies) =>
   ({
     id: deps.IdProvider.generate(),
     correlationId: CorrelationStorage.get(),
-    createdAt: deps.Clock.nowMs(),
+    createdAt: deps.Clock.now().ms,
   }) as const;

package/src/crypto-aes-gcm.service.ts

@@ -0,0 +1,37 @@
+import { EncryptionIV } from "./encryption-iv.vo";
+
+/** @public */
+export const CryptoAesGcmError = { InvalidPayload: "aes.gcm.crypto.invalid.payload" };
+
+export class CryptoAesGcm {
+  static readonly ALGORITHM = "AES-GCM";
+
+  static async encrypt(key: CryptoKey, plaintext: ArrayBuffer, iv: Uint8Array): Promise<Uint8Array> {
+    const encrypted = await crypto.subtle.encrypt(
+      { name: CryptoAesGcm.ALGORITHM, iv: iv as BufferSource },
+      key,
+      plaintext,
+    );
+
+    const ciphertext = new Uint8Array(encrypted);
+    const output = new Uint8Array(iv.length + ciphertext.length);
+
+    output.set(iv, 0);
+    output.set(ciphertext, iv.length);
+
+    return output;
+  }
+
+  static async decrypt(key: CryptoKey, payload: Uint8Array): Promise<ArrayBuffer> {
+    if (payload.length < EncryptionIV.LENGTH + 1) throw new Error(CryptoAesGcmError.InvalidPayload);
+
+    const iv = payload.subarray(0, EncryptionIV.LENGTH);
+    const ciphertext = payload.subarray(EncryptionIV.LENGTH);
+
+    return crypto.subtle.decrypt(
+      { name: CryptoAesGcm.ALGORITHM, iv: iv as BufferSource },
+      key,
+      ciphertext as BufferSource,
+    );
+  }
+}

package/src/crypto-key-provider-with-cache.adapter.ts

@@ -0,0 +1,28 @@
+import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import { CacheSubjectResolver } from "./cache-subject-resolver.vo";
+import { CacheSubjectSegmentFixedStrategy } from "./cache-subject-segment-fixed.strategy";
+import type { CryptoKeyProviderPort } from "./crypto-key-provider.port";
+import type { HashContentStrategy } from "./hash-content.strategy";
+
+type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy };
+
+export class CryptoKeyProviderWithCacheAdapter implements CryptoKeyProviderPort {
+  constructor(
+    private readonly config: { id: string; inner: CryptoKeyProviderPort },
+    private readonly deps: Dependencies,
+  ) {}
+
+  async get(): Promise<CryptoKey> {
+    const resolver = new CacheSubjectResolver(
+      [
+        new CacheSubjectSegmentFixedStrategy("crypto_key_provider"),
+        new CacheSubjectSegmentFixedStrategy(this.config.id),
+      ],
+      this.deps,
+    );
+
+    const subject = await resolver.resolve();
+
+    return this.deps.CacheResolver.resolve<CryptoKey>(subject.hex, () => this.config.inner.get());
+  }
+}

package/src/decorators.service.ts

@@ -2,7 +2,7 @@ import * as tools from "@bgord/tools";
 import type { LoggerPort } from "./logger.port";
 
 export class Decorators {
-  private readonly rounding = new tools.RoundToDecimal(2);
+  private readonly rounding = new tools.RoundingDecimalStrategy(2);
 
   constructor(private readonly logger: LoggerPort) {}
 

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

@@ -0,0 +1,57 @@
+import type * as tools from "@bgord/tools";
+import { CryptoAesGcm } from "./crypto-aes-gcm.service";
+import type { CryptoKeyProviderPort } from "./crypto-key-provider.port";
+import type { EncryptionPort, EncryptionRecipe } from "./encryption.port";
+import { EncryptionIV } from "./encryption-iv.vo";
+
+type Dependencies = { CryptoKeyProvider: CryptoKeyProviderPort };
+
+export const EncryptionAesGcmAdapterError = { MissingFile: "encryption.aes.gcm.adapter.missing.file" };
+
+export class EncryptionAesGcmAdapter implements EncryptionPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async encrypt(recipe: EncryptionRecipe) {
+    const key = await this.deps.CryptoKeyProvider.get();
+    const iv = EncryptionIV.generate();
+
+    const file = Bun.file(recipe.input.get());
+    const exists = await file.exists();
+    if (!exists) throw new Error(EncryptionAesGcmAdapterError.MissingFile);
+
+    const plaintext = await file.arrayBuffer();
+    const output = await CryptoAesGcm.encrypt(key, plaintext, iv);
+
+    await Bun.write(recipe.output.get(), output);
+
+    return recipe.output;
+  }
+
+  async decrypt(recipe: EncryptionRecipe) {
+    const key = await this.deps.CryptoKeyProvider.get();
+
+    const file = Bun.file(recipe.input.get());
+    const exists = await file.exists();
+    if (!exists) throw new Error(EncryptionAesGcmAdapterError.MissingFile);
+
+    const bytes = new Uint8Array(await file.arrayBuffer());
+
+    const decrypted = await CryptoAesGcm.decrypt(key, bytes);
+
+    await Bun.write(recipe.output.get(), decrypted);
+
+    return recipe.output;
+  }
+
+  async view(input: tools.FilePathRelative | tools.FilePathAbsolute) {
+    const key = await this.deps.CryptoKeyProvider.get();
+
+    const file = Bun.file(input.get());
+    const exists = await file.exists();
+    if (!exists) throw new Error(EncryptionAesGcmAdapterError.MissingFile);
+
+    const bytes = new Uint8Array(await file.arrayBuffer());
+
+    return CryptoAesGcm.decrypt(key, bytes);
+  }
+}

package/src/environment-loader-noop.adapter.ts

@@ -0,0 +1,16 @@
+import type { z } from "zod/v4";
+import type { NodeEnvironmentEnum } from "../src/node-env.vo";
+import type { EnvironmentLoaderPort, EnvironmentResultType } from "./environment-loader.port";
+
+export class EnvironmentLoaderNoopAdapter<Schema extends z.ZodObject<any>>
+  implements EnvironmentLoaderPort<Schema>
+{
+  constructor(
+    private readonly config: { type: NodeEnvironmentEnum; Schema: Schema },
+    private readonly deterministic: Omit<EnvironmentResultType<Schema>, "type">,
+  ) {}
+
+  async load(): Promise<Readonly<EnvironmentResultType<Schema>>> {
+    return Object.freeze({ ...this.config.Schema.parse(this.deterministic), type: this.config.type });
+  }
+}

package/src/environment-loader-process-safe.adapter.ts

@@ -1,12 +1,12 @@
 import type { z } from "zod/v4";
 import type { NodeEnvironmentEnum } from "../src/node-env.vo";
-import type { CacheResolverPort } from "./cache-resolver.port";
+import type { CacheResolverStrategy } from "./cache-resolver.strategy";
 import { CacheSubjectResolver } from "./cache-subject-resolver.vo";
-import { CacheSubjectSegmentFixed } from "./cache-subject-segment-fixed";
+import { CacheSubjectSegmentFixedStrategy } from "./cache-subject-segment-fixed.strategy";
 import type { EnvironmentLoaderPort } from "./environment-loader.port";
-import type { HashContentPort } from "./hash-content.port";
+import type { HashContentStrategy } from "./hash-content.strategy";
 
-type Dependencies = { CacheResolver: CacheResolverPort; HashContent: HashContentPort };
+type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy };
 
 export class EnvironmentLoaderProcessSafeAdapter<Schema extends z.ZodObject<any>>
   implements EnvironmentLoaderPort<Schema>
@@ -18,7 +18,7 @@ export class EnvironmentLoaderProcessSafeAdapter<Schema extends z.ZodObject<any>
   ) {}
 
   async load() {
-    const resolver = new CacheSubjectResolver([new CacheSubjectSegmentFixed("env")], this.deps);
+    const resolver = new CacheSubjectResolver([new CacheSubjectSegmentFixedStrategy("env")], this.deps);
     const subject = await resolver.resolve();
 
     const result = await this.deps.CacheResolver.resolve(subject.hex, async () =>

package/src/event-envelope.ts

@@ -21,7 +21,7 @@ export const createEventEnvelope = (stream: EventStreamType, deps: Dependencies)
   ({
     id: deps.IdProvider.generate(),
     correlationId: CorrelationStorage.get(),
-    createdAt: deps.Clock.nowMs(),
+    createdAt: deps.Clock.now().ms,
     stream,
     version: 1,
   }) as const;

package/src/event-handler-bare.strategy.ts

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

package/src/event-handler-noop.strategy.ts

@@ -0,0 +1,9 @@
+import type { z } from "zod/v4";
+import type { GenericEventSchema } from "./event.types";
+import type { EventHandlerStrategy } from "./event-handler.strategy";
+
+export class EventHandlerNoopStrategy implements EventHandlerStrategy {
+  handle<T extends { name: z.infer<GenericEventSchema["shape"]["name"]> }>(_fn: (event: T) => Promise<void>) {
+    return async (_event: T) => {};
+  }
+}