@bgord/bun 1.14.5 → 1.14.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.14.5",
+  "version": "1.14.6",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",

package/readme.md

@@ -74,13 +74,12 @@ src/
 ├── clock-system.adapter.ts
 ├── clock.port.ts
 ├── command-envelope.ts
-├── command.types.ts
 ├── commit-sha-value.vo.ts
 ├── commit-sha.vo.ts
 ├── correlation-hono.middleware.ts
-├── correlation-id.middleware.ts
 ├── correlation-id.vo.ts
 ├── correlation-storage.service.ts
+├── correlation.middleware.ts
 ├── crypto-aes-gcm.service.ts
 ├── crypto-key-provider-file.adapter.ts
 ├── crypto-key-provider-memory.adapter.ts
@@ -108,6 +107,7 @@ src/
 ├── environment-loader-process-safe.adapter.ts
 ├── environment-loader-process.adapter.ts
 ├── environment-loader.port.ts
+├── environment-schema.port.ts
 ├── error-normalizer.service.ts
 ├── etag-extractor-hono.middleware.ts
 ├── etag-extractor.middleware.ts
@@ -435,6 +435,7 @@ src/
 ├── sse-hono.handler.ts
 ├── sse-registry-collecting.adapter.ts
 ├── sse-registry-noop.adapter.ts
+├── sse-registry-with-limit.adapter.ts
 ├── sse-registry-with-logger.adapter.ts
 ├── sse-registry.adapter.ts
 ├── sse-registry.port.ts

package/src/correlation-hono.middleware.ts

@@ -1,5 +1,5 @@
 import { createMiddleware } from "hono/factory";
-import { CorrelationIdMiddleware } from "./correlation-id.middleware";
+import { CorrelationMiddleware } from "./correlation.middleware";
 import { CorrelationStorage } from "./correlation-storage.service";
 import type { IdProviderPort } from "./id-provider.port";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
