@bgord/bun 1.23.0 → 1.23.2

package/src/file-type-detector-text.strategy.ts

@@ -0,0 +1,25 @@
+import type * as tools from "@bgord/tools";
+import type { FileTypeDetectorStrategy } from "./file-type-detector.strategy";
+
+const ALLOWED_CONTROL_BYTES = [0x09, 0x0a, 0x0c, 0x0d];
+
+const isControlByte = (byte: number) =>
+  (byte < 0x20 && !ALLOWED_CONTROL_BYTES.includes(byte)) || byte === 0x7f;
+
+export class FileTypeDetectorTextStrategy implements FileTypeDetectorStrategy {
+  constructor(private readonly mime: tools.Mime) {}
+
+  async detect(file: File): Promise<tools.Mime | null> {
+    const bytes = new Uint8Array(await file.slice(0, 1445).arrayBuffer());
+
+    if (bytes.length === 0) return null;
+    if (bytes.some(isControlByte)) return null;
+
+    const text = new TextDecoder().decode(bytes);
+
+    if (text.includes("\ufffd")) return null;
+    if (text.trimStart().startsWith("<")) return null;
+
+    return this.mime;
+  }
+}

package/src/file-type-detector.strategy.ts

@@ -0,0 +1,5 @@
+import type * as tools from "@bgord/tools";
+
+export interface FileTypeDetectorStrategy {
+  detect(file: File): Promise<tools.Mime | null>;
+}

package/src/file-uploader-hono.middleware.ts

@@ -1,14 +1,17 @@
 import { createMiddleware } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
+import type { FileTypeDetectorStrategy } from "./file-type-detector.strategy";
 import { type FileUploaderConfig, FileUploaderMiddleware } from "./file-uploader.middleware";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
 import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
 
