@bgord/bun 1.16.0 → 1.16.2

package/src/remote-file-storage-with-logger.adapter.ts

@@ -0,0 +1,140 @@
+import type * as tools from "@bgord/tools";
+import type { ClockPort } from "./clock.port";
+import type { LoggerPort } from "./logger.port";
+import type {
+  RemoteFileStoragePort,
+  RemoteHeadResult,
+  RemotePutFromPathInput,
+  RemotePutFromPathResult,
+} from "./remote-file-storage.port";
+import { Stopwatch } from "./stopwatch.service";
+
+type Dependencies = { inner: RemoteFileStoragePort; Logger: LoggerPort; Clock: ClockPort };
+
+export class RemoteFileStorageWithLoggerAdapter implements RemoteFileStoragePort {
+  private readonly base = { component: "infra", operation: "remote_file_storage" };
+
+  constructor(private readonly deps: Dependencies) {}
+
+  async putFromPath(input: RemotePutFromPathInput): Promise<RemotePutFromPathResult> {
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Remote file storage put attempt",
+        metadata: { key: input.key },
+        ...this.base,
+      });
+
+      const result = await this.deps.inner.putFromPath(input);
+
+      this.deps.Logger.info({
+        message: "Remote file storage put success",
+        metadata: { key: input.key, size: result.size, duration: duration.stop() },
+        ...this.base,
+      });
+
+      return result;
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Remote file storage put error",
+        error,
+        metadata: duration.stop(),
+        ...this.base,
+      });
+
+      throw error;
+    }
+  }
+
+  async head(key: tools.ObjectKeyType): Promise<RemoteHeadResult> {
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({ message: "Remote file storage head attempt", metadata: { key }, ...this.base });
+
+      const result = await this.deps.inner.head(key);
+
+      this.deps.Logger.info({
+        message: "Remote file storage head success",
+        metadata: { key, exists: result.exists, duration: duration.stop() },
+        ...this.base,
+      });
+
+      return result;
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Remote file storage head error",
+        error,
+        metadata: duration.stop(),
+        ...this.base,
+      });
+
+      throw error;
+    }
+  }
+
+  async getStream(key: tools.ObjectKeyType): Promise<ReadableStream | null> {
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Remote file storage get stream attempt",
+        metadata: { key },
+        ...this.base,
+      });
+
+      const result = await this.deps.inner.getStream(key);
+
+      this.deps.Logger.info({
+        message: "Remote file storage get stream success",
+        metadata: { key, duration: duration.stop() },
+        ...this.base,
+      });
+
+      return result;
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Remote file storage get stream error",
+        error,
+        metadata: duration.stop(),
+        ...this.base,
+      });
+
+      throw error;
+    }
+  }
+
+  async delete(key: tools.ObjectKeyType): Promise<void> {
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Remote file storage delete attempt",
+        metadata: { key },
+        ...this.base,
+      });
+
+      await this.deps.inner.delete(key);
+
+      this.deps.Logger.info({
+        message: "Remote file storage delete success",
+        metadata: { key, duration: duration.stop() },
+        ...this.base,
+      });
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Remote file storage delete error",
+        error,
+        metadata: duration.stop(),
+        ...this.base,
+      });
+
+      throw error;
+    }
+  }
+
+  get root(): tools.DirectoryPathAbsoluteType {
+    return this.deps.inner.root;
+  }
+}

package/src/retry.service.ts

@@ -2,8 +2,6 @@ import * as tools from "@bgord/tools";
 import type { RetryBackoffStrategy } from "./retry-backoff.strategy";
 import type { SleeperPort } from "./sleeper.port";
 
