@bgord/bun 1.9.0 → 1.9.2

package/src/correlation-storage.service.ts

@@ -0,0 +1,31 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createMiddleware } from "hono/factory";
+import type { CorrelationIdType } from "./correlation-id.vo";
+
+type CorrelationContext = { correlationId: CorrelationIdType };
+
+export const CorrelationStorageError = { Missing: "correlation.storage.missing" } as const;
+
+export class CorrelationStorage {
+  static readonly GLOBAL_KEY = Symbol.for("bgord.CorrelationStorage");
+
+  // biome-ignore lint: lint/suspicious/noAssignInExpressions
+  private static readonly als: AsyncLocalStorage<CorrelationContext> = ((globalThis as any)[
+    this.GLOBAL_KEY
+  ] ??=
+    new AsyncLocalStorage<CorrelationContext>());
+
+  static run<T>(correlationId: CorrelationIdType, action: () => T | Promise<T>): T | Promise<T> {
+    return CorrelationStorage.als.run({ correlationId }, action);
+  }
+
+  static get(): CorrelationIdType {
+    const store = CorrelationStorage.als.getStore();
+
+    if (!store) throw new Error(CorrelationStorageError.Missing);
+    return store.correlationId;
+  }
+
+  static handle = () =>
+    createMiddleware(async (context, next) => CorrelationStorage.run(context.get("requestId"), next));
+}

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-file.adapter.ts

@@ -0,0 +1,29 @@
+import type * as tools from "@bgord/tools";
+import type { CryptoKeyProviderPort } from "./crypto-key-provider.port";
+import { EncryptionKey } from "./encryption-key.vo";
+
+export const CryptoKeyProviderFileAdapterError = {
+  MissingFile: "crypto.key.provider.file.adapter.missing.file",
+};
+
+export class CryptoKeyProviderFileAdapter implements CryptoKeyProviderPort {
+  constructor(private readonly path: tools.FilePathAbsolute | tools.FilePathRelative) {}
+
+  async get() {
+    const file = Bun.file(this.path.get());
+    const exists = await file.exists();
+
+    if (!exists) throw new Error(CryptoKeyProviderFileAdapterError.MissingFile);
+
+    const content = await file.text();
+    const encryptionKey = EncryptionKey.fromString(content.trim());
+
+    return crypto.subtle.importKey(
+      "raw",
+      encryptionKey.toBuffer() as BufferSource,
+      { name: "AES-GCM" },
+      false,
+      ["encrypt", "decrypt"],
+    );
+  }
+}

package/src/crypto-key-provider-memory.adapter.ts

@@ -0,0 +1,17 @@
+import type { CryptoKeyProviderPort } from "./crypto-key-provider.port";
+import { EncryptionKey } from "./encryption-key.vo";
+import type { EncryptionKeyValueType } from "./encryption-key-value.vo";
+
+export class CryptoKeyProviderMemoryAdapter implements CryptoKeyProviderPort {
+  constructor(private readonly ENCRYPTION_KEY_VALUE: EncryptionKeyValueType) {}
+
+  async get(): Promise<CryptoKey> {
+    return crypto.subtle.importKey(
+      "raw",
+      EncryptionKey.fromString(this.ENCRYPTION_KEY_VALUE).toBuffer() as BufferSource,
+      { name: "AES-GCM" },
+      false,
+      ["encrypt", "decrypt"],
+    );
+  }
+}

package/src/crypto-key-provider-noop.adapter.ts

