@bgord/bun 1.5.11 → 1.6.1

package/dist/visitor-id-client.adapter.d.ts

@@ -0,0 +1,14 @@
+import type { Client } from "./client.vo";
+import type { HashContentPort } from "./hash-content.port";
+import type { VisitorIdPort } from "./visitor-id.port";
+type Dependencies = {
+    HashContent: HashContentPort;
+};
+export declare class VisitorIdClientAdapter implements VisitorIdPort {
+    private readonly client;
+    private readonly deps;
+    constructor(client: Client, deps: Dependencies);
+    get(): Promise<import("./hash.vo").Hash>;
+}
+export {};
+//# sourceMappingURL=visitor-id-client.adapter.d.ts.map

package/dist/visitor-id-client.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitor-id-client.adapter.d.ts","sourceRoot":"","sources":["../src/visitor-id-client.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,KAAK,YAAY,GAAG;IAAE,WAAW,EAAE,eAAe,CAAA;CAAE,CAAC;AAErD,qBAAa,sBAAuB,YAAW,aAAa;IAExD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,IAAI;gBADJ,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,YAAY;IAG/B,GAAG;CAOV"}

package/dist/visitor-id-client.adapter.js

@@ -0,0 +1,14 @@
+export class VisitorIdClientAdapter {
+    client;
+    deps;
+    constructor(client, deps) {
+        this.client = client;
+        this.deps = deps;
+    }
+    async get() {
+        const { ip, ua } = this.client.toJSON();
+        const value = `${ip}|${ua}`;
+        return this.deps.HashContent.hash(value);
+    }
+}
+//# sourceMappingURL=visitor-id-client.adapter.js.map

package/dist/visitor-id-client.adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visitor-id-client.adapter.js","sourceRoot":"","sources":["../src/visitor-id-client.adapter.ts"],"names":[],"mappings":"AAMA,MAAM,OAAO,sBAAsB;IAEd;IACA;IAFnB,YACmB,MAAc,EACd,IAAkB;QADlB,WAAM,GAAN,MAAM,CAAQ;QACd,SAAI,GAAJ,IAAI,CAAc;IAClC,CAAC;IAEJ,KAAK,CAAC,GAAG;QACP,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QAExC,MAAM,KAAK,GAAG,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC;QAE5B,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;CACF"}

package/dist/visitor-id.port.d.ts

@@ -1,5 +1,5 @@
-import type { VisitorIdType } from "./visitor-id.vo";
+import type { Hash } from "./hash.vo";
 export interface VisitorIdPort {
-    get(): Promise<VisitorIdType>;
+    get(): Promise<Hash>;
 }
 //# sourceMappingURL=visitor-id.port.d.ts.map

