zeed 1.3.0 → 1.4.0

package/AGENTS.md

@@ -1,233 +1,72 @@
 # AGENTS.md
 
-## Project Overview
+Guidance for coding agents working on the zeed repository. For end-user documentation see [README.md](README.md).
 
-Zeed is a zero-dependency TypeScript utility library designed for universal JavaScript (browsers, Node.js, Deno, and Bun). It provides core utilities for logging, messaging, schema validation, event handling, async operations, and more.
+## Project
 
-**Key characteristics:**
-- Zero runtime dependencies (all integrations are vendored or optional)
-- Strict TypeScript with full type inference
-- Tree-shakable ESM with CommonJS fallback
-- Platform-specific code split between `src/browser/`, `src/node/`, and `src/common/`
+Zero-dependency TypeScript utility library for universal JavaScript (browser, Node, Deno, Bun).
 
-## Commands
-
-### Building and Development
-```bash
-# Build the library (ESM + CJS with minification and types)
-pnpm build
-
-# Type checking without compilation
-pnpm check
-
-# Watch mode for development
-pnpm watch
-```
-
-### Testing
-```bash
-# Run all tests (Node.js + common)
-pnpm test
-
-# Run tests with coverage report
-pnpm coverage
+- Zero runtime dependencies
+- Strict TypeScript, full type inference
+- Tree-shakable ESM with CJS fallback
+- Platform split: `src/browser/`, `src/node/`, `src/common/`
 
-# Run specific test file
-pnpm test <filename>.spec.ts
+## Commands
 
-# Run browser tests in different browsers
-pnpm test:browser      # Chromium with preview
-pnpm test:chromium     # Chromium via playwright
-pnpm test:firefox      # Firefox via playwright
-pnpm test:webkit       # WebKit via playwright
-```
+Package manager: `pnpm` (>= 10). Node >= 20. `nr` is a binary from `@antfu/ni` that runs `package.json` scripts.
 
-### Linting
 ```bash
-# Check for linting issues
-pnpm lint
-
-# Auto-fix linting issues
+pnpm build            # tsdown build (ESM + CJS + types)
+pnpm check            # tsc --noEmit
+pnpm watch            # incremental build
+pnpm test             # type check + vitest run (node + common)
+pnpm coverage         # vitest with coverage
+pnpm vitest run path/to/file.spec.ts   # single test file
+pnpm test:chromium    # browser tests via playwright (also :firefox, :webkit)
+pnpm test:browser     # browser tests with preview UI
+pnpm lint             # eslint
 pnpm lint:fix
+pnpm build:docs       # typedoc -> docs/
 ```
 