+type Dependencies = { FileTypeDetector: FileTypeDetectorStrategy };
+
 export class FileUploaderHonoMiddleware implements MiddlewareHonoPort {
   private readonly middleware: FileUploaderMiddleware;
 
-  constructor(config: FileUploaderConfig) {
-    this.middleware = new FileUploaderMiddleware(config);
+  constructor(config: FileUploaderConfig, deps: Dependencies) {
+    this.middleware = new FileUploaderMiddleware(config, deps);
   }
 
   handle() {

package/src/file-uploader.middleware.ts

@@ -1,8 +1,11 @@
 import * as tools from "@bgord/tools";
+import type { FileTypeDetectorStrategy } from "./file-type-detector.strategy";
 import type { HasRequestForm } from "./request-context.port";
 
 export type FileUploaderConfig = { MimeRegistry: tools.MimeRegistry; maxSize: tools.Size; field: string };
 
+type Dependencies = { FileTypeDetector: FileTypeDetectorStrategy };
+
 export const FileUploaderError = {
   MissingFile: "file.uploader.missing.file",
   EmptyFile: "file.uploader.empty.file",
@@ -15,7 +18,10 @@ export type FileValidationError = (typeof FileUploaderError)[keyof typeof FileUp
 export type FileValidationResult = { valid: true } | { valid: false; error: FileValidationError };
 
 export class FileUploaderMiddleware {
-  constructor(private readonly config: FileUploaderConfig) {}
+  constructor(
+    private readonly config: FileUploaderConfig,
+    private readonly deps: Dependencies,
+  ) {}
 
   async validate(context: HasRequestForm): Promise<FileValidationResult> {
     const form = await context.request.form();
@@ -28,8 +34,9 @@ export class FileUploaderMiddleware {
 
     if (size.isGreaterThan(this.config.maxSize)) return { valid: false, error: FileUploaderError.SizeLimit };
 
-    // TODO: MIME spoofing possible by reading client-supplied file.type
-    const mime = tools.Mime.fromString(file.type);
+    const mime = await this.deps.FileTypeDetector.detect(file);
+
+    if (!mime) return { valid: false, error: FileUploaderError.InvalidMime };
 
     if (!this.config.MimeRegistry.hasMime(mime)) {
       return { valid: false, error: FileUploaderError.InvalidMime };

package/src/hcaptcha.service.ts

@@ -4,7 +4,7 @@ export const HCaptchaServiceError = { Error: "hcaptcha.service.error" };
 
 type HcaptchaTokenType = string;
 
-export type HCaptchaVerificationResult = { success: boolean };
+export type HCaptchaVerificationResult = { success: boolean; hostname?: string };
 
 export class HCaptchaService {
   async verify(

package/src/healthcheck.handler.ts

@@ -37,7 +37,7 @@ export type HealthcheckDependencies = {
 export type HealthcheckConfig = {
   Env: NodeEnvironmentEnum;
   prerequisites: ReadonlyArray<Prerequisite>;
-  redactor?: RedactorStrategy;
+  redactor: RedactorStrategy;
 };
 
 const self = new Prerequisite("self", new PrerequisiteVerifierSelfAdapter());
@@ -111,7 +111,7 @@ export class HealthcheckHandler {
 
         return {
           label: prerequisite.label,
-          outcome: this.config.redactor ? this.config.redactor.redact(outcome) : outcome,
+          outcome: this.config.redactor.redact(outcome),
           ms: stopwatch.stop().ms,
         };
       }),

package/src/http-exception-errors.ts

@@ -0,0 +1,31 @@
+import { FileUploaderError } from "./file-uploader.middleware";
+import { ShieldApiKeyStrategyError } from "./shield-api-key.strategy";
+import { ShieldAuthStrategyError } from "./shield-auth.strategy";
+import { ShieldBasicAuthStrategyError } from "./shield-basic-auth.strategy";
+import { ShieldBodyLimitError } from "./shield-body-limit.strategy";
+import { ShieldCsrfStrategyError } from "./shield-csrf.strategy";
+import { ShieldHcaptchaStrategyError } from "./shield-hcaptcha.strategy";
+import { ShieldHcaptchaLocalStrategyError } from "./shield-hcaptcha-hono-local.strategy";
+import { ShieldIpBlacklistStrategyError } from "./shield-ip-blacklist.strategy";
+import { ShieldIpWhitelistStrategyError } from "./shield-ip-whitelist.strategy";
+import { ShieldRateLimitStrategyError } from "./shield-rate-limit.strategy";
+import { ShieldRecaptchaStrategyError } from "./shield-recaptcha.strategy";
+import { ShieldTimeoutStrategyError } from "./shield-timeout.strategy";
+import { ShieldWebhookStrategyError } from "./shield-webhook.strategy";
+
+export const HttpExceptionErrors = {
+  ShieldApiKeyRejected: ShieldApiKeyStrategyError.Rejected,
+  ShieldAuthRejected: ShieldAuthStrategyError.Rejected,
+  ShieldBasicAuthRejected: ShieldBasicAuthStrategyError.Rejected,
+  ShieldBodyLimitTooBig: ShieldBodyLimitError.TooBig,
+  ShieldCsrfRejected: ShieldCsrfStrategyError.Rejected,
+  ShieldHcaptchaRejected: ShieldHcaptchaStrategyError.Rejected,
+  ShieldHcaptchaLocalRejected: ShieldHcaptchaLocalStrategyError.Rejected,
+  ShieldIpBlacklistRejected: ShieldIpBlacklistStrategyError.Rejected,
+  ShieldIpWhitelistRejected: ShieldIpWhitelistStrategyError.Rejected,
+  ShieldRateLimitRejected: ShieldRateLimitStrategyError.Rejected,
+  ShieldRecaptchaRejected: ShieldRecaptchaStrategyError.Rejected,
+  ShieldTimeoutRejected: ShieldTimeoutStrategyError.Rejected,
+  ShieldWebhookRejected: ShieldWebhookStrategyError.Rejected,
+  ...FileUploaderError,
+} as const;

package/src/index.ts

@@ -180,6 +180,10 @@ export * from "./file-renamer.port";
 export * from "./file-renamer-node.adapter";
 export * from "./file-renamer-node-forgiving.adapter";
 export * from "./file-renamer-noop.adapter";
+export * from "./file-type-detector.strategy";
+export * from "./file-type-detector-fixed.strategy";
+export * from "./file-type-detector-magic-bytes.strategy";
+export * from "./file-type-detector-text.strategy";
 export * from "./file-uploader.middleware";
 export * from "./file-uploader-hono.middleware";
 export * from "./file-writer.adapter";
@@ -212,6 +216,7 @@ export * from "./hcaptcha-site-key.vo";
 export * from "./healthcheck.handler";
 export * from "./healthcheck-hono.handler";
 export * from "./hostname.vo";
+export * from "./http-exception-errors";
 export * from "./http-logger.middleware";
 export * from "./http-logger-hono.middleware";
 export * from "./id-provider.port";
@@ -261,7 +266,6 @@ export * from "./in-flight-requests-hono.middleware";
 export * from "./in-flight-requests-tracker.service";
 export * from "./instrumentation.service";
 export * from "./invariant.service";
-export * from "./invariant-error-handler.service";
 export * from "./job.types";
 export * from "./job-claimer.port";
 export * from "./job-claimer-noop.adapter";
@@ -537,6 +541,7 @@ export * from "./subject-segment-method.strategy";
 export * from "./subject-segment-param.strategy";
 export * from "./subject-segment-path.strategy";
 export * from "./subject-segment-query.strategy";
+export * from "./subject-segment-remote-ip.strategy";
 export * from "./subject-segment-request.strategy";
 export * from "./subject-segment-user.strategy";
 export * from "./temporary-file.port";
@@ -576,6 +581,7 @@ export * from "./weak-etag-extractor-header.strategy";
 export * from "./weak-etag-extractor-hono.middleware";
 export * from "./weak-etag-extractor-param.strategy";
 export * from "./webhook-body-builder.strategy";
+export * from "./webhook-body-builder-signed-headers.strategy";
 export * from "./webhook-body-builder-text.strategy";
 export * from "./webhook-id.vo";
 export * from "./webhook-id-extractor.strategy";

package/src/readiness.handler.ts

@@ -3,8 +3,12 @@ import {
   PrerequisiteVerificationOutcome,
   type PrerequisiteVerificationResult,
 } from "./prerequisite-verifier.port";
+import type { RedactorStrategy } from "./redactor.strategy";
 
-export type ReadinessConfig = { prerequisites: ReadonlyArray<Prerequisite> };
+export type ReadinessConfig = {
+  prerequisites: ReadonlyArray<Prerequisite>;
+  redactor: RedactorStrategy;
+};
 
 export enum ReadinessStatusCode {
   Ready = 200,
@@ -28,7 +32,7 @@ export class ReadinessHandler {
     const details = await Promise.all(
       prerequisites.map(async (prerequisite) => ({
         label: prerequisite.label,
-        outcome: await prerequisite.build().verify(),
+        outcome: this.config.redactor.redact(await prerequisite.build().verify()),
       })),
     );
 

package/src/remote-file-storage-disk.adapter.ts

@@ -37,7 +37,10 @@ export class RemoteFileStorageDiskAdapter implements RemoteFileStoragePort {
     const parts = key.split("/");
     const filename = tools.Filename.fromString(parts.pop() as string);
 
-    const directory = v.parse(tools.DirectoryPathAbsoluteSchema, `${this.config.root}/${parts.join("/")}`);
+    if (parts.length === 0) return tools.FilePathAbsolute.fromPartsSafe(this.config.root, filename);
+
+    const base = this.config.root === "/" ? "" : this.config.root;
+    const directory = v.parse(tools.DirectoryPathAbsoluteSchema, `${base}/${parts.join("/")}`);
 
     return tools.FilePathAbsolute.fromPartsSafe(directory, filename);
   }

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

@@ -34,9 +34,13 @@ export class SealerAesGcmAdapter implements SealerPort {
 
     const key = await this.deps.CryptoKeyProvider.get();
 
-    const encrypted = Uint8Array.fromBase64(value.slice(SealerAesGcmAdapter.PREFIX.length));
-    const plaintext = await CryptoAesGcm.decrypt(key, encrypted);
+    try {
+      const encrypted = Uint8Array.fromBase64(value.slice(SealerAesGcmAdapter.PREFIX.length));
+      const plaintext = await CryptoAesGcm.decrypt(key, encrypted);
 
-    return JSON.parse(new TextDecoder().decode(plaintext));
+      return JSON.parse(new TextDecoder().decode(plaintext));
+    } catch {
+      throw new Error(SealerAesGcmAdapterError.InvalidPayload);
+    }
   }
 }

package/src/security-rule-user-agent.strategy.ts

@@ -1,6 +1,5 @@
 import * as v from "valibot";
 import { ALL_BOTS } from "./bots.vo";
-import { Client } from "./client.vo";
 import type { RequestContext } from "./request-context.port";
 import type { SecurityRuleStrategy } from "./security-rule.strategy";
 import { SecurityRuleName, type SecurityRuleNameType } from "./security-rule-name.vo";
@@ -9,9 +8,11 @@ export class SecurityRuleUserAgentStrategy implements SecurityRuleStrategy {
   constructor(private readonly blacklist: ReadonlyArray<string> = ALL_BOTS) {}
 
   async isViolated(context: RequestContext): Promise<boolean> {
-    const client = Client.fromParts(context.identity.ip(), context.identity.ua());
+    const ua = context.identity.ua()?.toLowerCase();
 
-    return this.blacklist.some((bot) => client.hasSameUa(Client.fromParts(undefined, bot)));
+    if (!ua) return false;
+
+    return this.blacklist.some((bot) => ua.includes(bot.toLowerCase()));
   }
 
   get name(): SecurityRuleNameType {

package/src/security-rule-violation-threshold.strategy.ts

@@ -7,25 +7,31 @@ import type { SecurityRuleStrategy } from "./security-rule.strategy";
 import { SecurityRuleName, type SecurityRuleNameType } from "./security-rule-name.vo";
 import { SubjectRequestResolver } from "./subject-request-resolver.vo";
 import { SubjectSegmentFixedStrategy } from "./subject-segment-fixed.strategy";
-import { SubjectSegmentIpStrategy } from "./subject-segment-ip.strategy";
+import type { SubjectSegmentRequestStrategy } from "./subject-segment-request.strategy";
 
 type Dependencies = { CacheRepository: CacheRepositoryPort; HashContent: HashContentStrategy };
-type Config = { threshold: tools.IntegerPositiveType };
+type Config = {
+  threshold: tools.IntegerPositiveType;
+  segments: ReadonlyArray<SubjectSegmentRequestStrategy>;
+};
 
 export class SecurityRuleViolationThresholdStrategy implements SecurityRuleStrategy {
+  private readonly resolver: SubjectRequestResolver;
+
   constructor(
     private readonly rule: SecurityRuleStrategy,
     private readonly config: Config,
     private readonly deps: Dependencies,
-  ) {}
+  ) {
+    this.resolver = new SubjectRequestResolver(
+      [new SubjectSegmentFixedStrategy(this.name), ...this.config.segments],
+      this.deps,
+    );
+  }
 
   // Best-effort increment, occasional lost increments are acceptable for concurrent requests.
   async isViolated(context: RequestContext): Promise<boolean> {
-    const resolver = new SubjectRequestResolver(
-      [new SubjectSegmentFixedStrategy(this.name), new SubjectSegmentIpStrategy()],
-      this.deps,
-    );
-    const subject = await resolver.resolve(context);
+    const subject = await this.resolver.resolve(context);
 
     const violated = await this.rule.isViolated(context);
 

package/src/shield-body-limit.strategy.ts

@@ -12,9 +12,11 @@ export class ShieldBodyLimitStrategy {
   evaluate(context: HasRequestHeader): boolean {
     const header = context.request.header("content-length");
 
+    if (header === undefined) return true;
+
     const contentLength = v.safeParse(tools.SizeBytes, Number(header));
 
-    if (!contentLength.success) return true;
+    if (!contentLength.success) return false;
 
     const size = tools.Size.fromBytes(contentLength.output);
 

package/src/shield-hcaptcha-hono-local.strategy.ts

@@ -18,8 +18,13 @@ export class ShieldHcaptchaLocalHonoStrategy implements MiddlewareHonoPort {
 
   private static readonly TOKEN_LOCAL = "10000000-aaaa-bbbb-cccc-000000000001";
 
+  private static readonly HOSTNAME_LOCAL = "local-pass";
+
   constructor() {
-    this.strategy = new ShieldHcaptchaStrategy(ShieldHcaptchaLocalHonoStrategy.SECRET_KEY_LOCAL);
+    this.strategy = new ShieldHcaptchaStrategy({
+      secretKey: ShieldHcaptchaLocalHonoStrategy.SECRET_KEY_LOCAL,
+      hostname: ShieldHcaptchaLocalHonoStrategy.HOSTNAME_LOCAL,
+    });
   }
 
   handle(): MiddlewareHandler {

package/src/shield-hcaptcha-hono.strategy.ts

@@ -1,15 +1,18 @@
 import type { MiddlewareHandler } from "hono";
 import { HTTPException } from "hono/http-exception";
-import type { HCaptchaSecretKeyType } from "./hcaptcha-secret-key.vo";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
 import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
-import { ShieldHcaptchaStrategy, ShieldHcaptchaStrategyError } from "./shield-hcaptcha.strategy";
+import {
+  type ShieldHcaptchaConfig,
+  ShieldHcaptchaStrategy,
+  ShieldHcaptchaStrategyError,
+} from "./shield-hcaptcha.strategy";
 
 export class ShieldHcaptchaHonoStrategy implements MiddlewareHonoPort {
   private readonly strategy: ShieldHcaptchaStrategy;
 
-  constructor(secretKey: HCaptchaSecretKeyType) {
-    this.strategy = new ShieldHcaptchaStrategy(secretKey);
+  constructor(config: ShieldHcaptchaConfig) {
+    this.strategy = new ShieldHcaptchaStrategy(config);
   }
 
   handle(): MiddlewareHandler {

package/src/shield-hcaptcha.strategy.ts

@@ -6,10 +6,12 @@ export const ShieldHcaptchaStrategyError = { Rejected: "shield.hcaptcha.rejected
 
 export const ShieldHcaptchaStrategyField = "h-captcha-response";
 
+export type ShieldHcaptchaConfig = { secretKey: HCaptchaSecretKeyType; hostname: string };
+
 export class ShieldHcaptchaStrategy {
   private readonly hcaptcha = new HCaptchaService();
 
-  constructor(private readonly secretKey: HCaptchaSecretKeyType) {}
+  constructor(private readonly config: ShieldHcaptchaConfig) {}
 
   async evaluate(context: HasRequestForm & HasRequestJson): Promise<boolean> {
     try {
@@ -23,9 +25,12 @@ export class ShieldHcaptchaStrategy {
 
       if (!token) return false;
 
-      const result = await this.hcaptcha.verify(this.secretKey, token);
+      const result = await this.hcaptcha.verify(this.config.secretKey, token);
+
+      if (!result.success) return false;
+      if (result.hostname !== this.config.hostname) return false;
 
-      return result.success;
+      return true;
     } catch {
       return false;
     }

package/src/shield-recaptcha.strategy.ts

@@ -4,8 +4,13 @@ import * as v from "valibot";
 import type { RecaptchaSecretKeyType } from "./recaptcha-secret-key.vo";
 import type { HasIdentityIp, HasRequestForm, HasRequestJson } from "./request-context.port";
 
-export type ShieldRecaptchaConfig = { secretKey: RecaptchaSecretKeyType; threshold?: number };
-export type RecaptchaResult = { success: boolean; score: number };
+export type ShieldRecaptchaConfig = {
+  secretKey: RecaptchaSecretKeyType;
+  hostname: string;
+  action?: string;
+  threshold?: number;
+};
+export type RecaptchaResult = { success: boolean; score: number; hostname?: string; action?: string };
 
 export const ShieldRecaptchaStrategyError = { Rejected: "shield.recaptcha.rejected" };
 
@@ -51,6 +56,8 @@ export class ShieldRecaptchaStrategy {
 
       if (!result.success) return false;
       if (typeof result.score !== "number" || result.score < threshold) return false;
+      if (result.hostname !== this.config.hostname) return false;
+      if (this.config.action !== undefined && result.action !== this.config.action) return false;
 
       return true;
     } catch {

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

@@ -0,0 +1,14 @@
+import type { HasIdentityRemoteIp } from "./request-context.port";
+import {
+  SubjectSegmentRequestEmpty,
+  type SubjectSegmentRequestStrategy,
+  type SubjectSegmentType,
+} from "./subject-segment-request.strategy";
+
+export class SubjectSegmentRemoteIpStrategy implements SubjectSegmentRequestStrategy {
+  readonly label = "remote-ip";
+
+  create(context: HasIdentityRemoteIp): SubjectSegmentType {
+    return context.identity.remoteIp() ?? SubjectSegmentRequestEmpty;
+  }
+}

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

@@ -1,5 +1,6 @@
 import type {
   HasIdentityIp,
+  HasIdentityRemoteIp,
   HasIdentityUserId,
   HasRequestCookie,
   HasRequestHeader,
@@ -21,6 +22,7 @@ type RequestContextCapabilities = HasRequestCookie &
   HasRequestQueries &
   HasRequestParam &
   HasIdentityIp &
+  HasIdentityRemoteIp &
   HasIdentityUserId;
 
 export interface SubjectSegmentRequestStrategy {

package/src/webhook-body-builder-signed-headers.strategy.ts

@@ -0,0 +1,12 @@
+import type { HasRequestHeader, HasRequestText } from "./request-context.port";
+import type { WebhookBodyBuilderStrategy } from "./webhook-body-builder.strategy";
+
+export class WebhookBodyBuilderSignedHeadersStrategy implements WebhookBodyBuilderStrategy {
+  constructor(private readonly headers: ReadonlyArray<string>) {}
+
+  async build(context: HasRequestHeader & HasRequestText): Promise<string> {
+    const headers = this.headers.map((name) => [name, context.request.header(name) ?? null]);
+
+    return JSON.stringify([headers, await context.request.text()]);
+  }
+}

package/src/webhook-signature.vo.ts

@@ -3,11 +3,16 @@ import * as v from "valibot";
 export const WebhookSignatureError = {
   Type: "webhook.signature.type",
   Empty: "webhook.signature.empty",
+  InvalidHex: "webhook.signature.invalid.hex",
 };
 
+// Hex chars allowed
+const CHARS_WHITELIST = /^[a-fA-F0-9]+$/;
+
 export const WebhookSignature = v.pipe(
   v.string(WebhookSignatureError.Type),
   v.nonEmpty(WebhookSignatureError.Empty),
+  v.regex(CHARS_WHITELIST, WebhookSignatureError.InvalidHex),
   // Stryker disable next-line StringLiteral
   v.brand("WebhookSignature"),
 );

package/src/webhook-verifier-sha256.strategy.ts

@@ -9,9 +9,10 @@ export class WebhookVerifierSha256Strategy implements WebhookVerifierStrategy {
   constructor(private readonly config: Config) {}
 
   verify(body: string, signature: WebhookSignatureType): boolean {
-    const digest = this.config.WebhookSignatureCreator.create(body);
+    const digest = Buffer.from(this.config.WebhookSignatureCreator.create(body));
+    const candidate = Buffer.from(signature);
 
-    if (digest.length !== signature.length) return false;
-    return timingSafeEqual(Buffer.from(digest), Buffer.from(signature));
+    if (digest.length !== candidate.length) return false;
+    return timingSafeEqual(digest, candidate);
   }
 }

package/src/woodchopper.ts

@@ -24,7 +24,7 @@ export type WoodchopperConfig = {
   level: LogLevelEnum;
   environment: NodeEnvironmentEnum;
   dispatcher: WoodchopperDispatcher;
-  redactor?: RedactorStrategy;
+  redactor: RedactorStrategy;
   diagnostics?: WoodchopperDiagnosticsStrategy;
 };
 
@@ -88,9 +88,7 @@ export class Woodchopper implements LoggerPort, LoggerStatsProviderPort {
 
     let withRedaction: LoggerEntry;
     try {
-      withRedaction = this.config.redactor
-        ? this.config.redactor.redact(withInjectedFields)
-        : withInjectedFields;
+      withRedaction = this.config.redactor.redact(withInjectedFields);
     } catch (error) {
       this.stats.recordDropped();
       this.config.diagnostics?.handle({ kind: "redaction", error });

package/dist/invariant-error-handler.service.d.ts

@@ -1,13 +0,0 @@
-import { type Invariant } from "./invariant.service";
-type BaseInvariantType = Invariant<any>;
-type InvariantMessageType = BaseInvariantType["message"];
-type ErrorResponseTupleType = [{
-    message: InvariantMessageType;
-    _known: true;
-}, number];
-export declare class InvariantErrorHandler {
-    static detect(invariants: ReadonlyArray<BaseInvariantType>, error: unknown): BaseInvariantType | null;
-    static respond(error: BaseInvariantType): ErrorResponseTupleType;
-}
-export {};
-//# sourceMappingURL=invariant-error-handler.service.d.ts.map

package/dist/invariant-error-handler.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"invariant-error-handler.service.d.ts","sourceRoot":"","sources":["../src/invariant-error-handler.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAwB,MAAM,qBAAqB,CAAC;AAE3E,KAAK,iBAAiB,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;AACxC,KAAK,oBAAoB,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAC;AACzD,KAAK,sBAAsB,GAAG,CAAC;IAAE,OAAO,EAAE,oBAAoB,CAAC;IAAC,MAAM,EAAE,IAAI,CAAA;CAAE,EAAE,MAAM,CAAC,CAAC;AAExF,qBAAa,qBAAqB;IAChC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,aAAa,CAAC,iBAAiB,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,iBAAiB,GAAG,IAAI,CAEpG;IAED,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,iBAAiB,GAAG,sBAAsB,CAQ/D;CACF"}

package/dist/invariant-error-handler.service.js

@@ -1,15 +0,0 @@
-import { InvariantFailureKind } from "./invariant.service";
-export class InvariantErrorHandler {
-    static detect(invariants, error) {
-        return invariants.find((invariant) => error instanceof invariant.error) ?? null;
-    }
-    static respond(error) {
-        const code = {
-            [InvariantFailureKind.forbidden]: 403,
-            [InvariantFailureKind.not_found]: 404,
-            [InvariantFailureKind.precondition]: 400,
-        };
-        return [{ message: error.message, _known: true }, code[error.kind]];
-    }
-}
-//# sourceMappingURL=invariant-error-handler.service.js.map

package/dist/invariant-error-handler.service.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"invariant-error-handler.service.js","sourceRoot":"","sources":["../src/invariant-error-handler.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAM3E,MAAM,OAAO,qBAAqB;IAChC,MAAM,CAAC,MAAM,CAAC,UAA4C,EAAE,KAAc;QACxE,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,KAAK,YAAY,SAAS,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC;IAClF,CAAC;IAED,MAAM,CAAC,OAAO,CAAC,KAAwB;QACrC,MAAM,IAAI,GAAyC;YACjD,CAAC,oBAAoB,CAAC,SAAS,CAAC,EAAE,GAAG;YACrC,CAAC,oBAAoB,CAAC,SAAS,CAAC,EAAE,GAAG;YACrC,CAAC,oBAAoB,CAAC,YAAY,CAAC,EAAE,GAAG;SACzC,CAAC;QAEF,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;IACtE,CAAC;CACF"}

package/src/invariant-error-handler.service.ts

@@ -1,21 +0,0 @@
-import { type Invariant, InvariantFailureKind } from "./invariant.service";
-
-type BaseInvariantType = Invariant<any>;
-type InvariantMessageType = BaseInvariantType["message"];
-type ErrorResponseTupleType = [{ message: InvariantMessageType; _known: true }, number];
-
-export class InvariantErrorHandler {
-  static detect(invariants: ReadonlyArray<BaseInvariantType>, error: unknown): BaseInvariantType | null {
-    return invariants.find((invariant) => error instanceof invariant.error) ?? null;
-  }
-
-  static respond(error: BaseInvariantType): ErrorResponseTupleType {
-    const code: Record<InvariantFailureKind, number> = {
-      [InvariantFailureKind.forbidden]: 403,
-      [InvariantFailureKind.not_found]: 404,
-      [InvariantFailureKind.precondition]: 400,
-    };
-
-    return [{ message: error.message, _known: true }, code[error.kind]];
-  }
-}