-export const RetryError = { InvalidMax: "retry.invalid.max" };
-
 type Dependencies = { Sleeper: SleeperPort };
 
 export type RetryConfig = {
@@ -16,8 +14,6 @@ export class Retry {
   constructor(private readonly deps: Dependencies) {}
 
   async run<T>(action: () => Promise<T>, config: RetryConfig): Promise<T> {
-    if (config.max < 1) throw new Error(RetryError.InvalidMax);
-
     let lastError: unknown;
 
     for (let attempt = 1; attempt <= config.max; attempt++) {

package/src/security-countermeasure-ban.strategy.ts

@@ -1,12 +1,11 @@
 import * as v from "valibot";
 import type { ClockPort } from "./clock.port";
 import { CorrelationStorage } from "./correlation-storage.service";
-import { createEventEnvelope } from "./event-envelope";
+import { event } from "./event-envelope";
 import type { EventStorePort } from "./event-store.port";
 import type { IdProviderPort } from "./id-provider.port";
 import type { LoggerPort } from "./logger.port";
 import {
-  SECURITY_VIOLATION_DETECTED_EVENT,
   SecurityViolationDetectedEvent,
   type SecurityViolationDetectedEventType,
 } from "./modules/system/events/SECURITY_VIOLATION_DETECTED_EVENT";
@@ -51,13 +50,9 @@ export class SecurityCountermeasureBanStrategy implements SecurityCountermeasure
       metadata: context,
     });
 
-    const event = v.parse(SecurityViolationDetectedEvent, {
-      ...createEventEnvelope("security", this.deps),
-      name: SECURITY_VIOLATION_DETECTED_EVENT,
-      payload: { action: action.kind, ...context },
-    } satisfies SecurityViolationDetectedEventType);
-
-    await this.deps.EventStore.save([event]);
+    await this.deps.EventStore.save([
+      event(SecurityViolationDetectedEvent, "security", { action: action.kind, ...context }, this.deps),
+    ]);
 
     return action;
   }

package/src/semaphore.service.ts

@@ -0,0 +1,26 @@
+import type * as tools from "@bgord/tools";
+
+export type SemaphoreConfig = { limit: tools.IntegerPositiveType };
+
+export class Semaphore {
+  private readonly slots: Array<Promise<void>>;
+
+  constructor(config: SemaphoreConfig) {
+    this.slots = Array.from({ length: config.limit }, () => Promise.resolve());
+  }
+
+  async run<T>(action: () => Promise<T>): Promise<T> {
+    const slot = this.slots.shift()!;
+    const { promise, resolve } = Promise.withResolvers<void>();
+
+    this.slots.push(promise);
+
+    await slot;
+
+    try {
+      return await action();
+    } finally {
+      resolve();
+    }
+  }
+}

package/src/setup-hono.service.ts

@@ -69,18 +69,7 @@ export class SetupHono {
         xFrameOptions: false,
       }),
       cors({
-        // Stryker disable all
-        origin: (origin, c) => {
-          // server-to-server, curl, same-origin navigation
-          if (!origin) return undefined;
-
-          // same-origin fetch
-          if (origin === new URL(c.req.url).origin) return origin;
-
-          // deny cross-origin
-          return null;
-        },
-        // Stryker restore all
+        origin: (origin, c) => (origin === new URL(c.req.url).origin ? origin : null),
         credentials: false,
         maxAge: tools.Duration.Minutes(10).seconds,
         ...config.cors,

package/src/sse-registry.adapter.ts

@@ -8,7 +8,7 @@ export class SseRegistryAdapter<Messages extends Message> implements SseRegistry
   register(identity: HashValueType, connection: SseSenderType<Messages>): void {
     if (!this.senders.has(identity)) this.senders.set(identity, new Set());
 
-    this.senders.get(identity)!.add(connection);
+    this.senders.get(identity)?.add(connection);
   }
 
   unregister(identity: HashValueType, connection: SseSenderType<Messages>): void {

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

@@ -72,9 +72,7 @@ export class StaticFilesHono {
 
           const contentType = context.res.headers.get("Content-Type");
 
-          // Stryker disable all
           if (contentType?.startsWith("text/html")) staticDocumentHeaders(context, noop);
-          // Stryker restore all
           else staticAssetHeaders(context, noop);
         },
         etag(),

package/src/translations-hono.handler.ts

@@ -19,7 +19,7 @@ export class TranslationsHonoHandler<T extends tools.LanguageType> implements Ha
   }
 
   handle() {
-    return factory.createHandlers<{}, any, { Variables: LanguageDetectorVariables }>(async (c) => {
+    return factory.createHandlers<any, any, { Variables: LanguageDetectorVariables }>(async (c) => {
       const language = c.get("language");
       const result = await this.handler.execute(language);
 

package/src/woodchopper-diagnostics-collecting.strategy.ts

@@ -1,4 +1,4 @@
-import { ErrorNormalizer } from "./error-normalizer.service";
+import * as tools from "@bgord/tools";
 import type {
   WoodchopperDiagnosticsStrategy,
   WoodchopperDiagnosticType,
@@ -8,6 +8,6 @@ export class WoodchopperDiagnosticsCollecting implements WoodchopperDiagnosticsS
   readonly entries: Array<WoodchopperDiagnosticType> = [];
 
   handle(diagnostic: WoodchopperDiagnosticType): void {
-    this.entries.push({ ...diagnostic, error: ErrorNormalizer.normalize(diagnostic.error) });
+    this.entries.push({ ...diagnostic, error: tools.ErrorNormalizer.normalize(diagnostic.error) });
   }
 }

package/src/woodchopper-diagnostics-console-error.strategy.ts

@@ -1,4 +1,4 @@
-import { ErrorNormalizer } from "./error-normalizer.service";
+import * as tools from "@bgord/tools";
 import type { RedactorStrategy } from "./redactor.strategy";
 import type {
   WoodchopperDiagnosticsStrategy,
@@ -9,7 +9,7 @@ export class WoodchopperDiagnosticsConsoleError implements WoodchopperDiagnostic
   constructor(private readonly redactor?: RedactorStrategy) {}
 
   handle(diagnostic: WoodchopperDiagnosticType): void {
-    const output = { ...diagnostic, error: ErrorNormalizer.normalize(diagnostic.error) };
+    const output = { ...diagnostic, error: tools.ErrorNormalizer.normalize(diagnostic.error) };
 
     // biome-ignore lint: lint/suspicious/noConsole
     console.error(this.redactor ? this.redactor.redact(output) : output);

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

@@ -73,9 +73,7 @@ export class WoodchopperDispatcherAsync implements WoodchopperDispatcher {
       try {
         this.sink.write(entry as LoggerEntry);
       } catch (error) {
-        // Stryker disable all
         this.onError?.(error);
-        // Stryker restore all
       }
     }
   }

package/src/woodchopper-sampling-correlation-id.strategy.ts

@@ -9,8 +9,8 @@ export class WoodchoperSamplingCorrelationId implements WoodchopperSamplingStrat
   constructor(private readonly config: Config) {}
 
   decide(entry: LoggerEntry): boolean {
-    // Stryker disable all
     if (!entry.correlationId) return false;
+    // Stryker disable all
     return fnv1a32(entry.correlationId) % this.config.everyNth === 0;
     // Stryker restore all
   }

package/src/woodchopper-sink-stderr.strategy.ts

@@ -3,6 +3,6 @@ import type { WoodchopperSinkStrategy } from "./woodchopper-sink.strategy";
 
 export class WoodchopperSinkStderr implements WoodchopperSinkStrategy {
   write(entry: LoggerEntry): void {
-    process.stderr.write(JSON.stringify(entry) + "\n");
+    process.stderr.write(`${JSON.stringify(entry)}\n`);
   }
 }

package/src/woodchopper-sink-stdout-human.strategy.ts

@@ -3,6 +3,6 @@ import type { WoodchopperSinkStrategy } from "./woodchopper-sink.strategy";
 
 export class WoodchopperSinkStdoutHuman implements WoodchopperSinkStrategy {
   write(entry: LoggerEntry): void {
-    process.stdout.write(JSON.stringify(entry, null, 2) + "\n");
+    process.stdout.write(`${JSON.stringify(entry, null, 2)}\n`);
   }
 }

package/src/woodchopper-sink-stdout.strategy.ts

@@ -3,6 +3,6 @@ import type { WoodchopperSinkStrategy } from "./woodchopper-sink.strategy";
 
 export class WoodchopperSinkStdout implements WoodchopperSinkStrategy {
   write(entry: LoggerEntry): void {
-    process.stdout.write(JSON.stringify(entry) + "\n");
+    process.stdout.write(`${JSON.stringify(entry)}\n`);
   }
 }

package/src/woodchopper.ts

@@ -1,6 +1,5 @@
 import * as tools from "@bgord/tools";
 import type { ClockPort } from "./clock.port";
-import { ErrorNormalizer } from "./error-normalizer.service";
 import {
   type LoggerAppType,
   type LoggerEntry,
@@ -64,7 +63,7 @@ export class Woodchopper implements LoggerPort, LoggerStatsProviderPort {
     let withNormalization: LoggerEntryBare | LoggerEntryBareWithError;
     try {
       withNormalization =
-        "error" in entry ? { ...entry, error: ErrorNormalizer.normalize(entry.error) } : entry;
+        "error" in entry ? { ...entry, error: tools.ErrorNormalizer.normalize(entry.error) } : entry;
     } catch (error) {
       this.stats.recordDropped();
       this.config.diagnostics?.handle({ kind: "normalization", error });

package/dist/deep-clone-with.d.ts

@@ -1,4 +0,0 @@
-export declare function deepCloneWith<T>(value: T, replacer: (value: unknown, key?: string) => unknown, options?: {
-    allowRootReplace?: boolean;
-}): T;
-//# sourceMappingURL=deep-clone-with.d.ts.map

package/dist/deep-clone-with.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deep-clone-with.d.ts","sourceRoot":"","sources":["../src/deep-clone-with.ts"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,CAAC,EAC7B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,OAAO,EACnD,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3C,CAAC,CAwBH"}

package/dist/deep-clone-with.js

@@ -1,22 +0,0 @@
-import { isPlainObject } from "./is-plain-object";
-export function deepCloneWith(value, replacer, options = {}) {
-    const allowRootReplace = options.allowRootReplace ?? false;
-    function clone(current, key, isRoot = false) {
-        const replaced = replacer(current, key);
-        if (replaced !== undefined && (!isRoot || allowRootReplace))
-            return replaced;
-        if (Array.isArray(current))
-            return current.map((item) => clone(item));
-        if (isPlainObject(current)) {
-            const result = {};
-            for (const ownKey of Reflect.ownKeys(current)) {
-                const value = current[ownKey];
-                result[ownKey] = clone(value, ownKey);
-            }
-            return result;
-        }
-        return current;
-    }
-    return clone(value, undefined, true);
-}
-//# sourceMappingURL=deep-clone-with.js.map

package/dist/deep-clone-with.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"deep-clone-with.js","sourceRoot":"","sources":["../src/deep-clone-with.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD,MAAM,UAAU,aAAa,CAC3B,KAAQ,EACR,QAAmD,EACnD,UAA0C,EAAE;IAE5C,MAAM,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,IAAI,KAAK,CAAC;IAE3D,SAAS,KAAK,CAAC,OAAgB,EAAE,GAAY,EAAE,MAAM,GAAG,KAAK;QAC3D,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;QAExC,IAAI,QAAQ,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,IAAI,gBAAgB,CAAC;YAAE,OAAO,QAAQ,CAAC;QAE7E,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;YAAE,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;QAEtE,IAAI,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3B,MAAM,MAAM,GAAqC,EAAE,CAAC;YAEpD,KAAK,MAAM,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC9C,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;gBAC9B,MAAM,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC,KAAK,EAAE,MAAgB,CAAC,CAAC;YAClD,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,OAAO,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAM,CAAC;AAC5C,CAAC"}

package/dist/error-normalizer.service.d.ts

@@ -1,12 +0,0 @@
-export type NormalizedError = {
-    message: string;
-    name?: string;
-    stack?: string;
-    cause?: NormalizedError;
-};
-export declare class ErrorNormalizer {
-    static normalize(error: unknown): NormalizedError;
-    static isNormalizedError(value: unknown): value is NormalizedError;
-    private static normalizeWithGuard;
-}
-//# sourceMappingURL=error-normalizer.service.d.ts.map

package/dist/error-normalizer.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-normalizer.service.d.ts","sourceRoot":"","sources":["../src/error-normalizer.service.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,eAAe,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,eAAe,CAAA;CAAE,CAAC;AAE1G,qBAAa,eAAe;IAC1B,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe;IAIjD,MAAM,CAAC,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe;IAIlE,OAAO,CAAC,MAAM,CAAC,kBAAkB;CAkBlC"}

package/dist/error-normalizer.service.js

@@ -1,24 +0,0 @@
-import { isPlainObject } from "./is-plain-object";
-export class ErrorNormalizer {
-    static normalize(error) {
-        return ErrorNormalizer.normalizeWithGuard(error, new WeakSet());
-    }
-    static isNormalizedError(value) {
-        return isPlainObject(value) && "message" in value && typeof value["message"] === "string";
-    }
-    static normalizeWithGuard(error, seen) {
-        if (error instanceof Error) {
-            if (seen.has(error))
-                return { message: error.message, name: error.name };
-            seen.add(error);
-            const cause = error.cause instanceof Error
-                ? ErrorNormalizer.normalizeWithGuard(error.cause, seen)
-                : typeof error.cause === "string"
-                    ? { message: error.cause }
-                    : undefined;
-            return { message: error.message, name: error.name, stack: error.stack, cause };
-        }
-        return { message: String(error) };
-    }
-}
-//# sourceMappingURL=error-normalizer.service.js.map

package/dist/error-normalizer.service.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-normalizer.service.js","sourceRoot":"","sources":["../src/error-normalizer.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAIlD,MAAM,OAAO,eAAe;IAC1B,MAAM,CAAC,SAAS,CAAC,KAAc;QAC7B,OAAO,eAAe,CAAC,kBAAkB,CAAC,KAAK,EAAE,IAAI,OAAO,EAAE,CAAC,CAAC;IAClE,CAAC;IAED,MAAM,CAAC,iBAAiB,CAAC,KAAc;QACrC,OAAO,aAAa,CAAC,KAAK,CAAC,IAAI,SAAS,IAAI,KAAK,IAAI,OAAO,KAAK,CAAC,SAAS,CAAC,KAAK,QAAQ,CAAC;IAC5F,CAAC;IAEO,MAAM,CAAC,kBAAkB,CAAC,KAAc,EAAE,IAAqB;QACrE,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;YAC3B,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;gBAAE,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC;YAEzE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YAEhB,MAAM,KAAK,GACT,KAAK,CAAC,KAAK,YAAY,KAAK;gBAC1B,CAAC,CAAC,eAAe,CAAC,kBAAkB,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC;gBACvD,CAAC,CAAC,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ;oBAC/B,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,KAAK,EAAE;oBAC1B,CAAC,CAAC,SAAS,CAAC;YAElB,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC;QACjF,CAAC;QAED,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;IACpC,CAAC;CACF"}

package/dist/is-plain-object.d.ts

@@ -1,2 +0,0 @@
-export declare function isPlainObject(value: unknown): value is Record<string | symbol, unknown>;
-//# sourceMappingURL=is-plain-object.d.ts.map

package/dist/is-plain-object.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-plain-object.d.ts","sourceRoot":"","sources":["../src/is-plain-object.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,CAMvF"}

package/dist/is-plain-object.js

@@ -1,7 +0,0 @@
-export function isPlainObject(value) {
-    if (!value)
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
-//# sourceMappingURL=is-plain-object.js.map

package/dist/is-plain-object.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-plain-object.js","sourceRoot":"","sources":["../src/is-plain-object.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,aAAa,CAAC,KAAc;IAC1C,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC;IAEzB,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAE/C,OAAO,SAAS,KAAK,MAAM,CAAC,SAAS,IAAI,SAAS,KAAK,IAAI,CAAC;AAC9D,CAAC"}

package/src/deep-clone-with.ts

@@ -1,31 +0,0 @@
-import { isPlainObject } from "./is-plain-object";
-
-export function deepCloneWith<T>(
-  value: T,
-  replacer: (value: unknown, key?: string) => unknown,
-  options: { allowRootReplace?: boolean } = {},
-): T {
-  const allowRootReplace = options.allowRootReplace ?? false;
-
-  function clone(current: unknown, key?: string, isRoot = false): unknown {
-    const replaced = replacer(current, key);
-
-    if (replaced !== undefined && (!isRoot || allowRootReplace)) return replaced;
-
-    if (Array.isArray(current)) return current.map((item) => clone(item));
-
-    if (isPlainObject(current)) {
-      const result: Record<string | symbol, unknown> = {};
-
-      for (const ownKey of Reflect.ownKeys(current)) {
-        const value = current[ownKey];
-        result[ownKey] = clone(value, ownKey as string);
-      }
-      return result;
-    }
-
-    return current;
-  }
-
-  return clone(value, undefined, true) as T;
-}

package/src/error-normalizer.service.ts

@@ -1,32 +0,0 @@
-import { isPlainObject } from "./is-plain-object";
-
-export type NormalizedError = { message: string; name?: string; stack?: string; cause?: NormalizedError };
-
-export class ErrorNormalizer {
-  static normalize(error: unknown): NormalizedError {
-    return ErrorNormalizer.normalizeWithGuard(error, new WeakSet());
-  }
-
-  static isNormalizedError(value: unknown): value is NormalizedError {
-    return isPlainObject(value) && "message" in value && typeof value["message"] === "string";
-  }
-
-  private static normalizeWithGuard(error: unknown, seen: WeakSet<object>): NormalizedError {
-    if (error instanceof Error) {
-      if (seen.has(error)) return { message: error.message, name: error.name };
-
-      seen.add(error);
-
-      const cause =
-        error.cause instanceof Error
-          ? ErrorNormalizer.normalizeWithGuard(error.cause, seen)
-          : typeof error.cause === "string"
-            ? { message: error.cause }
-            : undefined;
-
-      return { message: error.message, name: error.name, stack: error.stack, cause };
-    }
-
-    return { message: String(error) };
-  }
-}

package/src/is-plain-object.ts

@@ -1,7 +0,0 @@
-export function isPlainObject(value: unknown): value is Record<string | symbol, unknown> {
-  if (!value) return false;
-
-  const prototype = Object.getPrototypeOf(value);
-
-  return prototype === Object.prototype || prototype === null;
-}