@@ -0,0 +1,9 @@
+import type { CryptoKeyProviderPort } from "./crypto-key-provider.port";
+
+export class CryptoKeyProviderNoopAdapter implements CryptoKeyProviderPort {
+  async get(): Promise<CryptoKey> {
+    const bytes = new Uint8Array(32);
+
+    return crypto.subtle.importKey("raw", bytes, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+  }
+}

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

@@ -0,0 +1,28 @@
+import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import { CacheSubjectApplicationResolver } from "./cache-subject-application-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 CacheSubjectApplicationResolver(
+      [
+        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/crypto-key-provider.port.ts

@@ -0,0 +1,3 @@
+export interface CryptoKeyProviderPort {
+  get(): Promise<CryptoKey>;
+}

package/src/csv-stringifier.adapter.ts

@@ -0,0 +1,8 @@
+import { stringify } from "csv";
+import type { CsvColumnType, CsvRowType, CsvStringifierPort } from "./csv-stringifier.port";
+
+export class CsvStringifierAdapter implements CsvStringifierPort {
+  process(columns: CsvColumnType[], data: CsvRowType[]) {
+    return stringify(data, { header: true, columns });
+  }
+}

package/src/csv-stringifier.port.ts

@@ -0,0 +1,8 @@
+import type stream from "node:stream";
+
+export type CsvColumnType = string;
+export type CsvRowType = Record<string, any>;
+
+export interface CsvStringifierPort {
+  process(columns: CsvColumnType[], data: CsvRowType[]): stream.Transform;
+}

package/src/disk-space-checker-bun.adapter.ts

@@ -0,0 +1,18 @@
+import bun from "bun";
+import * as tools from "@bgord/tools";
+import type { DiskSpaceCheckerPort } from "./disk-space-checker.port";
+
+// Example command output:
+// Filesystem     1024-blocks      Used Available Capacity  Mounted on
+// /dev/disk3s1s1   239362496  10997540  43650948    21%    /
+
+export class DiskSpaceCheckerBunAdapter implements DiskSpaceCheckerPort {
+  async get(root: string) {
+    const stdout = await bun.$`df -kP ${root}`.text();
+
+    const line = stdout.trim().split(/\r?\n/)[1]; // Select the second line
+    const free = Number(line?.trim().split(/\s+/)[3]); // Get the fourth block
+
+    return tools.Size.fromKb(free);
+  }
+}

package/src/disk-space-checker-noop.adapter.ts

@@ -0,0 +1,10 @@
+import type * as tools from "@bgord/tools";
+import type { DiskSpaceCheckerPort } from "./disk-space-checker.port";
+
+export class DiskSpaceCheckerNoopAdapter implements DiskSpaceCheckerPort {
+  constructor(private readonly value: tools.Size) {}
+
+  async get(_root: string) {
+    return this.value;
+  }
+}

package/src/disk-space-checker.port.ts

@@ -0,0 +1,5 @@
+import type * as tools from "@bgord/tools";
+
+export interface DiskSpaceCheckerPort {
+  get(root: string): Promise<tools.Size>;
+}

package/src/dispatching-event-store.ts

@@ -0,0 +1,36 @@
+// Stryker disable all
+import type * as z from "zod/v4";
+import type { GenericEventSchema, GenericParsedEventSchema } from "./event.types";
+import type { EventPublisher } from "./event-publisher.types";
+import { EventStore as BaseStore } from "./event-store";
+import type { EventStreamType } from "./event-stream.vo";
+import type { ToEventMap } from "./to-event-map.types";
+
+export class DispatchingEventStore<AllEvents extends GenericEventSchema> extends BaseStore<AllEvents> {
+  static EMPTY_STREAM_REVISION = -1;
+
+  constructor(
+    config: {
+      finder: (stream: EventStreamType, names: string[]) => Promise<z.infer<GenericEventSchema>[]>;
+      inserter: (events: z.infer<GenericParsedEventSchema>[]) => Promise<z.infer<GenericParsedEventSchema>[]>;
+    },
+    private readonly publisher: EventPublisher<ToEventMap<z.infer<AllEvents>>>,
+  ) {
+    super(config);
+  }
+
+  async save(_events: z.infer<AllEvents>[]): Promise<z.infer<AllEvents>[]> {
+    // We receive the events with the `revision` fields added by the inserter,
+    // so the read models can receive them.
+    const events = await super.save(_events);
+
+    await Promise.all(
+      events.map((event) =>
+        this.publisher.emit(event.name as keyof ToEventMap<z.infer<AllEvents>>, event as any),
+      ),
+    );
+
+    return events;
+  }
+}
+// Stryker restore all

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/encryption-iv.vo.ts

@@ -0,0 +1,9 @@
+export class EncryptionIV {
+  static LENGTH = 12;
+
+  static generate(): Uint8Array {
+    const iv = new Uint8Array(EncryptionIV.LENGTH);
+    crypto.getRandomValues(iv);
+    return iv;
+  }
+}

package/src/encryption-key-value.vo.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+
+export const EncryptionKeyValueError = {
+  Type: "encryption.key.value.type",
+  InvalidHex: "encryption.key.value.invalid.hex",
+};
+
+// 64 hex chars allowed
+const CHARS_WHITELIST = /^[a-fA-F0-9]{64}$/;
+
+// Stryker disable all
+export const EncryptionKeyValue = z
+  // Stryker restore all
+  .string(EncryptionKeyValueError.Type)
+  .regex(CHARS_WHITELIST, EncryptionKeyValueError.InvalidHex)
+  .brand("EncryptionKeyValue");
+
+export type EncryptionKeyValueType = z.infer<typeof EncryptionKeyValue>;

package/src/encryption-key.vo.ts

@@ -0,0 +1,41 @@
+import { EncryptionKeyValue, type EncryptionKeyValueType } from "./encryption-key-value.vo";
+
+export const EncryptionKeyError = { InvalidBuffer: "encryption.key.invalid.buffer" };
+
+export class EncryptionKey {
+  private constructor(private readonly value: EncryptionKeyValueType) {}
+
+  static fromStringSafe(value: EncryptionKeyValueType): EncryptionKey {
+    return new EncryptionKey(value);
+  }
+
+  static fromString(candidate: string): EncryptionKey {
+    return new EncryptionKey(EncryptionKeyValue.parse(candidate));
+  }
+
+  static fromBuffer(buffer: Uint8Array): EncryptionKey {
+    if (buffer.length !== 32) throw new Error(EncryptionKeyError.InvalidBuffer);
+
+    const hex = Array.from(buffer)
+      .map((byte) => byte.toString(16).padStart(2, "0"))
+      .join("");
+
+    return EncryptionKey.fromString(hex);
+  }
+
+  equals(another: EncryptionKey): boolean {
+    return this.value === another.value;
+  }
+
+  toBuffer(): Uint8Array {
+    return Uint8Array.from(Buffer.from(this.value, "hex"));
+  }
+
+  toString(): string {
+    return "EncryptionKey";
+  }
+
+  toJSON(): string {
+    return "EncryptionKey";
+  }
+}

package/src/encryption-noop.adapter.ts

@@ -0,0 +1,18 @@
+import type * as tools from "@bgord/tools";
+import type { EncryptionPort, EncryptionRecipe } from "./encryption.port";
+
+export class EncryptionNoopAdapter implements EncryptionPort {
+  constructor(private readonly buffer: ArrayBuffer = new TextEncoder().encode("noop").buffer) {}
+
+  async encrypt(recipe: EncryptionRecipe) {
+    return recipe.output;
+  }
+
+  async decrypt(recipe: EncryptionRecipe) {
+    return recipe.output;
+  }
+
+  async view(_input: tools.FilePathRelative | tools.FilePathAbsolute) {
+    return this.buffer;
+  }
+}

package/src/encryption.port.ts

@@ -0,0 +1,12 @@
+import type * as tools from "@bgord/tools";
+
+export type EncryptionRecipe = {
+  input: tools.FilePathRelative | tools.FilePathAbsolute;
+  output: tools.FilePathRelative | tools.FilePathAbsolute;
+};
+
+export interface EncryptionPort {
+  encrypt(recipe: EncryptionRecipe): Promise<tools.FilePathRelative | tools.FilePathAbsolute>;
+  decrypt(recipe: EncryptionRecipe): Promise<tools.FilePathRelative | tools.FilePathAbsolute>;
+  view(input: tools.FilePathRelative | tools.FilePathAbsolute): Promise<ArrayBuffer>;
+}

package/src/environment-file-parser.service.ts

@@ -0,0 +1,35 @@
+export class EnvironmentFileParser {
+  static parse(content: string): Record<string, string> {
+    const result: Record<string, string> = {};
+
+    const lines = content.split(/\r?\n/);
+
+    for (const line of lines) {
+      // Stryker disable all
+      const trimmed = line.trim();
+      // Stryker restore all
+
+      // Stryker disable all
+      if (!trimmed) continue;
+      // Stryker restore all
+
+      if (trimmed.startsWith("#")) continue;
+
+      const separatorIndex = trimmed.indexOf("=");
+
+      if (separatorIndex === -1) continue;
+
+      const key = trimmed.slice(0, separatorIndex).trim();
+
+      let value = trimmed.slice(separatorIndex + 1).trim();
+
+      if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+      }
+
+      result[key] = value;
+    }
+
+    return result;
+  }
+}

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

@@ -0,0 +1,31 @@
+import type * as tools from "@bgord/tools";
+import type * as z from "zod/v4";
+import type { NodeEnvironmentEnum } from "../src/node-env.vo";
+import type { EncryptionPort } from "./encryption.port";
+import { EnvironmentFileParser } from "./environment-file-parser.service";
+import type { EnvironmentLoaderPort } from "./environment-loader.port";
+
+type Dependencies = { Encryption: EncryptionPort };
+
+export class EnvironmentLoaderEncryptedAdapter<Schema extends z.ZodObject<any>>
+  implements EnvironmentLoaderPort<Schema>
+{
+  constructor(
+    private readonly config: {
+      type: NodeEnvironmentEnum;
+      Schema: Schema;
+      path: tools.FilePathAbsolute | tools.FilePathRelative;
+    },
+    private readonly deps: Dependencies,
+  ) {}
+
+  async load() {
+    const file = await this.deps.Encryption.view(this.config.path);
+    const content = new TextDecoder().decode(file);
+
+    return Object.freeze({
+      ...this.config.Schema.parse(EnvironmentFileParser.parse(content)),
+      type: this.config.type,
+    });
+  }
+}

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

@@ -0,0 +1,16 @@
+import type * as 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

@@ -0,0 +1,35 @@
+import type * as z from "zod/v4";
+import type { NodeEnvironmentEnum } from "../src/node-env.vo";
+import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import { CacheSubjectApplicationResolver } from "./cache-subject-application-resolver.vo";
+import { CacheSubjectSegmentFixedStrategy } from "./cache-subject-segment-fixed.strategy";
+import type { EnvironmentLoaderPort } from "./environment-loader.port";
+import type { HashContentStrategy } from "./hash-content.strategy";
+
+type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy };
+
+export class EnvironmentLoaderProcessSafeAdapter<Schema extends z.ZodObject<any>>
+  implements EnvironmentLoaderPort<Schema>
+{
+  constructor(
+    private env: NodeJS.ProcessEnv,
+    private readonly config: { type: NodeEnvironmentEnum; Schema: Schema },
+    private readonly deps: Dependencies,
+  ) {}
+
+  async load() {
+    const resolver = new CacheSubjectApplicationResolver(
+      [new CacheSubjectSegmentFixedStrategy("env")],
+      this.deps,
+    );
+    const subject = await resolver.resolve();
+
+    const result = await this.deps.CacheResolver.resolve(subject.hex, async () =>
+      this.config.Schema.parse(this.env),
+    );
+
+    for (const key of Object.keys(result)) delete process.env[key];
+
+    return Object.freeze({ ...result, type: this.config.type });
+  }
+}

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

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