@@ -11,10 +11,10 @@ type Dependencies = { IdProvider: IdProviderPort };
 export type CorrelationVariables = { correlationId: UUIDType };
 
 export class CorrelationHonoMiddleware implements MiddlewareHonoPort {
-  private readonly correlationId: CorrelationIdMiddleware;
+  private readonly correlationId: CorrelationMiddleware;
 
   constructor(deps: Dependencies) {
-    this.correlationId = new CorrelationIdMiddleware(deps);
+    this.correlationId = new CorrelationMiddleware(deps);
   }
 
   handle() {
@@ -24,7 +24,7 @@ export class CorrelationHonoMiddleware implements MiddlewareHonoPort {
       const result = this.correlationId.evaluate(context);
 
       c.set("correlationId", result);
-      c.header(CorrelationIdMiddleware.HEADER_NAME, result);
+      c.header(CorrelationMiddleware.HEADER_NAME, result);
 
       return CorrelationStorage.run(result, next);
     });

package/src/{correlation-id.middleware.ts → correlation.middleware.ts}

@@ -4,13 +4,13 @@ import { UUID, type UUIDType } from "./uuid.vo";
 
 type Dependencies = { IdProvider: IdProviderPort };
 
-export class CorrelationIdMiddleware {
+export class CorrelationMiddleware {
   static readonly HEADER_NAME = "correlation-id";
 
   constructor(private readonly deps: Dependencies) {}
 
   evaluate(context: HasRequestHeader): UUIDType {
-    const incoming = context.request.header(CorrelationIdMiddleware.HEADER_NAME);
+    const incoming = context.request.header(CorrelationMiddleware.HEADER_NAME);
 
     const existing = UUID.safeParse(incoming);
 

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

@@ -1,29 +1,26 @@
 import util from "node:util";
 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 type { EnvironmentLoaderPort, EnvironmentResultType } from "./environment-loader.port";
+import type {
+  EnvironmentLoaderConfig,
+  EnvironmentLoaderPort,
+  EnvironmentResultType,
+} from "./environment-loader.port";
 
 type Dependencies = { Encryption: EncryptionPort };
 
-export class EnvironmentLoaderEncryptedAdapter<Schema extends z.ZodObject<any>>
-  implements EnvironmentLoaderPort<Schema>
-{
+export class EnvironmentLoaderEncryptedAdapter<T extends object> implements EnvironmentLoaderPort<T> {
   constructor(
-    private readonly config: {
-      type: NodeEnvironmentEnum;
-      Schema: Schema;
-      path: tools.FilePathAbsolute | tools.FilePathRelative;
-    },
+    private readonly path: tools.FilePathAbsolute | tools.FilePathRelative,
+    private readonly config: EnvironmentLoaderConfig<T>,
     private readonly deps: Dependencies,
   ) {}
 
-  async load(): Promise<Readonly<EnvironmentResultType<Schema>>> {
-    const file = await this.deps.Encryption.view(this.config.path);
+  async load(): Promise<Readonly<EnvironmentResultType<T>>> {
+    const file = await this.deps.Encryption.view(this.path);
     const plaintext = new TextDecoder().decode(file);
     const env = util.parseEnv(plaintext);
 
-    return Object.freeze({ ...this.config.Schema.parse(env), type: this.config.type });
+    return Object.freeze({ ...this.config.EnvironmentSchema.parse(env), type: this.config.type });
   }
 }

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

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

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

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

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

@@ -1,16 +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";
+import type {
+  EnvironmentLoaderConfig,
+  EnvironmentLoaderPort,
+  EnvironmentResultType,
+} from "./environment-loader.port";
 
-export class EnvironmentLoaderProcessAdapter<Schema extends z.ZodObject<any>>
-  implements EnvironmentLoaderPort<Schema>
-{
+export class EnvironmentLoaderProcessAdapter<T extends object> implements EnvironmentLoaderPort<T> {
   constructor(
-    private readonly config: { type: NodeEnvironmentEnum; Schema: Schema },
+    private readonly config: EnvironmentLoaderConfig<T>,
     private env: NodeJS.ProcessEnv,
   ) {}
 
-  async load(): Promise<Readonly<EnvironmentResultType<Schema>>> {
-    return Object.freeze({ ...this.config.Schema.parse(this.env), type: this.config.type });
+  async load(): Promise<Readonly<EnvironmentResultType<T>>> {
+    return Object.freeze({ ...this.config.EnvironmentSchema.parse(this.env), type: this.config.type });
   }
 }

package/src/environment-loader.port.ts

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

package/src/environment-schema.port.ts

@@ -0,0 +1,3 @@
+export interface EnvironmentSchemaPort<T extends object> {
+  parse(data: unknown): T;
+}

package/src/event-revision-assigner.adapter.ts

@@ -4,10 +4,7 @@ import type { EventRevisionAssignerPort } from "./event-revision-assigner.port";
 export class EventRevisionAssignerAdapter implements EventRevisionAssignerPort {
   static readonly EMPTY_STREAM_REVISION = -1;
 
-  assign(
-    events: ReadonlyArray<GenericEventSerialized>,
-    max: number | undefined,
-  ): ReadonlyArray<GenericEventSerialized> {
+  assign(events: ReadonlyArray<GenericEventSerialized>, max?: number): ReadonlyArray<GenericEventSerialized> {
     const current = max ?? EventRevisionAssignerAdapter.EMPTY_STREAM_REVISION;
 
     return events.map((event, index) => ({ ...event, revision: current + index + 1 }));

package/src/event-revision-assigner.port.ts

@@ -3,6 +3,6 @@ import type { GenericEventSerialized } from "./event.types";
 export interface EventRevisionAssignerPort {
   assign(
     events: ReadonlyArray<GenericEventSerialized>,
-    max: number | undefined,
+    max?: number | undefined,
   ): ReadonlyArray<GenericEventSerialized>;
 }

package/src/event-store-dispatching.adapter.ts

@@ -4,9 +4,9 @@ import type { EventStreamType } from "./event-stream.vo";
 import type { EventValidatorRegistryPort } from "./event-validator-registry.port";
 import type { EventBusPort } from "./message-bus.port";
 
-type Dependencies<TEvent extends GenericEvent> = {
-  inner: EventStorePort<TEvent>;
-  EventBus: EventBusPort<TEvent>;
+type Dependencies<Event extends GenericEvent> = {
+  inner: EventStorePort<Event>;
+  EventBus: EventBusPort<Event>;
 };
 
 export class EventStoreDispatchingAdapter<Event extends GenericEvent> implements EventStorePort<Event> {

package/src/event-store-with-logger.adapter.ts

@@ -5,8 +5,8 @@ import type { EventStreamType } from "./event-stream.vo";
 import type { EventValidatorRegistryPort } from "./event-validator-registry.port";
 import type { LoggerPort } from "./logger.port";
 
-type Dependencies<TEvent extends GenericEvent> = {
-  inner: EventStorePort<TEvent>;
+type Dependencies<Event extends GenericEvent> = {
+  inner: EventStorePort<Event>;
   Logger: LoggerPort;
 };
 

package/src/event-validator-registry-zod.adapter.ts

@@ -22,7 +22,7 @@ const EventValidatorRegistryZodAdapterError = {
   UnknownEvent: "event.validator.registry.zod.adapter.error.unknown.event",
 };
 
-export class EventValidatorRegistryZodAdapter<TEvent> implements EventValidatorRegistryPort<TEvent> {
+export class EventValidatorRegistryZodAdapter<Event> implements EventValidatorRegistryPort<Event> {
   private readonly map: Map<GenericEvent["name"], GenericEventSchema>;
   readonly names: ReadonlyArray<GenericEvent["name"]>;
 
@@ -35,13 +35,13 @@ export class EventValidatorRegistryZodAdapter<TEvent> implements EventValidatorR
     return this.map.has(name);
   }
 
-  validate(raw: unknown): TEvent {
+  validate(raw: unknown): Event {
     const name = (raw as { name?: GenericEvent["name"] }).name;
     if (!name) throw new Error(EventValidatorRegistryZodAdapterError.MissingName);
 
     const schema = this.map.get(name);
     if (!schema) throw new Error(EventValidatorRegistryZodAdapterError.UnknownEvent);
 
-    return schema.parse(raw) as TEvent;
+    return schema.parse(raw) as Event;
   }
 }

package/src/event-validator-registry.port.ts

@@ -1,7 +1,9 @@
 import type { GenericEvent } from "./event.types";
 
-export interface EventValidatorRegistryPort<TEvent> {
+export interface EventValidatorRegistryPort<Event> {
   readonly names: ReadonlyArray<GenericEvent["name"]>;
+
   accepts(name: GenericEvent["name"]): boolean;
-  validate(raw: unknown): TEvent;
+
+  validate(raw: unknown): Event;
 }

package/src/index.ts

@@ -47,12 +47,11 @@ export * from "./clock.port";
 export * from "./clock-fixed.adapter";
 export * from "./clock-offset.adapter";
 export * from "./clock-system.adapter";
-export * from "./command.types";
 export * from "./command-envelope";
 export * from "./commit-sha.vo";
 export * from "./commit-sha-value.vo";
+export * from "./correlation.middleware";
 export * from "./correlation-hono.middleware";
-export * from "./correlation-id.middleware";
 export * from "./correlation-id.vo";
 export * from "./correlation-storage.service";
 export * from "./crypto-key-provider.port";
@@ -79,6 +78,7 @@ export * from "./environment-loader-encrypted.adapter";
 export * from "./environment-loader-noop.adapter";
 export * from "./environment-loader-process.adapter";
 export * from "./environment-loader-process-safe.adapter";
+export * from "./environment-schema.port";
 export * from "./error-normalizer.service";
 export * from "./etag-extractor.middleware";
 export * from "./etag-extractor-hono.middleware";
@@ -365,6 +365,7 @@ export * from "./sse-registry.adapter";
 export * from "./sse-registry.port";
 export * from "./sse-registry-collecting.adapter";
 export * from "./sse-registry-noop.adapter";
+export * from "./sse-registry-with-limit.adapter";
 export * from "./sse-registry-with-logger.adapter";
 export * from "./ssr.service";
 export * from "./ssr-bun.service";

package/src/prerequisite-verifier-timezone-utc.adapter.ts

@@ -1,22 +1,17 @@
 import type * as tools from "@bgord/tools";
-import * as z from "zod/v4";
 import {
   PrerequisiteVerification,
   type PrerequisiteVerificationResult,
   type PrerequisiteVerifierPort,
 } from "./prerequisite-verifier.port";
 
-export const TimezoneUtc = z.literal("UTC");
-
 type Config = { timezone: tools.TimezoneType };
 
 export class PrerequisiteVerifierTimezoneUtcAdapter implements PrerequisiteVerifierPort {
   constructor(private readonly config: Config) {}
 
   async verify(): Promise<PrerequisiteVerificationResult> {
-    const result = TimezoneUtc.safeParse(this.config.timezone);
-
-    if (result.success) return PrerequisiteVerification.success;
+    if (this.config.timezone === "UTC") return PrerequisiteVerification.success;
     return PrerequisiteVerification.failure(`Timezone: ${this.config.timezone}`);
   }
 

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

@@ -12,4 +12,8 @@ export class SseRegistryCollectingAdapter<Messages extends Message> implements S
   async emit<M extends Messages>(identity: HashValueType, message: M): Promise<void> {
     this.emitted.push({ identity, message });
   }
+
+  count(_identity: HashValueType): number {
+    return 0;
+  }
 }

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

@@ -8,4 +8,8 @@ export class SseRegistryNoopAdapter<Messages extends Message> implements SseRegi
   unregister(_identity: HashValueType, _sender: SseSenderType<Messages>): void {}
 
   async emit<M extends Messages>(_identity: HashValueType, _message: M): Promise<void> {}
+
+  count(_identity: HashValueType): number {
+    return 0;
+  }
 }

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

@@ -0,0 +1,31 @@
+import type * as tools from "@bgord/tools";
+import type { HashValueType } from "./hash-value.vo";
+import type { Message } from "./message.types";
+import type { SseRegistryPort, SseSenderType } from "./sse-registry.port";
+
+type Dependencies<Messages extends Message> = {
+  inner: SseRegistryPort<Messages>;
+  limit: tools.IntegerPositiveType;
+};
+
+export class SseRegistryWithLimitAdapter<Messages extends Message> implements SseRegistryPort<Messages> {
+  constructor(private readonly deps: Dependencies<Messages>) {}
+
+  register(identity: HashValueType, sender: SseSenderType<Messages>): void {
+    if (this.deps.inner.count(identity) >= this.deps.limit) return;
+
+    this.deps.inner.register(identity, sender);
+  }
+
+  unregister(identity: HashValueType, sender: SseSenderType<Messages>): void {
+    this.deps.inner.unregister(identity, sender);
+  }
+
+  async emit<M extends Messages>(identity: HashValueType, message: M): Promise<void> {
+    return this.deps.inner.emit(identity, message);
+  }
+
+  count(identity: HashValueType): number {
+    return this.deps.inner.count(identity);
+  }
+}

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

@@ -43,4 +43,8 @@ export class SseRegistryWithLoggerAdapter<Messages extends Message> implements S
 
     return this.deps.inner.emit(identity, message);
   }
+
+  count(identity: HashValueType): number {
+    return this.deps.inner.count(identity);
+  }
 }

package/src/sse-registry.adapter.ts

@@ -20,4 +20,8 @@ export class SseRegistryAdapter<Messages extends Message> implements SseRegistry
       await sender(message);
     }
   }
+
+  count(identity: HashValueType): number {
+    return this.senders.get(identity)?.size ?? 0;
+  }
 }

package/src/sse-registry.port.ts

@@ -9,4 +9,6 @@ export interface SseRegistryPort<Messages extends Message> {
   unregister(identity: HashValueType, sender: SseSenderType<Messages>): void;
 
   emit<M extends Messages>(identity: HashValueType, message: M): Promise<void>;
+
+  count(identity: HashValueType): number;
 }

package/dist/command.types.d.ts

@@ -1,12 +0,0 @@
-import type * as z from "zod/v4";
-export type GenericCommandSchema = z.ZodObject<{
-    id: z.ZodType<string>;
-    correlationId: z.ZodType<string>;
-    createdAt: z.ZodType<number>;
-    name: z.ZodLiteral<string>;
-    payload: z.ZodType<any>;
-}>;
-export type GenericParsedCommandSchema = z.ZodObject<Omit<GenericCommandSchema["shape"], "payload"> & {
-    payload: z.ZodString;
-}>;
-//# sourceMappingURL=command.types.d.ts.map

package/dist/command.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"command.types.d.ts","sourceRoot":"","sources":["../src/command.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,CAAC,MAAM,QAAQ,CAAC;AAEjC,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,SAAS,CAAC;IAC7C,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACtB,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACjC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7B,IAAI,EAAE,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAC3B,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;CACzB,CAAC,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,SAAS,CAClD,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,GAAG;IAAE,OAAO,EAAE,CAAC,CAAC,SAAS,CAAA;CAAE,CAC1E,CAAC"}

package/dist/command.types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=command.types.js.map

package/dist/command.types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"command.types.js","sourceRoot":"","sources":["../src/command.types.ts"],"names":[],"mappings":""}

package/dist/correlation-id.middleware.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"correlation-id.middleware.d.ts","sourceRoot":"","sources":["../src/correlation-id.middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAQ,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAEhD,KAAK,YAAY,GAAG;IAAE,UAAU,EAAE,cAAc,CAAA;CAAE,CAAC;AAEnD,qBAAa,uBAAuB;IAGtB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFjC,MAAM,CAAC,QAAQ,CAAC,WAAW,oBAAoB;gBAElB,IAAI,EAAE,YAAY;IAE/C,QAAQ,CAAC,OAAO,EAAE,gBAAgB,GAAG,QAAQ;CAQ9C"}

package/dist/correlation-id.middleware.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"correlation-id.middleware.js","sourceRoot":"","sources":["../src/correlation-id.middleware.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAiB,MAAM,WAAW,CAAC;AAIhD,MAAM,OAAO,uBAAuB;IAGL;IAF7B,MAAM,CAAU,WAAW,GAAG,gBAAgB,CAAC;IAE/C,YAA6B,IAAkB;QAAlB,SAAI,GAAJ,IAAI,CAAc;IAAG,CAAC;IAEnD,QAAQ,CAAC,OAAyB;QAChC,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAC;QAE7E,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QAE1C,IAAI,QAAQ,CAAC,OAAO;YAAE,OAAO,QAAQ,CAAC,IAAI,CAAC;QAC3C,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IACzC,CAAC"}

package/src/command.types.ts

@@ -1,13 +0,0 @@
-import type * as z from "zod/v4";
-
-export type GenericCommandSchema = z.ZodObject<{
-  id: z.ZodType<string>;
-  correlationId: z.ZodType<string>;
-  createdAt: z.ZodType<number>;
-  name: z.ZodLiteral<string>;
-  payload: z.ZodType<any>;
-}>;
-
-export type GenericParsedCommandSchema = z.ZodObject<
-  Omit<GenericCommandSchema["shape"], "payload"> & { payload: z.ZodString }
->;