package/dist/visitor-id.port.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"visitor-id.port.d.ts","sourceRoot":"","sources":["../src/visitor-id.port.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,WAAW,aAAa;IAC5B,GAAG,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;CAC/B"}
+{"version":3,"file":"visitor-id.port.d.ts","sourceRoot":"","sources":["../src/visitor-id.port.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC,MAAM,WAAW,aAAa;IAC5B,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACtB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.5.11",
+  "version": "1.6.1",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -23,7 +23,7 @@
     "@biomejs/biome": "2.3.10",
     "@commitlint/cli": "20.2.0",
     "@commitlint/config-conventional": "20.2.0",
-    "@types/bun": "1.3.4",
+    "@types/bun": "1.3.5",
     "@types/lodash": "4.17.21",
     "@types/nodemailer": "7.0.4",
     "@types/yazl": "3.3.0",

package/readme.md

@@ -42,11 +42,18 @@ src/
 ├── cache-resolver-simple.adapter.ts
 ├── cache-resolver.port.ts
 ├── cache-response.middleware.ts
+├── cache-subject-resolver.vo.ts
+├── cache-subject-segment-cookie.ts
+├── cache-subject-segment-fixed.ts
+├── cache-subject-segment-header.ts
+├── cache-subject-segment-path.ts
+├── cache-subject-segment-query.ts
+├── cache-subject-segment-user.ts
+├── cache-subject-segment.port.ts
 ├── certificate-inspector-noop.adapter.ts
 ├── certificate-inspector-tls.adapter.ts
 ├── certificate-inspector.port.ts
 ├── checksum.service.ts
-├── client-from-hono.adapter.ts
 ├── client.vo.ts
 ├── clock-fixed.adapter.ts
 ├── clock-system.adapter.ts
@@ -54,9 +61,6 @@ src/
 ├── command-envelope.ts
 ├── command-logger.service.ts
 ├── command.types.ts
-├── content-hash-noop.adapter.ts
-├── content-hash-sha256-bun.adapter.ts
-├── content-hash.port.ts
 ├── context.middleware.ts
 ├── correlation-id.vo.ts
 ├── correlation-storage.service.ts
@@ -97,10 +101,6 @@ src/
 ├── file-cleaner.port.ts
 ├── file-draft-zip.service.ts
 ├── file-draft.service.ts
-├── file-etag.vo.ts
-├── file-hash-noop.adapter.ts
-├── file-hash-sha256-bun.adapter.ts
-├── file-hash.port.ts
 ├── file-renamer-fs-forgiving.adapter.ts
 ├── file-renamer-fs.adapter.ts
 ├── file-renamer-noop.adapter.ts
@@ -111,6 +111,14 @@ src/
 ├── gzip-noop.adapter.ts
 ├── gzip-stream.adapter.ts
 ├── gzip.port.ts
+├── hash-content-noop.adapter.ts
+├── hash-content-sha256-bun.adapter.ts
+├── hash-content.port.ts
+├── hash-file-noop.adapter.ts
+├── hash-file-sha256-bun.adapter.ts
+├── hash-file.port.ts
+├── hash-value.vo.ts
+├── hash.vo.ts
 ├── hcaptcha-secret-key.vo.ts
 ├── hcaptcha-site-key.vo.ts
 ├── healthcheck.service.ts
@@ -162,8 +170,6 @@ src/
 ├── mailer-smtp.adapter.ts
 ├── mailer.port.ts
 ├── mailer.vo.ts
-├── markdown-generator-noop.adapter.ts
-├── markdown-generator.port.ts
 ├── memory-consumption.service.ts
 ├── modules
 │   ├── history
@@ -243,8 +249,6 @@ src/
 ├── remote-file-storage-noop.adapter.ts
 ├── remote-file-storage.port.ts
 ├── safe-parse-body.service.ts
-├── secret-manager-noop.adapter.ts
-├── secret-manager.port.ts
 ├── secret.vo.ts
 ├── setup.service.ts
 ├── shield-api-key.adapter.ts
@@ -272,10 +276,8 @@ src/
 ├── translations.service.ts
 ├── uptime.service.ts
 ├── uuid.vo.ts
-├── visitor-id-hash-hono.adapter.ts
-├── visitor-id-hash.adapter.ts
+├── visitor-id-client.adapter.ts
 ├── visitor-id.port.ts
-├── visitor-id.vo.ts
 └── weak-etag-extractor.middleware.ts
 ```
 

package/src/cache-file.service.ts

@@ -1,19 +1,19 @@
-import type { FileHashResult } from "./file-hash.port";
+import type { HashFileResult } from "./hash-file.port";
 
 type CacheFileOverridesType = Record<string, string>;
 
 interface CacheFileHandler {
-  notModified(options: FileHashResult, overrides?: CacheFileOverridesType): Response;
+  notModified(options: HashFileResult, overrides?: CacheFileOverridesType): Response;
 
-  fresh(options: FileHashResult, overrides?: CacheFileOverridesType): Headers;
+  fresh(options: HashFileResult, overrides?: CacheFileOverridesType): Headers;
 }
 
 export const CacheFileMustRevalidate: CacheFileHandler = {
-  notModified(options: FileHashResult, overrides: CacheFileOverridesType = {}) {
+  notModified(options: HashFileResult, overrides: CacheFileOverridesType = {}) {
     return new Response(null, {
       status: 304,
       headers: new Headers({
-        ETag: options.etag,
+        ETag: options.etag.get(),
         "Cache-Control": "private, max-age=0, must-revalidate",
         "Last-Modified": new Date(options.lastModified.ms).toUTCString(),
         Vary: "Authorization, Cookie",
@@ -22,11 +22,11 @@ export const CacheFileMustRevalidate: CacheFileHandler = {
     });
   },
 
-  fresh(options: FileHashResult, overrides: CacheFileOverridesType = {}) {
+  fresh(options: HashFileResult, overrides: CacheFileOverridesType = {}) {
     return new Headers({
       "Content-Type": options.mime.toString(),
       "Cache-Control": "private, max-age=0, must-revalidate",
-      ETag: options.etag,
+      ETag: options.etag.get(),
       "Content-Length": options.size.toBytes().toString(),
       "Last-Modified": new Date(options.lastModified.ms).toUTCString(),
       "Accept-Ranges": "bytes",

package/src/cache-repository-node-cache.adapter.ts

@@ -1,6 +1,7 @@
 import type * as tools from "@bgord/tools";
 import NodeCache from "node-cache";
-import type { CacheRepositoryKeyType, CacheRepositoryPort } from "./cache-repository.port";
+import type { CacheRepositoryPort } from "./cache-repository.port";
+import type { Hash } from "./hash.vo";
 
 export class CacheRepositoryNodeCacheAdapter implements CacheRepositoryPort {
   private readonly store: NodeCache;
@@ -15,16 +16,16 @@ export class CacheRepositoryNodeCacheAdapter implements CacheRepositoryPort {
     });
   }
 
-  async get<T>(key: CacheRepositoryKeyType): Promise<T | null> {
-    return this.store.get(key) ?? null;
+  async get<T>(subject: Hash): Promise<T | null> {
+    return this.store.get(subject.get()) ?? null;
   }
 
-  async set<T>(key: CacheRepositoryKeyType, value: T) {
-    this.store.set(key, value);
+  async set<T>(subject: Hash, value: T) {
+    this.store.set(subject.get(), value);
   }
 
-  async delete(key: CacheRepositoryKeyType) {
-    this.store.del(key);
+  async delete(subject: Hash) {
+    this.store.del(subject.get());
   }
 
   async flush() {

package/src/cache-repository.port.ts

@@ -1,11 +1,10 @@
 import type * as tools from "@bgord/tools";
-
-export type CacheRepositoryKeyType = string;
+import type { Hash } from "./hash.vo";
 
 export interface CacheRepositoryPort {
-  get<T>(key: CacheRepositoryKeyType): Promise<T | null>;
-  set<T>(key: CacheRepositoryKeyType, value: T): Promise<void>;
-  delete(key: CacheRepositoryKeyType): Promise<void>;
+  get<T>(subject: Hash): Promise<T | null>;
+  set<T>(subject: Hash, value: T): Promise<void>;
+  delete(subject: Hash): Promise<void>;
   flush(): Promise<void>;
   get ttl(): tools.Duration;
 }

package/src/cache-resolver-simple.adapter.ts

@@ -1,27 +1,28 @@
-import type { CacheRepositoryKeyType, CacheRepositoryPort } from "./cache-repository.port";
+import type { CacheRepositoryPort } from "./cache-repository.port";
 import { type CacheResolverPort, CacheSourceEnum } from "./cache-resolver.port";
+import type { Hash } from "./hash.vo";
 
 type Dependencies = { CacheRepository: CacheRepositoryPort };
 
 export class CacheResolverSimpleAdapter implements CacheResolverPort {
   constructor(private readonly deps: Dependencies) {}
 
-  async resolve<T>(key: CacheRepositoryKeyType, producer: () => Promise<T>): Promise<T> {
-    const result = await this.resolveWithContext(key, producer);
+  async resolve<T>(subject: Hash, producer: () => Promise<T>): Promise<T> {
+    const result = await this.resolveWithContext(subject, producer);
 
     return result.value;
   }
 
   async resolveWithContext<T>(
-    key: CacheRepositoryKeyType,
+    subject: Hash,
     producer: () => Promise<T>,
   ): Promise<{ value: T; source: CacheSourceEnum }> {
-    const cached = await this.deps.CacheRepository.get<T>(key);
+    const cached = await this.deps.CacheRepository.get<T>(subject);
 
     if (cached !== null) return { value: cached, source: CacheSourceEnum.hit };
 
     const value = await producer();
-    await this.deps.CacheRepository.set(key, value);
+    await this.deps.CacheRepository.set(subject, value);
 
     return { value, source: CacheSourceEnum.miss };
   }

package/src/cache-resolver.port.ts

@@ -1,5 +1,5 @@
 import type * as tools from "@bgord/tools";
-import type { CacheRepositoryKeyType } from "./cache-repository.port";
+import type { Hash } from "./hash.vo";
 
 export enum CacheSourceEnum {
   hit = "hit",
@@ -7,10 +7,10 @@ export enum CacheSourceEnum {
 }
 
 export interface CacheResolverPort {
-  resolve<T>(key: CacheRepositoryKeyType, producer: () => Promise<T>): Promise<T>;
+  resolve<T>(subject: Hash, producer: () => Promise<T>): Promise<T>;
 
   resolveWithContext<T>(
-    key: CacheRepositoryKeyType,
+    subject: Hash,
     producer: () => Promise<T>,
   ): Promise<{ value: T; source: CacheSourceEnum }>;
 

package/src/cache-response.middleware.ts

@@ -1,15 +1,11 @@
-import type { Context } from "hono";
 import { createMiddleware } from "hono/factory";
 import type { ContentfulStatusCode } from "hono/utils/http-status";
 import type { CacheResolverPort } from "./cache-resolver.port";
-
-type SubjectResolver = (c: Context) => string;
+import type { CacheSubjectResolver } from "./cache-subject-resolver.vo";
 
 type Dependencies = { CacheResolver: CacheResolverPort };
 
-type CacheResponseOptions = { enabled: boolean; subject: SubjectResolver };
-
-export const CacheResponseSubjectUrl: SubjectResolver = (c: Context) => `cache_response_${c.req.url}`;
+type CacheResponseOptions = { enabled: boolean; resolver: CacheSubjectResolver };
 
 type CachedResponse = {
   body: string;
@@ -28,9 +24,9 @@ export class CacheResponse {
   handle = createMiddleware(async (c, next) => {
     if (!this.config.enabled) return next();
 
-    const subject = this.config.subject(c);
+    const subject = await this.config.resolver.resolve(c);
 
-    const result = await this.deps.CacheResolver.resolveWithContext<CachedResponse>(subject, async () => {
+    const result = await this.deps.CacheResolver.resolveWithContext<CachedResponse>(subject.hex, async () => {
       await next();
 
       const response = c.res.clone();

package/src/cache-subject-resolver.vo.ts

@@ -0,0 +1,30 @@
+import type { Context } from "hono";
+import type { CacheSubjectSegmentPort, CacheSubjectSegmentType } from "./cache-subject-segment.port";
+import type { Hash } from "./hash.vo";
+import type { HashContentPort } from "./hash-content.port";
+
+type Dependencies = { HashContent: HashContentPort };
+
+export const CacheSubjectResolverError = { NoSegments: "cache.subject.no.segments" };
+
+export class CacheSubjectResolver {
+  private readonly SEPARATOR = "|";
+
+  constructor(
+    private readonly segments: CacheSubjectSegmentPort[],
+    private readonly deps: Dependencies,
+  ) {
+    if (this.segments.length === 0) throw new Error(CacheSubjectResolverError.NoSegments);
+  }
+
+  async resolve(context?: Context): Promise<{ hex: Hash; raw: CacheSubjectSegmentType[] }> {
+    const segments = this.segments.map((segment) =>
+      segment.create(context).replaceAll(this.SEPARATOR, encodeURIComponent(this.SEPARATOR)),
+    );
+    const subject = segments.join(this.SEPARATOR);
+
+    const hex = await this.deps.HashContent.hash(subject);
+
+    return { hex, raw: segments };
+  }
+}

package/src/cache-subject-segment-cookie.ts

@@ -0,0 +1,12 @@
+import type { Context } from "hono";
+import { getCookie } from "hono/cookie";
+import type { CacheSubjectSegmentPort } from "./cache-subject-segment.port";
+
+export class CacheSubjectSegmentCookie implements CacheSubjectSegmentPort {
+  constructor(private readonly name: string) {}
+
+  create(context?: Context) {
+    if (!context) return "";
+    return getCookie(context, this.name) ?? "";
+  }
+}

package/src/cache-subject-segment-fixed.ts

@@ -0,0 +1,9 @@
+import type { CacheSubjectSegmentPort } from "./cache-subject-segment.port";
+
+export class CacheSubjectSegmentFixed implements CacheSubjectSegmentPort {
+  constructor(private readonly value: string) {}
+
+  create() {
+    return this.value;
+  }
+}

package/src/cache-subject-segment-header.ts

@@ -0,0 +1,10 @@
+import type { Context } from "hono";
+import type { CacheSubjectSegmentPort } from "./cache-subject-segment.port";
+
+export class CacheSubjectSegmentHeader implements CacheSubjectSegmentPort {
+  constructor(private readonly name: string) {}
+
+  create(context?: Context) {
+    return context?.req.header(this.name) ?? "";
+  }
+}

package/src/cache-subject-segment-path.ts

@@ -0,0 +1,8 @@
+import type { Context } from "hono";
+import type { CacheSubjectSegmentPort } from "./cache-subject-segment.port";
+
+export class CacheSubjectSegmentPath implements CacheSubjectSegmentPort {
+  create(context?: Context) {
+    return context?.req.path ?? "";
+  }
+}

package/src/cache-subject-segment-query.ts

@@ -0,0 +1,13 @@
+import type { Context } from "hono";
+import type { CacheSubjectSegmentPort } from "./cache-subject-segment.port";
+
+export class CacheSubjectSegmentQuery implements CacheSubjectSegmentPort {
+  create(context?: Context) {
+    const query = context?.req.query() ?? {};
+
+    const keys = Object.keys(query).toSorted();
+
+    if (keys.length === 0) return "";
+    return keys.map((key) => `${key}=${query[key]}`).join("&");
+  }
+}

package/src/cache-subject-segment-user.ts

@@ -0,0 +1,8 @@
+import type { Context } from "hono";
+import type { CacheSubjectSegmentPort } from "./cache-subject-segment.port";
+
+export class CacheSubjectSegmentUser implements CacheSubjectSegmentPort {
+  create(context?: Context) {
+    return context?.get("user")?.id ?? "anon";
+  }
+}

package/src/cache-subject-segment.port.ts

@@ -0,0 +1,7 @@
+import type { Context } from "hono";
+
+export type CacheSubjectSegmentType = string;
+
+export interface CacheSubjectSegmentPort {
+  create(context?: Context): CacheSubjectSegmentType;
+}

package/src/checksum.service.ts

@@ -1,4 +1,4 @@
-import type { FileHashResult } from "./file-hash.port";
+import type { HashFileResult } from "./hash-file.port";
 
 export enum ChecksumStrategy {
   etag = "etag",
@@ -6,13 +6,13 @@ export enum ChecksumStrategy {
 }
 
 export class Checksum {
-  static compare(first: FileHashResult, second: FileHashResult, strategy: ChecksumStrategy): boolean {
+  static compare(first: HashFileResult, second: HashFileResult, strategy: ChecksumStrategy): boolean {
     switch (strategy) {
       case ChecksumStrategy.etag:
-        return first.etag === second.etag;
+        return first.etag.matches(second.etag);
       case ChecksumStrategy.complex:
         return (
-          first.etag === second.etag &&
+          first.etag.matches(second.etag) &&
           first.size === second.size &&
           first.lastModified &&
           second.lastModified &&

package/src/client.vo.ts

@@ -1,3 +1,6 @@
+import type { Context } from "hono";
+import { getConnInfo } from "hono/bun";
+
 export type ClientIpType = string;
 export type ClientUaType = string;
 export type ClientType = { ip: ClientIpType; ua: ClientUaType };
@@ -5,10 +8,21 @@ export type ClientType = { ip: ClientIpType; ua: ClientUaType };
 export class Client {
   private constructor(private readonly value: ClientType) {}
 
-  static from(ip: ClientIpType | null | undefined, ua: ClientUaType | null | undefined): Client {
+  static fromParts(ip: ClientIpType | null | undefined, ua: ClientUaType | null | undefined): Client {
     return new Client({ ip: ip ?? "anon", ua: ua ?? "anon" });
   }
 
+  static fromHonoContext(context: Context): Client {
+    const info = getConnInfo(context);
+
+    const ip =
+      context.req.header("x-real-ip") || context.req.header("x-forwarded-for") || info?.remote?.address;
+
+    const ua = context.req.header("user-agent");
+
+    return Client.fromParts(ip, ua);
+  }
+
   toJSON(): ClientType {
     return this.value;
   }

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

@@ -1,9 +1,12 @@
 import type { z } from "zod/v4";
 import type { NodeEnvironmentEnum } from "../src/node-env.vo";
 import type { CacheResolverPort } from "./cache-resolver.port";
+import { CacheSubjectResolver } from "./cache-subject-resolver.vo";
+import { CacheSubjectSegmentFixed } from "./cache-subject-segment-fixed";
 import type { EnvironmentLoaderPort } from "./environment-loader.port";
+import type { HashContentPort } from "./hash-content.port";
 
-type Dependencies = { CacheResolver: CacheResolverPort };
+type Dependencies = { CacheResolver: CacheResolverPort; HashContent: HashContentPort };
 
 export class EnvironmentLoaderProcessSafeAdapter<Schema extends z.ZodObject<any>>
   implements EnvironmentLoaderPort<Schema>
@@ -15,7 +18,10 @@ export class EnvironmentLoaderProcessSafeAdapter<Schema extends z.ZodObject<any>
   ) {}
 
   async load() {
-    const result = await this.deps.CacheResolver.resolve("env", async () =>
+    const resolver = new CacheSubjectResolver([new CacheSubjectSegmentFixed("env")], this.deps);
+    const subject = await resolver.resolve();
+
+    const result = await this.deps.CacheResolver.resolve(subject.hex, async () =>
       this.config.Schema.parse(this.env),
     );
 

package/src/hash-content-noop.adapter.ts

@@ -0,0 +1,8 @@
+import { Hash } from "./hash.vo";
+import type { HashContentPort } from "./hash-content.port";
+
+export class HashContentNoopAdapter implements HashContentPort {
+  async hash(_content: string) {
+    return Hash.fromString("0000000000000000000000000000000000000000000000000000000000000000");
+  }
+}

package/src/{content-hash-sha256-bun.adapter.ts → hash-content-sha256-bun.adapter.ts}

@@ -1,10 +1,11 @@
-import type { ContentHashPort } from "./content-hash.port";
+import { Hash } from "./hash.vo";
+import type { HashContentPort } from "./hash-content.port";
 
-export class ContentHashSha256BunAdapter implements ContentHashPort {
+export class HashContentSha256BunAdapter implements HashContentPort {
   async hash(content: string) {
     const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(content));
     const etag = Buffer.from(digest).toString("hex");
 
-    return { etag };
+    return Hash.fromString(etag);
   }
 }

package/src/hash-content.port.ts

@@ -0,0 +1,5 @@
+import type { Hash } from "./hash.vo";
+
+export interface HashContentPort {
+  hash(content: string): Promise<Hash>;
+}

package/src/{file-hash-noop.adapter.ts → hash-file-noop.adapter.ts}

@@ -1,11 +1,11 @@
 import * as tools from "@bgord/tools";
-import { FileEtag } from "./file-etag.vo";
-import type { FileHashPort } from "./file-hash.port";
+import { Hash } from "./hash.vo";
+import type { HashFilePort } from "./hash-file.port";
 
-export class FileHashNoopAdapter implements FileHashPort {
+export class HashFileNoopAdapter implements HashFilePort {
   async hash(_path: tools.FilePathAbsolute | tools.FilePathRelative) {
     return {
-      etag: FileEtag.parse("0000000000000000000000000000000000000000000000000000000000000000"),
+      etag: Hash.fromString("0000000000000000000000000000000000000000000000000000000000000000"),
       size: tools.Size.fromBytes(10),
       lastModified: tools.Timestamp.fromNumber(1000),
       mime: tools.MIMES.text,

package/src/{file-hash-sha256-bun.adapter.ts → hash-file-sha256-bun.adapter.ts}

@@ -1,17 +1,20 @@
 import * as tools from "@bgord/tools";
-import { FileEtag } from "./file-etag.vo";
-import type { FileHashPort } from "./file-hash.port";
+import type { HashContentPort } from "./hash-content.port";
+import type { HashFilePort } from "./hash-file.port";
+
+type Dependencies = { HashContent: HashContentPort };
+
+export class HashFileSha256BunAdapter implements HashFilePort {
+  constructor(private readonly deps: Dependencies) {}
 
-export class FileHashSha256BunAdapter implements FileHashPort {
   async hash(path: tools.FilePathAbsolute | tools.FilePathRelative) {
     const file = Bun.file(path.get());
     const extension = path.getFilename().getExtension();
 
     const arrayBuffer = await file.arrayBuffer();
-    const digest = await crypto.subtle.digest("SHA-256", arrayBuffer);
 
     return {
-      etag: FileEtag.parse(Buffer.from(digest).toString("hex")),
+      etag: await this.deps.HashContent.hash(await file.text()),
       size: tools.Size.fromBytes(arrayBuffer.byteLength),
       lastModified: tools.Timestamp.fromNumber(file.lastModified),
       mime: tools.Mime.fromExtension(extension),

package/src/{file-hash.port.ts → hash-file.port.ts}

@@ -1,13 +1,13 @@
 import type * as tools from "@bgord/tools";
-import type { FileEtagType } from "./file-etag.vo";
+import type { Hash } from "./hash.vo";
 
-export type FileHashResult = {
-  etag: FileEtagType;
+export type HashFileResult = {
+  etag: Hash;
   size: tools.Size;
   lastModified: tools.Timestamp;
   mime: tools.Mime;
 };
 
-export interface FileHashPort {
-  hash(path: tools.FilePathAbsolute | tools.FilePathRelative): Promise<FileHashResult>;
+export interface HashFilePort {
+  hash(path: tools.FilePathAbsolute | tools.FilePathRelative): Promise<HashFileResult>;
 }

package/src/hash-value.vo.ts

@@ -0,0 +1,13 @@
+import { z } from "zod/v4";
+
+export const HashValueError = { Type: "hash.value.type", InvalidHex: "hash.value.invalid.hex" } as const;
+
+// 64 hex chars allowed
+const CHARS_WHITELIST = /^[a-fA-F0-9]{64}$/;
+
+export const HashValue = z
+  .string(HashValueError.Type)
+  .regex(CHARS_WHITELIST, HashValueError.InvalidHex)
+  .brand("HashValue");
+
+export type HashValueType = z.infer<typeof HashValue>;