package/src/environment-loader.port.ts

@@ -0,0 +1,8 @@
+import type * as z from "zod/v4";
+import type { NodeEnvironmentEnum } from "../src/node-env.vo";
+
+export type EnvironmentResultType<Schema> = z.infer<Schema> & { type: NodeEnvironmentEnum };
+
+export interface EnvironmentLoaderPort<Schema extends z.ZodObject<any>> {
+  load(): Promise<Readonly<EnvironmentResultType<Schema>>>;
+}

package/src/etag-extractor.middleware.ts

@@ -0,0 +1,18 @@
+import * as tools from "@bgord/tools";
+import { createMiddleware } from "hono/factory";
+
+export type EtagVariables = { ETag: tools.ETag | null; WeakETag: tools.WeakETag | null };
+
+export class ETagExtractor {
+  static attach = createMiddleware<{ Variables: EtagVariables }>(async (context, next) => {
+    try {
+      const header = context.req.header(tools.ETag.IF_MATCH_HEADER_NAME);
+
+      context.set("ETag", tools.ETag.fromHeader(header));
+    } catch {
+      context.set("ETag", null);
+    }
+
+    await next();
+  });
+}

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

@@ -0,0 +1,10 @@
+import type { ToEventMap } from "./to-event-map.types";
+
+export type EventBusLike<E extends { name: string }> = {
+  on<K extends keyof ToEventMap<E> & string>(
+    name: K,
+    handler: (event: ToEventMap<E>[K]) => void | Promise<void>,
+  ): void;
+};
+
+export type CommandBusLike<C extends { name: string }> = { emit(name: C["name"], command: C): Promise<void> };

package/src/event-envelope.ts

@@ -0,0 +1,27 @@
+import * as tools from "@bgord/tools";
+import * as z from "zod/v4";
+import type { ClockPort } from "./clock.port";
+import { CorrelationStorage } from "./correlation-storage.service";
+import type { EventStreamType } from "./event-stream.vo";
+import type { IdProviderPort } from "./id-provider.port";
+import { UUID } from "./uuid.vo";
+
+type Dependencies = { IdProvider: IdProviderPort; Clock: ClockPort };
+
+export const EventEnvelopeSchema = {
+  id: UUID,
+  correlationId: UUID,
+  createdAt: tools.TimestampValue,
+  stream: z.string().min(1),
+  version: z.literal(1),
+  revision: tools.RevisionValue.optional(),
+};
+
+export const createEventEnvelope = (stream: EventStreamType, deps: Dependencies) =>
+  ({
+    id: deps.IdProvider.generate(),
+    correlationId: CorrelationStorage.get(),
+    createdAt: deps.Clock.now().ms,
+    stream,
+    version: 1,
+  }) as const;

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

@@ -0,0 +1,9 @@
+import type * as 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 * as 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) => {};
+  }
+}