@bgord/bun 1.15.5 → 1.16.1

package/src/api-version-hono.middleware.ts

@@ -1,14 +1,15 @@
 import type { MiddlewareHandler } from "hono";
 import { ApiVersionMiddleware } from "./api-version.middleware";
-import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
+import type { BuildInfoType } from "./build-info.vo";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
 import type { HashContentStrategy } from "./hash-content.strategy";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
+import type { ReactiveConfigPort } from "./reactive-config.port";
 
 type Dependencies = {
   CacheResolver: CacheResolverStrategy;
   HashContent: HashContentStrategy;
-  BuildInfoRepository: BuildInfoRepositoryStrategy;
+  BuildInfoConfig: ReactiveConfigPort<BuildInfoType>;
 };
 
 export class ApiVersionHonoMiddleware implements MiddlewareHonoPort {

package/src/api-version.middleware.ts

@@ -1,14 +1,15 @@
 import type * as tools from "@bgord/tools";
-import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
+import type { BuildInfoType } from "./build-info.vo";
 import type { CacheResolverStrategy } from "./cache-resolver.strategy";
 import type { HashContentStrategy } from "./hash-content.strategy";
+import type { ReactiveConfigPort } from "./reactive-config.port";
 import { SubjectApplicationResolver } from "./subject-application-resolver.vo";
 import { SubjectSegmentFixedStrategy } from "./subject-segment-fixed.strategy";
 
 type Dependencies = {
   CacheResolver: CacheResolverStrategy;
   HashContent: HashContentStrategy;
-  BuildInfoRepository: BuildInfoRepositoryStrategy;
+  BuildInfoConfig: ReactiveConfigPort<BuildInfoType>;
 };
 
 export class ApiVersionMiddleware {
@@ -16,7 +17,7 @@ export class ApiVersionMiddleware {
 
   constructor(private readonly deps: Dependencies) {}
 
-  async evaluate(): Promise<tools.PackageVersion> {
+  async evaluate(): Promise<tools.PackageVersionSchemaType> {
     const resolver = new SubjectApplicationResolver(
       [new SubjectSegmentFixedStrategy("api-version")],
       this.deps,
@@ -24,7 +25,7 @@ export class ApiVersionMiddleware {
     const subject = await resolver.resolve();
 
     const build = await this.deps.CacheResolver.resolve(subject.hex, async () =>
-      this.deps.BuildInfoRepository.extract(),
+      this.deps.BuildInfoConfig.get(),
     );
 
     return build.version;

package/src/build-info.vo.ts

@@ -0,0 +1,14 @@
+import * as tools from "@bgord/tools";
+import * as v from "valibot";
+import { CommitShaValue } from "./commit-sha-value.vo";
+
+export const BuildInfo = v.object({
+  timestamp: tools.TimestampValue,
+  version: tools.PackageVersionSchema,
+  sha: CommitShaValue,
+  size: tools.SizeBytes,
+});
+
+export type BuildInfoType = v.InferOutput<typeof BuildInfo>;
+
+export const BUILD_INFO_FILE_PATH = tools.FilePathRelative.fromString("infra/build-info.json");

package/src/error-normalizer.service.ts

@@ -8,7 +8,7 @@ export class ErrorNormalizer {
   }
 
   static isNormalizedError(value: unknown): value is NormalizedError {
-    return isPlainObject(value) && "message" in value && typeof value.message === "string";
+    return isPlainObject(value) && "message" in value && typeof value["message"] === "string";
   }
 
   private static normalizeWithGuard(error: unknown, seen: WeakSet<object>): NormalizedError {

package/src/event-envelope.ts

@@ -17,13 +17,12 @@ export const EventEnvelopeSchema = {
   revision: v.optional(tools.RevisionValue),
 };
 
-export const createEventEnvelope = (stream: EventStreamType, deps: Dependencies) =>
+const createEventEnvelope = (stream: EventStreamType, deps: Dependencies) =>
   ({
     id: deps.IdProvider.generate(),
     correlationId: CorrelationStorage.get(),
     createdAt: deps.Clock.now().ms,
     stream,
-    version: 1,
   }) as const;
 
 export function event<Schema extends v.ObjectSchema<any, any>>(
@@ -35,6 +34,7 @@ export function event<Schema extends v.ObjectSchema<any, any>>(
   return v.parse(schema, {
     ...createEventEnvelope(stream, deps),
     name: schema.entries.name.literal,
+    version: schema.entries.version.literal,
     payload,
   });
 }

package/src/event-serializer-collecting.adapter.ts

@@ -1,17 +1,18 @@
+import type { GenericEvent, GenericEventSerialized } from "./event.types";
 import type { EventSerializerPort } from "./event-serializer.port";
 
 export class EventSerializerCollectingAdapter implements EventSerializerPort {
-  readonly serialized: Array<unknown> = [];
+  readonly serialized: Array<GenericEvent["payload"]> = [];
 
-  readonly deserialized: Array<string> = [];
+  readonly deserialized: Array<GenericEventSerialized["payload"]> = [];
 
-  serialize(payload: unknown): string {
+  serialize(payload: GenericEvent["payload"]): GenericEventSerialized["payload"] {
     this.serialized.push(payload);
 
     return JSON.stringify(payload);
   }
 
-  deserialize(raw: string): unknown {
+  deserialize(raw: GenericEventSerialized["payload"]): GenericEvent["payload"] {
     this.deserialized.push(raw);
 
     return JSON.parse(raw);

package/src/event-serializer-json.adapter.ts

@@ -1,11 +1,12 @@
+import type { GenericEvent, GenericEventSerialized } from "./event.types";
 import type { EventSerializerPort } from "./event-serializer.port";
 
 export class EventSerializerJsonAdapter implements EventSerializerPort {
-  serialize(payload: unknown): string {
+  serialize(payload: GenericEvent["payload"]): GenericEventSerialized["payload"] {
     return JSON.stringify(payload);
   }
 
-  deserialize(raw: string): unknown {
+  deserialize(raw: GenericEventSerialized["payload"]): GenericEvent["payload"] {
     return JSON.parse(raw);
   }
 }

package/src/event-serializer.port.ts

@@ -1,4 +1,6 @@
+import type { GenericEvent, GenericEventSerialized } from "./event.types";
+
 export interface EventSerializerPort {
-  serialize(payload: unknown): string;
-  deserialize(raw: string): unknown;
+  serialize(payload: GenericEvent["payload"]): GenericEventSerialized["payload"];
+  deserialize(raw: GenericEventSerialized["payload"]): GenericEvent["payload"];
 }

package/src/event-store.adapter.ts

@@ -4,12 +4,14 @@ import type { EventInserterPort } from "./event-inserter.port";
 import type { EventSerializerPort } from "./event-serializer.port";
 import type { EventStorePort } from "./event-store.port";
 import type { EventStreamType } from "./event-stream.vo";
+import type { EventUpcasterPort } from "./event-upcaster.port";
 import type { EventValidatorRegistryPort } from "./event-validator-registry.port";
 
 type Config = {
   finder: EventFinderPort;
   inserter: EventInserterPort;
   serializer: EventSerializerPort;
+  upcaster?: EventUpcasterPort;
 };
 
 const EventStoreAdapterError = { UniqueStream: "event.store.adapter.error.unique.stream" };
@@ -25,6 +27,7 @@ export class EventStoreAdapter<Event extends GenericEvent> implements EventStore
 
     return events
       .map((event) => ({ ...event, payload: this.config.serializer.deserialize(event.payload) }))
+      .map((event) => (this.config.upcaster ? this.config.upcaster.upcast(event) : event))
       .map((event) => registry.validate(event));
   }
 

package/src/event-upcaster-chain.adapter.ts

@@ -0,0 +1,49 @@
+import type { GenericEvent } from "./event.types";
+import type { EventUpcasterPort } from "./event-upcaster.port";
+import type { EventUpcasterStep } from "./event-upcaster-step.vo";
+
+const EventUpcasterChainAdapterError = {
+  DuplicateStep: "event.upcaster.chain.duplicate.step",
+  GapInChain: "event.upcaster.chain.gap",
+};
+
+type EventUpcasterChainConfig = Record<GenericEvent["name"], ReadonlyArray<EventUpcasterStep<any, any>>>;
+
+export class EventUpcasterChainAdapter implements EventUpcasterPort {
+  private readonly upcasters: Record<GenericEvent["name"], ReadonlyArray<EventUpcasterStep<any, any>>>;
+
+  constructor(config: EventUpcasterChainConfig) {
+    this.upcasters = Object.fromEntries(
+      Object.entries(config).map(([name, chain]) => [
+        name,
+        [...chain].sort((a, b) => a.config.fromVersion - b.config.fromVersion),
+      ]),
+    );
+
+    for (const chain of Object.values(this.upcasters)) {
+      const versions = chain.map((step) => step.config.fromVersion);
+
+      if (new Set(versions).size !== versions.length) {
+        throw new Error(EventUpcasterChainAdapterError.DuplicateStep);
+      }
+
+      if (chain.some((step, i) => i > 0 && step.config.fromVersion !== chain[i - 1]!.config.toVersion)) {
+        throw new Error(EventUpcasterChainAdapterError.GapInChain);
+      }
+    }
+  }
+
+  upcast(event: GenericEvent): GenericEvent {
+    const chain = this.upcasters[event.name];
+
+    if (!chain) return event;
+
+    return chain.reduce(
+      (result, step) =>
+        result.version === step.config.fromVersion
+          ? { ...result, version: step.config.toVersion, payload: step.config.upcast(result.payload) }
+          : result,
+      event,
+    );
+  }
+}

package/src/event-upcaster-noop.adapter.ts

@@ -0,0 +1,8 @@
+import type { GenericEvent } from "./event.types";
+import type { EventUpcasterPort } from "./event-upcaster.port";
+
+export class EventUpcasterNoopAdapter implements EventUpcasterPort {
+  upcast(event: GenericEvent): GenericEvent {
+    return event;
+  }
+}

package/src/event-upcaster-step.vo.ts

@@ -0,0 +1,21 @@
+import type { GenericEvent } from "./event.types";
+
+export type EventUpcasterStepConfig<
+  From extends GenericEvent = GenericEvent,
+  To extends GenericEvent = GenericEvent,
+> = {
+  fromVersion: GenericEvent["version"];
+  toVersion: GenericEvent["version"];
+  upcast: (payload: From["payload"]) => To["payload"];
+};
+
+const EventUpcasterStepError = { VersionIncrement: "event.upcaster.step.version.increment" };
+
+export class EventUpcasterStep<
+  From extends GenericEvent = GenericEvent,
+  To extends GenericEvent = GenericEvent,
+> {
+  constructor(readonly config: EventUpcasterStepConfig<From, To>) {
+    if (config.toVersion !== config.fromVersion + 1) throw new Error(EventUpcasterStepError.VersionIncrement);
+  }
+}

package/src/event-upcaster.port.ts

@@ -0,0 +1,5 @@
+import type { GenericEvent } from "./event.types";
+
+export interface EventUpcasterPort {
+  upcast(event: GenericEvent): GenericEvent;
+}

package/src/event.types.ts

@@ -10,7 +10,7 @@ export type GenericEvent = {
   revision?: tools.RevisionValueType;
   name: string;
   version: number;
-  payload: unknown;
+  payload: Record<string, unknown>;
 };
 
 export type GenericEventSerialized = Omit<GenericEvent, "payload"> & { payload: string };

package/src/healthcheck-hono.handler.ts

@@ -1,13 +1,14 @@
 import { createFactory } from "hono/factory";
-import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
+import type { BuildInfoType } from "./build-info.vo";
 import type { ClockPort } from "./clock.port";
 import type { HandlerHonoPort } from "./handler-hono.port";
 import { type HealthcheckConfig, HealthcheckHandler } from "./healthcheck.handler";
 import type { LoggerStatsProviderPort } from "./logger-stats-provider.port";
+import type { ReactiveConfigPort } from "./reactive-config.port";
 
 type Dependencies = {
   Clock: ClockPort;
-  BuildInfoRepository: BuildInfoRepositoryStrategy;
+  BuildInfoConfig: ReactiveConfigPort<BuildInfoType>;
   LoggerStatsProvider?: LoggerStatsProviderPort;
 };
 

package/src/healthcheck.handler.ts

@@ -1,6 +1,6 @@
 import os from "node:os";
 import * as tools from "@bgord/tools";
-import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
+import type { BuildInfoType } from "./build-info.vo";
 import type { ClockPort } from "./clock.port";
 import type { CommitShaValueType } from "./commit-sha-value.vo";
 import { EventLoopLag } from "./event-loop-lag.service";
@@ -15,6 +15,7 @@ import {
   type PrerequisiteVerificationResult,
 } from "./prerequisite-verifier.port";
 import { PrerequisiteVerifierSelfAdapter } from "./prerequisite-verifier-self.adapter";
+import type { ReactiveConfigPort } from "./reactive-config.port";
 import type { RedactorStrategy } from "./redactor.strategy";
 import { Stopwatch } from "./stopwatch.service";
 import { Uptime, type UptimeResultType } from "./uptime.service";
@@ -27,7 +28,7 @@ export enum HealthcheckStatusEnum {
 
 type Dependencies = {
   Clock: ClockPort;
-  BuildInfoRepository: BuildInfoRepositoryStrategy;
+  BuildInfoConfig: ReactiveConfigPort<BuildInfoType>;
   LoggerStatsProvider?: LoggerStatsProviderPort;
 };
 
@@ -125,7 +126,7 @@ export class HealthcheckHandler {
         ? HealthcheckStatusEnum.degraded
         : HealthcheckStatusEnum.healthy;
 
-    const build = await this.deps.BuildInfoRepository.extract();
+    const build = await this.deps.BuildInfoConfig.get();
     const uptime = Uptime.get(this.deps.Clock);
     const histogram = EventLoopLag.snapshot();
     const memory = MemoryConsumption.snapshot();
@@ -135,11 +136,11 @@ export class HealthcheckHandler {
       code: HealthcheckStatusCode[status],
       details,
       deployment: {
-        version: build.version.toString(),
-        timestamp: build.timestamp.ms,
-        date: new Date(build.timestamp.ms).toISOString(),
-        sha: build.sha.toString(),
-        size: build.size.format(tools.Size.unit.MB),
+        version: build.version,
+        timestamp: build.timestamp,
+        date: new Date(build.timestamp).toISOString(),
+        sha: build.sha,
+        size: tools.Size.fromBytes(build.size).format(tools.Size.unit.MB),
         environment: this.config.Env,
       },
       server: {

package/src/index.ts

@@ -35,10 +35,7 @@ export * from "./basic-auth-username.vo";
 export * from "./better-auth-logger.service";
 export * from "./binary.vo";
 export * from "./bots.vo";
-export * from "./build-info-repository.strategy";
-export * from "./build-info-repository-file.strategy";
-export * from "./build-info-repository-noop.strategy";
-export * from "./build-info-repository-package-json.strategy";
+export * from "./build-info.vo";
 export * from "./cache-file.service";
 export * from "./cache-repository.port";
 export * from "./cache-repository-node-cache.adapter";
@@ -114,6 +111,10 @@ export * from "./event-store-dispatching.adapter";
 export * from "./event-store-noop.adapter";
 export * from "./event-store-with-logger.adapter";
 export * from "./event-stream.vo";
+export * from "./event-upcaster.port";
+export * from "./event-upcaster-chain.adapter";
+export * from "./event-upcaster-noop.adapter";
+export * from "./event-upcaster-step.vo";
 export * from "./event-validator-registry.adapter";
 export * from "./event-validator-registry.port";
 export * from "./file-cleaner.adapter";
@@ -303,6 +304,11 @@ export * from "./randomness.strategy";
 export * from "./randomness-crypto.strategy";
 export * from "./randomness-math.strategy";
 export * from "./randomness-noop.strategy";
+export * from "./reactive-config.port";
+export * from "./reactive-config-file-json.adapter";
+export * from "./reactive-config-noop.adapter";
+export * from "./reactive-config-with-cache.adapter";
+export * from "./reactive-config-with-fallback.adapter";
 export * from "./readiness.handler";
 export * from "./readiness-hono.handler";
 export * from "./recaptcha-secret-key.vo";

package/src/modules/preferences/command-handlers/handleSetUserLanguageCommand.ts

@@ -1,7 +1,6 @@
 import type * as tools from "@bgord/tools";
-import * as v from "valibot";
 import type { ClockPort } from "../../../clock.port";
-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 { Languages } from "../../../languages.vo";
@@ -34,11 +33,12 @@ export const handleSetUserLanguageCommand =
 
     if (!Invariants.UserLanguageHasChanged.passes({ current, candidate })) return;
 
-    const event = v.parse(Events.UserLanguageSetEvent, {
-      ...createEventEnvelope(`preferences_${command.payload.userId}`, deps),
-      name: Events.USER_LANGUAGE_SET_EVENT,
-      payload: { userId: command.payload.userId, language: candidate },
-    } satisfies Events.UserLanguageSetEventType);
-
-    await deps.EventStore.save([event]);
+    await deps.EventStore.save([
+      event(
+        Events.UserLanguageSetEvent,
+        `preferences_${command.payload.userId}`,
+        { userId: command.payload.userId, language: candidate },
+        deps,
+      ),
+    ]);
   };

package/src/modules/system/services/passage-of-time-hourly.service.ts

@@ -1,15 +1,10 @@
-import * as v from "valibot";
 import type { ClockPort } from "../../../clock.port";
-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 { UnitOfWork } from "../../../job-handler.strategy";
 import { Jobs } from "../../../jobs.service";
-import {
-  HOUR_HAS_PASSED_EVENT,
-  HourHasPassedEvent,
-  type HourHasPassedEventType,
-} from "../events/HOUR_HAS_PASSED_EVENT";
+import { HourHasPassedEvent, type HourHasPassedEventType } from "../events/HOUR_HAS_PASSED_EVENT";
 
 type Dependencies = {
   EventStore: EventStorePort<HourHasPassedEventType>;
@@ -25,12 +20,8 @@ export class PassageOfTimeHourly implements UnitOfWork {
   label = "PassageOfTime";
 
   async process() {
-    const event = v.parse(HourHasPassedEvent, {
-      ...createEventEnvelope("passage_of_time", this.deps),
-      name: HOUR_HAS_PASSED_EVENT,
-      payload: { timestamp: this.deps.Clock.now().ms },
-    } satisfies HourHasPassedEventType);
-
-    await this.deps.EventStore.save([event]);
+    await this.deps.EventStore.save([
+      event(HourHasPassedEvent, "passage_of_time", { timestamp: this.deps.Clock.now().ms }, this.deps),
+    ]);
   }
 }

package/src/modules/system/services/passage-of-time-minute.service.ts

@@ -1,15 +1,10 @@
-import * as v from "valibot";
 import type { ClockPort } from "../../../clock.port";
-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 { UnitOfWork } from "../../../job-handler.strategy";
 import { Jobs } from "../../../jobs.service";
-import {
-  MINUTE_HAS_PASSED_EVENT,
-  MinuteHasPassedEvent,
-  type MinuteHasPassedEventType,
-} from "../events/MINUTE_HAS_PASSED_EVENT";
+import { MinuteHasPassedEvent, type MinuteHasPassedEventType } from "../events/MINUTE_HAS_PASSED_EVENT";
 
 type Dependencies = {
   EventStore: EventStorePort<MinuteHasPassedEventType>;
@@ -25,12 +20,8 @@ export class PassageOfTimeMinute implements UnitOfWork {
   label = "PassageOfTime";
 
   async process() {
-    const event = v.parse(MinuteHasPassedEvent, {
-      ...createEventEnvelope("passage_of_time", this.deps),
-      name: MINUTE_HAS_PASSED_EVENT,
-      payload: { timestamp: this.deps.Clock.now().ms },
-    } satisfies MinuteHasPassedEventType);
-
-    await this.deps.EventStore.save([event]);
+    await this.deps.EventStore.save([
+      event(MinuteHasPassedEvent, "passage_of_time", { timestamp: this.deps.Clock.now().ms }, this.deps),
+    ]);
   }
 }

package/src/reactive-config-file-json.adapter.ts

@@ -0,0 +1,26 @@
+import type * as tools from "@bgord/tools";
+import type { FileReaderJsonPort } from "./file-reader-json.port";
+import {
+  ReactiveConfigError,
+  type ReactiveConfigPort,
+  type ReactiveConfigSchema,
+} from "./reactive-config.port";
+
+type Dependencies = { FileReaderJson: FileReaderJsonPort };
+
+export class ReactiveConfigFileJsonAdapter<T extends object> implements ReactiveConfigPort<T> {
+  constructor(
+    private readonly path: tools.FilePathAbsolute | tools.FilePathRelative,
+    private readonly schema: ReactiveConfigSchema<T>,
+    private readonly deps: Dependencies,
+  ) {}
+
+  async get(): Promise<Readonly<T>> {
+    const raw = await this.deps.FileReaderJson.read(this.path);
+
+    const result = this.schema["~standard"].validate(raw);
+    if (result instanceof Promise) throw new Error(ReactiveConfigError.NoAsyncSchema);
+    if (result.issues) throw new Error(result.issues[0]?.message);
+    return Object.freeze(result.value);
+  }
+}

package/src/reactive-config-noop.adapter.ts

@@ -0,0 +1,19 @@
+import {
+  ReactiveConfigError,
+  type ReactiveConfigPort,
+  type ReactiveConfigSchema,
+} from "./reactive-config.port";
+
+export class ReactiveConfigNoopAdapter<T extends object> implements ReactiveConfigPort<T> {
+  constructor(
+    private readonly schema: ReactiveConfigSchema<T>,
+    private readonly value: T,
+  ) {}
+
+  async get(): Promise<Readonly<T>> {
+    const result = this.schema["~standard"].validate(this.value);
+    if (result instanceof Promise) throw new Error(ReactiveConfigError.NoAsyncSchema);
+    if (result.issues) throw new Error(result.issues[0]?.message);
+    return Object.freeze(result.value);
+  }
+}

package/src/reactive-config-with-cache.adapter.ts

@@ -0,0 +1,19 @@
+import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import type { HashContentStrategy } from "./hash-content.strategy";
+import type { ReactiveConfigPort } from "./reactive-config.port";
+
+type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy };
+
+export class ReactiveConfigWithCacheAdapter<T extends object> implements ReactiveConfigPort<T> {
+  constructor(
+    private readonly inner: ReactiveConfigPort<T>,
+    private readonly subject: string,
+    private readonly deps: Dependencies,
+  ) {}
+
+  async get(): Promise<Readonly<T>> {
+    const key = await this.deps.HashContent.hash(this.subject);
+
+    return this.deps.CacheResolver.resolve(key, () => this.inner.get());
+  }
+}

package/src/reactive-config-with-fallback.adapter.ts

@@ -0,0 +1,24 @@
+import {
+  ReactiveConfigError,
+  type ReactiveConfigPort,
+  type ReactiveConfigSchema,
+} from "./reactive-config.port";
+
+export class ReactiveConfigWithFallbackAdapter<T extends object> implements ReactiveConfigPort<T> {
+  constructor(
+    private readonly inner: ReactiveConfigPort<T>,
+    private readonly schema: ReactiveConfigSchema<T>,
+    private readonly fallback: T,
+  ) {}
+
+  async get(): Promise<Readonly<T>> {
+    try {
+      return await this.inner.get();
+    } catch {
+      const result = this.schema["~standard"].validate(this.fallback);
+      if (result instanceof Promise) throw new Error(ReactiveConfigError.NoAsyncSchema);
+      if (result.issues) throw new Error(result.issues[0]?.message);
+      return Object.freeze(result.value);
+    }
+  }
+}

package/src/reactive-config.port.ts

@@ -0,0 +1,9 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+export const ReactiveConfigError = { NoAsyncSchema: "reactive.config.no.async.schema" };
+
+export type ReactiveConfigSchema<T extends object> = StandardSchemaV1<unknown, T>;
+
+export interface ReactiveConfigPort<T extends object> {
+  get(): Promise<Readonly<T>>;
+}

package/src/redactor-error-cause-depth-limit.strategy.ts

@@ -10,9 +10,8 @@ export class RedactorErrorCauseDepthLimit implements RedactorStrategy {
     // Stryker disable all
     if (!isPlainObject(input)) return input;
     // Stryker restore all
-    if (!ErrorNormalizer.isNormalizedError(input.error)) return input;
-
-    return { ...input, error: this.limit(input.error, tools.Int.nonNegative(0)) };
+    if (!ErrorNormalizer.isNormalizedError(input["error"])) return input;
+    return { ...input, error: this.limit(input["error"], tools.Int.nonNegative(0)) };
   }
 
   private limit(error: NormalizedError, depth: tools.IntegerNonNegativeType): NormalizedError {

package/src/redactor-error-stack-hide.strategy.ts

@@ -7,9 +7,8 @@ export class RedactorErrorStackHide implements RedactorStrategy {
     // Stryker disable all
     if (!isPlainObject(input)) return input;
     // Stryker restore all
-    if (!ErrorNormalizer.isNormalizedError(input.error)) return input;
-
-    return { ...input, error: this.hide(input.error) };
+    if (!ErrorNormalizer.isNormalizedError(input["error"])) return input;
+    return { ...input, error: this.hide(input["error"]) };
   }
 
   private hide(error: NormalizedError): NormalizedError {

package/src/redactor-metadata-compact-array.strategy.ts

@@ -20,7 +20,7 @@ export class RedactorMetadataCompactArray implements RedactorStrategy {
     return {
       ...input,
       metadata: deepCloneWith(
-        input.metadata,
+        input["metadata"],
         (value) => {
           if (!Array.isArray(value)) return undefined;
           if (value.length <= this.maxItems) return undefined;

package/src/redactor-metadata-compact-object.strategy.ts

@@ -20,7 +20,7 @@ export class RedactorMetadataCompactObject implements RedactorStrategy {
     return {
       ...input,
       metadata: deepCloneWith(
-        input.metadata,
+        input["metadata"],
         (value) => {
           if (!isPlainObject(value) || Array.isArray(value)) return undefined;