-### Documentation
-```bash
-# Generate API documentation (published to https://zeed.holtwick.de/)
-pnpm build:docs
-```
-
-## Architecture
-
-### Module Structure
-
-The codebase is organized into three main areas:
-
-1. **`src/common/`** - Platform-agnostic utilities
-   - Core functionality that works everywhere (browser, Node.js, Deno, Bun)
-   - Includes: schema validation, messaging, data utilities, logging foundation, etc.
-
-2. **`src/browser/`** - Browser-specific utilities
-   - DOM interactions, LocalStorage, browser-specific logging handlers
-   - Example: `log-browser-factory.ts` provides colorful console output for browsers
-
-3. **`src/node/`** - Node.js/Deno/Bun-specific utilities
-   - File system operations, process env handling, Node-specific features
-   - Example: `env.ts` for environment variable management
-
-### Entry Points
-
-The library uses conditional exports for platform-specific builds:
-
-- **`src/index.all.ts`** - Full universal export (browser + node + common)
-- **`src/index.browser.ts`** - Browser-only build (re-exports browser + common)
-- **`src/index.node.ts`** - Node-only build (re-exports node + common)
-- **`src/index.jsr.ts`** - JSR registry specific export
-
-The `package.json` exports field automatically selects the right build:
-```json
-{
-  "exports": {
-    ".": {
-      "types": "./dist/index.all.d.mts",
-      "require": "./dist/index.node.cjs",
-      "node": "./dist/index.node.mjs",
-      "default": "./dist/index.browser.mjs"
-    }
-  }
-}
-```
-
-### Key Subsystems
-
-#### Messaging (`src/common/msg/`)
-
-A layered messaging architecture for cross-context communication. See `src/common/msg/README.md` for full details.
-
-- **Emitter** - Type-safe, async event emitter for in-app communication
-- **Channel** - Uniform `postMessage` abstraction for data transport (WebSocket, WebRTC, WebWorker, etc.)
-- **PubSub** - Event-like messages over a Channel with type safety
-- **Messages** - RPC-like interface with Promise-based responses, timeouts, and retries
-- **Encoder** - Transform data for transport (JSON, encryption, etc.)
-
-Example:
-```typescript
-interface MyMessages {
-  echo: (data: any) => Promise<any>
-}
-
-const hub = useMessageHub({ channel }).send<MyMessages>()
-await hub.echo({ hello: 'world' })
-```
-
-#### Schema Validation (`src/common/schema/`)
-
-Type-safe runtime validation with [Standard Schema](https://github.com/standard-schema/standard-schema) compatibility. Works with tRPC, TanStack Form/Router, Hono, and 40+ other libraries.
-
-- Import via `z` namespace: `import { z } from 'zeed'`
-- All schemas support `.parse()`, `.optional()`, `.default()`, type inference
-- Standard Schema interface available via `schema['~standard']`
-- Supports serialization/deserialization for network transport
-
-Example:
-```typescript
-const userSchema = z.object({
-  name: z.string(),
-  email: z.string(),
-  role: z.stringLiterals(['admin', 'user']),
-})
-
-type User = z.infer<typeof userSchema>
-const user = userSchema.parse(data)
-```
-
-#### Logging (`src/common/log/`, `src/browser/log/`, `src/node/log/`)
-
-Universal logging system with platform-specific handlers:
-
-- **Configuration**: `ZEED=*` or `DEBUG=*` to enable logs (ZEED supersedes DEBUG)
-- **Level filtering**: `ZEED_LEVEL=info` to hide debug logs
-- **Log to file**: `ZEED_LOG=/path/to/file.log`
-- **Handlers**: `LoggerConsoleHandler`, `LoggerBrowserHandler`, `LoggerNodeHandler`, `LoggerFileHandler`
-
-Usage:
-```typescript
-import { Logger } from 'zeed'
-
-const log = Logger('my-module')
-log('message')
-log.info('info')
-log.warn('warning')
-log.error('error')
+## Layout
+
+```text
+src/
+  common/   platform-agnostic (schema, msg, data, log core, ...)
+  browser/  DOM, LocalStorage, browser log handler
+  node/     fs, env, node log handler
+  index.all.ts      universal entry
+  index.browser.ts  browser build
+  index.node.ts     node build
+  index.jsr.ts      JSR registry entry
 ```
 
-#### Data Utilities (`src/common/data/`)
-
-Extensive collection of data manipulation utilities:
-- **Array operations**: `arrayUnique`, `arrayShuffle`, `arrayGroupBy`
-- **String utilities**: `camelCase`, `snakeCase`, `slugify`
-- **Binary encoding**: `useBase(62)` for Base62 encoding/decoding
-- **Object operations**: `deepEqual`, `deepMerge`, `objectFilter`, `objectPluck`
-- **CRDT sorting**: `sortedItems` for conflict-free replicated data
-
-## Development Conventions
-
-### Code Style
-
-- **Indentation**: Always use 2 spaces (not tabs)
-- **TypeScript**: Strict mode enabled, use explicit types where inference isn't clear
-- **Imports**: Use relative imports within the same major module, exported symbols for cross-module
-
-### Testing
-
-- All test files must end with `.spec.ts`
-- Tests live side-by-side with the code they test (e.g., `array.ts` → `array.spec.ts`)
-- Use Vitest with globals enabled (`describe`, `it`, `expect` available globally)
-- Aim for 100% test coverage for new utilities
-- Browser tests require explicit environment: `pnpm test:browser`
+Conditional exports in `package.json` route consumers to the right build. Ignore `_archive/`, `dist/`, `docs/`, `demos/`.
 
-### File Organization
+## Subsystems
 
-- Platform-specific code goes in `src/browser/` or `src/node/`
-- Shared code goes in `src/common/`
-- Each module exports through an `index.ts` barrel file
-- Ignore `_archive/`, `dist/`, `docs/`, and `demos/` folders
+- **`common/schema/`** - Standard Schema compatible runtime validation, exposed as `z`. `z.object`, `z.string`, `z.stringLiterals`, `.parse`, `.optional`, `.default`, `z.infer`. `schema['~standard']` exposes the Standard Schema interface.
+- **`common/msg/`** - Layered messaging: `Emitter` (typed events), `Channel` (postMessage abstraction), `PubSub`, `Messages` (RPC with Promise/timeout/retry), `Encoder`. See `src/common/msg/README.md`.
+- **`common/log/`** + platform handlers - `Logger('name')`, levels `info`/`warn`/`error`. Env: `ZEED=*` or `DEBUG=*` (ZEED wins), `ZEED_LEVEL=info`, `ZEED_LOG=/path/file.log`. Handlers: `LoggerConsoleHandler`, `LoggerBrowserHandler`, `LoggerNodeHandler`, `LoggerFileHandler`.
+- **`common/data/`** - `arrayUnique`, `arrayShuffle`, `arrayGroupBy`, `camelCase`, `snakeCase`, `slugify`, `useBase(62)`, `deepEqual`, `deepMerge`, `objectFilter`, `objectPluck`, `sortedItems` (CRDT).
 
-### Type System Patterns
-
-**Use the `Type` class for runtime validation:**
-```typescript
-// Define schema
-const schema = z.object({ name: z.string() })
-
-// Infer TypeScript type
-type Schema = z.infer<typeof schema>
-
-// Parse/validate at runtime
-const data = schema.parse(input)
-```
-
-**Event emitters should use typed interfaces:**
-```typescript
-interface MyEvents {
-  inc: (count: number) => number
-}
-
-const e = new Emitter<MyEvents>()
-e.on('inc', async count => count + 1)
-```
+## Conventions
 
-## Build System
+- 2-space indent, no tabs.
+- Strict TS. Explicit types only where inference is unclear.
+- Relative imports within a module, barrel imports across modules.
+- Tests live next to code: `array.ts` + `array.spec.ts`. Vitest globals enabled.
+- New utilities: aim for 100% coverage.
+- Browser-only code in `src/browser/`, node-only in `src/node/`, everything else in `src/common/`.
+- Each module has an `index.ts` barrel.
 
-- **Bundler**: tsdown (rolldown-based)
-- **Output**: ESM + CJS in `dist/` with `.mjs` / `.cjs` entry files and TypeScript declarations
-- **Target**: ES2022
-- **Features**: Tree-shaking, minification, source maps, code splitting
+## Build
 
-The build creates multiple entry points and emits matching declaration files such as `dist/index.all.d.mts`, `dist/index.node.d.mts`, and `dist/index.node.d.cts`.
+- Bundler: `tsdown` (rolldown-based). Config in `tsdown.config.ts`.
+- Output: `dist/` with `.mjs`, `.cjs`, and `.d.mts`/`.d.cts` declarations per entry (e.g. `dist/index.all.d.mts`, `dist/index.node.d.cts`).
+- Features: tree-shaking, minification, source maps, code splitting.
 
-## Package Management
+## Release
 
-- Uses `pnpm` (v10.18.0+)
-- Node.js >= 20 required
-- The `nr` alias in scripts refers to `ni run` from `@antfu/ni` package
+`pnpm prep` runs lint-fix, type check, full test suite, and doc upload. `pnpm npm:release` publishes to npm. `pnpm build:docs` generates typedoc into `docs/` (published to <https://zeed.holtwick.de/>).

package/README.md

@@ -24,24 +24,30 @@
 <td width="50%">
 
 ### 🎯 **Type-Safe**
+
 Strict TypeScript with full type inference
 
 ### 📦 **Zero Dependencies**
+
 Lightweight and completely tree-shakable
 
 ### 🌍 **Universal**
+
 Works in browsers, Node.js, Deno, and Bun
 
 </td>
 <td width="50%">
 
 ### ⚡ **Modern ESM**
+
 ES Modules with CommonJS fallback
 
 ### ✅ **Well Tested**
+
 Comprehensive test coverage
 
 ### 🔌 **Standard Schema**
+
 Compatible with tRPC, TanStack, Hono & more
 
 </td>
@@ -93,11 +99,13 @@ log.error('Error')
 By default, logs are muted. Enable them with filters:
 
 **Browser:**
+
 ```ts
 localStorage.zeed = '*'
 ```
 
 **Node.js:**
+
 ```sh
 ZEED=* node myapp.js
 ```
@@ -116,6 +124,7 @@ Write to file: `ZEED_LOG=/path/to/file.log`
 - `LoggerFileHandler(path, opt)` - File output with optional rotation
 
 **Log Rotation Example:**
+
 ```ts
 import { LoggerFileHandler } from 'zeed'
 
@@ -270,6 +279,7 @@ else {
 ```
 
 **Features:**
+
 - Primitives: `string()`, `number()`, `int()`, `boolean()`, `any()`
 - Objects: `object()`, `record()`, `pick()`, `omit()`, `extend()`, `partial()`, `required()`
 - Arrays & Tuples: `array()`, `tuple()`
@@ -289,6 +299,7 @@ else {
 <td width="50%">
 
 **🔄 CRDT Sorting**
+
 ```ts
 interface Row extends SortedItem {
   id: string
@@ -298,6 +309,7 @@ sortedItems(rows)
 ```
 
 **🔐 Binary Encoding**
+
 ```ts
 const { encode, decode } = useBase(62)
 decode(encode(data)) === data
@@ -307,12 +319,14 @@ decode(encode(data)) === data
 <td width="50%">
 
 **🔍 Deep Object Utils**
+
 ```ts
 deepEqual(obj1, obj2)
 deepMerge(obj1, obj2)
 ```
 
 **🧹 Resource Disposal**
+
 ```ts
 const dispose = useDispose()
 dispose.add(cleanup)
@@ -332,10 +346,12 @@ Zeed includes many more utilities - explore the [full API documentation](https:/
 ## 🤝 Related Projects
 
 **By the same author:**
+
 - [zeed-dom](https://github.com/holtwick/zeed-dom) - DOM manipulation utilities
 - [zerva](https://github.com/holtwick/zerva) - Modular server framework
 
 **Similar utility libraries:**
+
 - [lib0](https://github.com/dmonad/lib0) - Fundamental utility functions
 - [antfu/utils](https://github.com/antfu/utils) - Collection of common utilities
 - [vueuse](https://vueuse.org/) - Vue composition utilities

package/dist/_experiments/bitcask.cjs

@@ -1,2 +1,244 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`../chunk-D-qHiVGv.cjs`);let t=require(`fs`);t=e.n(t);let n=require(`path`);n=e.n(n);let r=require(`fs/promises`);var i=class{dirname;readWrite;syncOnPut;keydir=new Map;activeFile=null;activeFileId=0;activeOffset=0;openFiles=new Map;constructor(e,n={}){this.dirname=e,this.readWrite=n.readWrite!==!1,this.syncOnPut=n.syncOnPut===!0,t.existsSync(e)||t.mkdirSync(e,{recursive:!0}),this.loadFiles(),this.readWrite&&this.rollover()}listDataFiles(){return t.readdirSync(this.dirname).filter(e=>e.endsWith(`.data`)).sort()}loadFiles(){for(let e of this.listDataFiles()){let r=parseInt(e.split(`.`)[0],10),i=n.join(this.dirname,e),a=t.openSync(i,`r`),o=0;for(;;){let e=Buffer.alloc(17);if(t.readSync(a,e,0,17,o)<17)break;let n=e.readUInt32BE(0),i=e.readUInt32BE(4),s=e.readUInt8(8)===1,c=e.readBigUInt64BE(9),l=Buffer.alloc(n);t.readSync(a,l,0,n,o+17);let u=17+n+i;this.keydir.set(l.toString(`binary`),{fileId:r,offset:o,size:u,timestamp:c,tombstone:s}),o+=u}t.closeSync(a)}}rollover(){let e=this.listDataFiles().map(e=>parseInt(e.split(`.`)[0],10)),r=e.length?Math.max(...e)+1:1,i=`${r.toString().padStart(8,`0`)}.data`,a=n.join(this.dirname,i);this.activeFile=t.createWriteStream(a,{flags:`a`}),this.activeFileId=r,this.activeOffset=t.existsSync(a)?t.statSync(a).size:0}async put(e,n){if(!this.readWrite)throw Error(`Read-only mode`);let r=Buffer.isBuffer(e)?e:Buffer.from(e),i=Buffer.isBuffer(n)?n:Buffer.from(n),a=BigInt(Date.now()),o=Buffer.alloc(17);o.writeUInt32BE(r.length,0),o.writeUInt32BE(i.length,4),o.writeUInt8(0,8),o.writeBigUInt64BE(a,9);let s=Buffer.concat([o,r,i]),c=this.activeOffset;await new Promise((e,t)=>{this.activeFile.write(s,n=>n?t(n):e())}),this.syncOnPut&&this.activeFile&&t.fsyncSync(this.activeFile.fd),this.keydir.set(r.toString(`binary`),{fileId:this.activeFileId,offset:c,size:s.length,timestamp:a,tombstone:!1}),this.activeOffset+=s.length,this.activeOffset>32*1024*1024&&(this.activeFile.close(),this.rollover())}async get(e){let t=Buffer.isBuffer(e)?e:Buffer.from(e),i=this.keydir.get(t.toString(`binary`));if(!i||i.tombstone)return null;let a=this.openFiles.get(i.fileId);a||(a=await(0,r.open)(n.join(this.dirname,`${i.fileId.toString().padStart(8,`0`)}.data`),`r`),this.openFiles.set(i.fileId,a));let o=Buffer.alloc(17);await a.read(o,0,17,i.offset);let s=o.readUInt32BE(0),c=o.readUInt32BE(4),l=Buffer.alloc(s);await a.read(l,0,s,i.offset+17);let u=Buffer.alloc(c);return await a.read(u,0,c,i.offset+17+s),u}async delete(e){if(!this.readWrite)throw Error(`Read-only mode`);let n=Buffer.isBuffer(e)?e:Buffer.from(e),r=BigInt(Date.now()),i=Buffer.alloc(17);i.writeUInt32BE(n.length,0),i.writeUInt32BE(0,4),i.writeUInt8(1,8),i.writeBigUInt64BE(r,9);let a=Buffer.concat([i,n]),o=this.activeOffset;await new Promise((e,t)=>{this.activeFile.write(a,n=>n?t(n):e())}),this.syncOnPut&&this.activeFile&&t.fsyncSync(this.activeFile.fd),this.keydir.set(n.toString(`binary`),{fileId:this.activeFileId,offset:o,size:a.length,timestamp:r,tombstone:!0}),this.activeOffset+=a.length,this.activeOffset>32*1024*1024&&(this.activeFile.close(),this.rollover())}listKeys(){return Array.from(this.keydir.entries()).filter(([e,t])=>!t.tombstone).map(([e,t])=>e)}async fold(e,t){for(let[n,r]of this.keydir.entries())r.tombstone||(t=e(n,await this.get(n),t));return t}async merge(){let e=new Map;for(let[t,n]of this.keydir.entries())n.tombstone||e.set(t,n);let r=this.listDataFiles().map(e=>parseInt(e.split(`.`)[0],10)),i=r.length?Math.max(...r)+1:1,a=`${i.toString().padStart(8,`0`)}.data`,o=n.join(this.dirname,a),s=t.createWriteStream(o,{flags:`a`});for(let[t,n]of e.entries()){let e=await this.get(t),r=Buffer.from(t,`binary`),i=Buffer.alloc(17);i.writeUInt32BE(r.length,0),i.writeUInt32BE(e.length,4),i.writeUInt8(0,8),i.writeBigUInt64BE(n.timestamp,9);let a=Buffer.concat([i,r,e]);await new Promise((e,t)=>{s.write(a,n=>n?t(n):e())})}s.close();for(let e of r)if(e!==this.activeFileId&&e!==i)try{t.unlinkSync(n.join(this.dirname,`${e.toString().padStart(8,`0`)}.data`))}catch{}this.loadFiles()}sync(){this.activeFile&&t.fsyncSync(this.activeFile.fd)}async close(){this.activeFile&&this.activeFile.end();for(let e of this.openFiles.values())await e.close();this.openFiles.clear()}};function a(e,t){return new i(e,t)}async function o(e,t){let n=await e.get(t);return n===null?`not found`:n}async function s(e,t,n){return await e.put(t,n),`ok`}async function c(e,t){return await e.delete(t),`ok`}function l(e){return e.listKeys()}async function u(e,t,n){return await e.fold(t,n)}async function d(e){let t=new i(e,{readWrite:!0});return await t.merge(),t.close(),`ok`}function f(e){return e.sync(),`ok`}async function p(e){return await e.close(),`ok`}exports.Bitcask=i,exports.close=p,exports.del=c,exports.fold=u,exports.get=o,exports.listKeys=l,exports.merge=d,exports.open=a,exports.put=s,exports.sync=f;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-uaV2rQ02.cjs');
+let fs = require("fs");
+fs = require_chunk.__toESM(fs, 1);
+let path = require("path");
+path = require_chunk.__toESM(path, 1);
+let fs_promises = require("fs/promises");
+
+//#region src/_experiments/bitcask.ts
+const ENTRY_HEADER_SIZE = 17;
+var Bitcask = class {
+	dirname;
+	readWrite;
+	syncOnPut;
+	keydir = /* @__PURE__ */ new Map();
+	activeFile = null;
+	activeFileId = 0;
+	activeOffset = 0;
+	openFiles = /* @__PURE__ */ new Map();
+	constructor(dirname, opts = {}) {
+		this.dirname = dirname;
+		this.readWrite = opts.readWrite !== false;
+		this.syncOnPut = opts.syncOnPut === true;
+		if (!fs.existsSync(dirname)) fs.mkdirSync(dirname, { recursive: true });
+		this.loadFiles();
+		if (this.readWrite) this.rollover();
+	}
+	listDataFiles() {
+		return fs.readdirSync(this.dirname).filter((f) => f.endsWith(".data")).sort();
+	}
+	loadFiles() {
+		for (const fname of this.listDataFiles()) {
+			const fileId = parseInt(fname.split(".")[0], 10);
+			const filePath = path.join(this.dirname, fname);
+			const fd = fs.openSync(filePath, "r");
+			let offset = 0;
+			while (true) {
+				const header = Buffer.alloc(ENTRY_HEADER_SIZE);
+				if (fs.readSync(fd, header, 0, ENTRY_HEADER_SIZE, offset) < ENTRY_HEADER_SIZE) break;
+				const keySize = header.readUInt32BE(0);
+				const valueSize = header.readUInt32BE(4);
+				const tombstone = header.readUInt8(8) === 1;
+				const timestamp = header.readBigUInt64BE(9);
+				const key = Buffer.alloc(keySize);
+				fs.readSync(fd, key, 0, keySize, offset + ENTRY_HEADER_SIZE);
+				const entrySize = ENTRY_HEADER_SIZE + keySize + valueSize;
+				this.keydir.set(key.toString("binary"), {
+					fileId,
+					offset,
+					size: entrySize,
+					timestamp,
+					tombstone
+				});
+				offset += entrySize;
+			}
+			fs.closeSync(fd);
+		}
+	}
+	rollover() {
+		const fileIds = this.listDataFiles().map((f) => parseInt(f.split(".")[0], 10));
+		const nextId = fileIds.length ? Math.max(...fileIds) + 1 : 1;
+		const fname = `${nextId.toString().padStart(8, "0")}.data`;
+		const filePath = path.join(this.dirname, fname);
+		this.activeFile = fs.createWriteStream(filePath, { flags: "a" });
+		this.activeFileId = nextId;
+		this.activeOffset = fs.existsSync(filePath) ? fs.statSync(filePath).size : 0;
+	}
+	async put(key, value) {
+		if (!this.readWrite) throw new Error("Read-only mode");
+		const keyBuf = Buffer.isBuffer(key) ? key : Buffer.from(key);
+		const valueBuf = Buffer.isBuffer(value) ? value : Buffer.from(value);
+		const timestamp = BigInt(Date.now());
+		const tombstone = 0;
+		const header = Buffer.alloc(ENTRY_HEADER_SIZE);
+		header.writeUInt32BE(keyBuf.length, 0);
+		header.writeUInt32BE(valueBuf.length, 4);
+		header.writeUInt8(tombstone, 8);
+		header.writeBigUInt64BE(timestamp, 9);
+		const entry = Buffer.concat([
+			header,
+			keyBuf,
+			valueBuf
+		]);
+		const offset = this.activeOffset;
+		await new Promise((resolve, reject) => {
+			this.activeFile.write(entry, (err) => err ? reject(err) : resolve());
+		});
+		if (this.syncOnPut && this.activeFile) fs.fsyncSync(this.activeFile.fd);
+		this.keydir.set(keyBuf.toString("binary"), {
+			fileId: this.activeFileId,
+			offset,
+			size: entry.length,
+			timestamp,
+			tombstone: false
+		});
+		this.activeOffset += entry.length;
+		if (this.activeOffset > 32 * 1024 * 1024) {
+			this.activeFile.close();
+			this.rollover();
+		}
+	}
+	async get(key) {
+		const keyBuf = Buffer.isBuffer(key) ? key : Buffer.from(key);
+		const meta = this.keydir.get(keyBuf.toString("binary"));
+		if (!meta || meta.tombstone) return null;
+		let fh = this.openFiles.get(meta.fileId);
+		if (!fh) {
+			fh = await (0, fs_promises.open)(path.join(this.dirname, `${meta.fileId.toString().padStart(8, "0")}.data`), "r");
+			this.openFiles.set(meta.fileId, fh);
+		}
+		const header = Buffer.alloc(ENTRY_HEADER_SIZE);
+		await fh.read(header, 0, ENTRY_HEADER_SIZE, meta.offset);
+		const keySize = header.readUInt32BE(0);
+		const valueSize = header.readUInt32BE(4);
+		const keyRead = Buffer.alloc(keySize);
+		await fh.read(keyRead, 0, keySize, meta.offset + ENTRY_HEADER_SIZE);
+		const value = Buffer.alloc(valueSize);
+		await fh.read(value, 0, valueSize, meta.offset + ENTRY_HEADER_SIZE + keySize);
+		return value;
+	}
+	async delete(key) {
+		if (!this.readWrite) throw new Error("Read-only mode");
+		const keyBuf = Buffer.isBuffer(key) ? key : Buffer.from(key);
+		const timestamp = BigInt(Date.now());
+		const tombstone = 1;
+		const header = Buffer.alloc(ENTRY_HEADER_SIZE);
+		header.writeUInt32BE(keyBuf.length, 0);
+		header.writeUInt32BE(0, 4);
+		header.writeUInt8(tombstone, 8);
+		header.writeBigUInt64BE(timestamp, 9);
+		const entry = Buffer.concat([header, keyBuf]);
+		const offset = this.activeOffset;
+		await new Promise((resolve, reject) => {
+			this.activeFile.write(entry, (err) => err ? reject(err) : resolve());
+		});
+		if (this.syncOnPut && this.activeFile) fs.fsyncSync(this.activeFile.fd);
+		this.keydir.set(keyBuf.toString("binary"), {
+			fileId: this.activeFileId,
+			offset,
+			size: entry.length,
+			timestamp,
+			tombstone: true
+		});
+		this.activeOffset += entry.length;
+		if (this.activeOffset > 32 * 1024 * 1024) {
+			this.activeFile.close();
+			this.rollover();
+		}
+	}
+	listKeys() {
+		return Array.from(this.keydir.entries()).filter(([_, v]) => !v.tombstone).map(([k, _]) => k);
+	}
+	async fold(fn, acc0) {
+		for (const [k, meta] of this.keydir.entries()) if (!meta.tombstone) acc0 = fn(k, await this.get(k), acc0);
+		return acc0;
+	}
+	async merge() {
+		const live = /* @__PURE__ */ new Map();
+		for (const [k, meta] of this.keydir.entries()) if (!meta.tombstone) live.set(k, meta);
+		const fileIds = this.listDataFiles().map((f) => parseInt(f.split(".")[0], 10));
+		const nextId = fileIds.length ? Math.max(...fileIds) + 1 : 1;
+		const fname = `${nextId.toString().padStart(8, "0")}.data`;
+		const filePath = path.join(this.dirname, fname);
+		const f = fs.createWriteStream(filePath, { flags: "a" });
+		for (const [k, meta] of live.entries()) {
+			const v = await this.get(k);
+			const keyBuf = Buffer.from(k, "binary");
+			const header = Buffer.alloc(ENTRY_HEADER_SIZE);
+			header.writeUInt32BE(keyBuf.length, 0);
+			header.writeUInt32BE(v.length, 4);
+			header.writeUInt8(0, 8);
+			header.writeBigUInt64BE(meta.timestamp, 9);
+			const entry = Buffer.concat([
+				header,
+				keyBuf,
+				v
+			]);
+			await new Promise((resolve, reject) => {
+				f.write(entry, (err) => err ? reject(err) : resolve());
+			});
+		}
+		f.close();
+		for (const fid of fileIds) if (fid !== this.activeFileId && fid !== nextId) try {
+			fs.unlinkSync(path.join(this.dirname, `${fid.toString().padStart(8, "0")}.data`));
+		} catch {}
+		this.loadFiles();
+	}
+	sync() {
+		if (this.activeFile) fs.fsyncSync(this.activeFile.fd);
+	}
+	async close() {
+		if (this.activeFile) this.activeFile.end();
+		for (const fh of this.openFiles.values()) await fh.close();
+		this.openFiles.clear();
+	}
+};
+function open(dirname, opts) {
+	return new Bitcask(dirname, opts);
+}
+async function get(handle, key) {
+	const v = await handle.get(key);
+	return v === null ? "not found" : v;
+}
+async function put(handle, key, value) {
+	await handle.put(key, value);
+	return "ok";
+}
+async function del(handle, key) {
+	await handle.delete(key);
+	return "ok";
+}
+function listKeys(handle) {
+	return handle.listKeys();
+}
+async function fold(handle, fn, acc0) {
+	return await handle.fold(fn, acc0);
+}
+async function merge(dirname) {
+	const h = new Bitcask(dirname, { readWrite: true });
+	await h.merge();
+	h.close();
+	return "ok";
+}
+function sync(handle) {
+	handle.sync();
+	return "ok";
+}
+async function close(handle) {
+	await handle.close();
+	return "ok";
+}
+
+//#endregion
+exports.Bitcask = Bitcask;
+exports.close = close;
+exports.del = del;
+exports.fold = fold;
+exports.get = get;
+exports.listKeys = listKeys;
+exports.merge = merge;
+exports.open = open;
+exports.put = put;
+exports.sync = sync;
 //# sourceMappingURL=bitcask.cjs.map