@zenbujs/core 0.0.1

package/dist/write-9dRFczGJ.mjs

@@ -0,0 +1,1248 @@
+import { n as traceKyjuSync, t as traceKyju } from "./trace-DCB7qFzT.mjs";
+import * as NFS from "node:fs";
+import * as OS from "node:os";
+import * as Path from "node:path";
+import path from "node:path";
+import * as Crypto from "node:crypto";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+import * as Brand from "effect/Brand";
+import * as Context from "effect/Context";
+import { GenericTag } from "effect/Context";
+import * as Data from "effect/Data";
+import * as Channel from "effect/Channel";
+import * as Chunk from "effect/Chunk";
+import { identity, pipe } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+import "effect/Predicate";
+import * as Schema from "effect/Schema";
+import { nanoid } from "nanoid";
+//#region ../../node_modules/.pnpm/@effect+platform@0.94.5_effect@3.21.1/node_modules/@effect/platform/dist/esm/Error.js
+/**
+* @since 1.0.0
+* @category type id
+*/
+const TypeId = /* @__PURE__ */ Symbol.for("@effect/platform/Error");
+/**
+* @since 1.0.0
+* @category Models
+*/
+const Module = /* @__PURE__ */ Schema.Literal("Clipboard", "Command", "FileSystem", "KeyValueStore", "Path", "Stream", "Terminal");
+/**
+* @since 1.0.0
+* @category Models
+*/
+var BadArgument = class extends Schema.TaggedError("@effect/platform/Error/BadArgument")("BadArgument", {
+	module: Module,
+	method: Schema.String,
+	description: /* @__PURE__ */ Schema.optional(Schema.String),
+	cause: /* @__PURE__ */ Schema.optional(Schema.Defect)
+}) {
+	/**
+	* @since 1.0.0
+	*/
+	[TypeId] = TypeId;
+	/**
+	* @since 1.0.0
+	*/
+	get message() {
+		return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`;
+	}
+};
+/**
+* @since 1.0.0
+* @category Model
+*/
+const SystemErrorReason = /* @__PURE__ */ Schema.Literal("AlreadyExists", "BadResource", "Busy", "InvalidData", "NotFound", "PermissionDenied", "TimedOut", "UnexpectedEof", "Unknown", "WouldBlock", "WriteZero");
+/**
+* @since 1.0.0
+* @category models
+*/
+var SystemError = class extends Schema.TaggedError("@effect/platform/Error/SystemError")("SystemError", {
+	reason: SystemErrorReason,
+	module: Module,
+	method: Schema.String,
+	description: /* @__PURE__ */ Schema.optional(Schema.String),
+	syscall: /* @__PURE__ */ Schema.optional(Schema.String),
+	pathOrDescriptor: /* @__PURE__ */ Schema.optional(/* @__PURE__ */ Schema.Union(Schema.String, Schema.Number)),
+	cause: /* @__PURE__ */ Schema.optional(Schema.Defect)
+}) {
+	/**
+	* @since 1.0.0
+	*/
+	[TypeId] = TypeId;
+	/**
+	* @since 1.0.0
+	*/
+	get message() {
+		return `${this.reason}: ${this.module}.${this.method}${this.pathOrDescriptor !== void 0 ? ` (${this.pathOrDescriptor})` : ""}${this.description ? `: ${this.description}` : ""}`;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform@0.94.5_effect@3.21.1/node_modules/@effect/platform/dist/esm/internal/fileSystem.js
+/** @internal */
+const tag = /* @__PURE__ */ GenericTag("@effect/platform/FileSystem");
+/** @internal */
+const Size$1 = (bytes) => typeof bytes === "bigint" ? bytes : BigInt(bytes);
+const bigint1024 = /* @__PURE__ */ BigInt(1024);
+bigint1024 * bigint1024 * bigint1024 * bigint1024 * bigint1024;
+/** @internal */
+const make$1 = (impl) => {
+	return tag.of({
+		...impl,
+		exists: (path) => pipe(impl.access(path), Effect.as(true), Effect.catchTag("SystemError", (e) => e.reason === "NotFound" ? Effect.succeed(false) : Effect.fail(e))),
+		readFileString: (path, encoding) => Effect.tryMap(impl.readFile(path), {
+			try: (_) => new TextDecoder(encoding).decode(_),
+			catch: (cause) => new BadArgument({
+				module: "FileSystem",
+				method: "readFileString",
+				description: "invalid encoding",
+				cause
+			})
+		}),
+		stream: (path, options) => pipe(impl.open(path, { flag: "r" }), options?.offset ? Effect.tap((file) => file.seek(options.offset, "start")) : identity, Effect.map((file) => stream(file, options)), Stream.unwrapScoped),
+		sink: (path, options) => pipe(impl.open(path, {
+			flag: "w",
+			...options
+		}), Effect.map((file) => Sink.forEach((_) => file.writeAll(_))), Sink.unwrapScoped),
+		writeFileString: (path, data, options) => Effect.flatMap(Effect.try({
+			try: () => new TextEncoder().encode(data),
+			catch: (cause) => new BadArgument({
+				module: "FileSystem",
+				method: "writeFileString",
+				description: "could not encode string",
+				cause
+			})
+		}), (_) => impl.writeFile(path, _, options))
+	});
+};
+/** @internal */
+const stream = (file, { bufferSize = 16, bytesToRead: bytesToRead_, chunkSize: chunkSize_ = Size$1(64 * 1024) } = {}) => {
+	const bytesToRead = bytesToRead_ !== void 0 ? Size$1(bytesToRead_) : void 0;
+	const chunkSize = Size$1(chunkSize_);
+	function loop(totalBytesRead) {
+		if (bytesToRead !== void 0 && bytesToRead <= totalBytesRead) return Channel.void;
+		const toRead = bytesToRead !== void 0 && bytesToRead - totalBytesRead < chunkSize ? bytesToRead - totalBytesRead : chunkSize;
+		return Channel.flatMap(file.readAlloc(toRead), Option.match({
+			onNone: () => Channel.void,
+			onSome: (buf) => Channel.flatMap(Channel.write(Chunk.of(buf)), (_) => loop(totalBytesRead + BigInt(buf.length)))
+		}));
+	}
+	return Stream.bufferChunks(Stream.fromChannel(loop(BigInt(0))), { capacity: bufferSize });
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform@0.94.5_effect@3.21.1/node_modules/@effect/platform/dist/esm/FileSystem.js
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category sizes
+*/
+const Size = Size$1;
+/**
+* @since 1.0.0
+* @category tag
+*/
+const FileSystem = tag;
+/**
+* @since 1.0.0
+* @category constructor
+*/
+const make = make$1;
+/**
+* @since 1.0.0
+* @category type id
+*/
+const FileTypeId = /* @__PURE__ */ Symbol.for("@effect/platform/FileSystem/File");
+/**
+* @since 1.0.0
+* @category constructor
+*/
+const FileDescriptor = /* @__PURE__ */ Brand.nominal();
+/**
+* @since 1.0.0
+* @category constructor
+*/
+const WatchEventCreate = /* @__PURE__ */ Data.tagged("Create");
+/**
+* @since 1.0.0
+* @category constructor
+*/
+const WatchEventUpdate = /* @__PURE__ */ Data.tagged("Update");
+/**
+* @since 1.0.0
+* @category constructor
+*/
+const WatchEventRemove = /* @__PURE__ */ Data.tagged("Remove");
+/**
+* @since 1.0.0
+* @category file watcher
+*/
+var WatchBackend = class extends Context.Tag("@effect/platform/FileSystem/WatchBackend")() {};
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform@0.94.5_effect@3.21.1/node_modules/@effect/platform/dist/esm/internal/effectify.js
+/** @internal */
+const effectify$1 = (fn, onError, onSyncError) => (...args) => Effect.async((resume) => {
+	try {
+		fn(...args, (err, result) => {
+			if (err) resume(Effect.fail(onError ? onError(err, args) : err));
+			else resume(Effect.succeed(result));
+		});
+	} catch (err) {
+		resume(onSyncError ? Effect.fail(onSyncError(err, args)) : Effect.die(err));
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform@0.94.5_effect@3.21.1/node_modules/@effect/platform/dist/esm/Effectify.js
+/**
+* @since 1.0.0
+*/
+const effectify = effectify$1;
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node-shared@0.57.1_@effect+cluster@0.56.4_@effect+platform@0.94.5_effe_8874b4c5b98109adb0b32dd122fa88a9/node_modules/@effect/platform-node-shared/dist/esm/internal/error.js
+/** @internal */
+const handleErrnoException = (module, method) => (err, [path]) => {
+	let reason = "Unknown";
+	switch (err.code) {
+		case "ENOENT":
+			reason = "NotFound";
+			break;
+		case "EACCES":
+			reason = "PermissionDenied";
+			break;
+		case "EEXIST":
+			reason = "AlreadyExists";
+			break;
+		case "EISDIR":
+			reason = "BadResource";
+			break;
+		case "ENOTDIR":
+			reason = "BadResource";
+			break;
+		case "EBUSY":
+			reason = "Busy";
+			break;
+		case "ELOOP":
+			reason = "BadResource";
+			break;
+	}
+	return new SystemError({
+		reason,
+		module,
+		method,
+		pathOrDescriptor: path,
+		syscall: err.syscall,
+		description: err.message,
+		cause: err
+	});
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node-shared@0.57.1_@effect+cluster@0.56.4_@effect+platform@0.94.5_effe_8874b4c5b98109adb0b32dd122fa88a9/node_modules/@effect/platform-node-shared/dist/esm/internal/fileSystem.js
+const handleBadArgument = (method) => (cause) => new BadArgument({
+	module: "FileSystem",
+	method,
+	cause
+});
+const access = /* @__PURE__ */ (() => {
+	const nodeAccess = /* @__PURE__ */ effectify(NFS.access, /* @__PURE__ */ handleErrnoException("FileSystem", "access"), /* @__PURE__ */ handleBadArgument("access"));
+	return (path, options) => {
+		let mode = NFS.constants.F_OK;
+		if (options?.readable) mode |= NFS.constants.R_OK;
+		if (options?.writable) mode |= NFS.constants.W_OK;
+		return nodeAccess(path, mode);
+	};
+})();
+const copy = /* @__PURE__ */ (() => {
+	const nodeCp = /* @__PURE__ */ effectify(NFS.cp, /* @__PURE__ */ handleErrnoException("FileSystem", "copy"), /* @__PURE__ */ handleBadArgument("copy"));
+	return (fromPath, toPath, options) => nodeCp(fromPath, toPath, {
+		force: options?.overwrite ?? false,
+		preserveTimestamps: options?.preserveTimestamps ?? false,
+		recursive: true
+	});
+})();
+const copyFile = /* @__PURE__ */ (() => {
+	const nodeCopyFile = /* @__PURE__ */ effectify(NFS.copyFile, /* @__PURE__ */ handleErrnoException("FileSystem", "copyFile"), /* @__PURE__ */ handleBadArgument("copyFile"));
+	return (fromPath, toPath) => nodeCopyFile(fromPath, toPath);
+})();
+const chmod = /* @__PURE__ */ (() => {
+	const nodeChmod = /* @__PURE__ */ effectify(NFS.chmod, /* @__PURE__ */ handleErrnoException("FileSystem", "chmod"), /* @__PURE__ */ handleBadArgument("chmod"));
+	return (path, mode) => nodeChmod(path, mode);
+})();
+const chown = /* @__PURE__ */ (() => {
+	const nodeChown = /* @__PURE__ */ effectify(NFS.chown, /* @__PURE__ */ handleErrnoException("FileSystem", "chown"), /* @__PURE__ */ handleBadArgument("chown"));
+	return (path, uid, gid) => nodeChown(path, uid, gid);
+})();
+const link = /* @__PURE__ */ (() => {
+	const nodeLink = /* @__PURE__ */ effectify(NFS.link, /* @__PURE__ */ handleErrnoException("FileSystem", "link"), /* @__PURE__ */ handleBadArgument("link"));
+	return (existingPath, newPath) => nodeLink(existingPath, newPath);
+})();
+const makeDirectory = /* @__PURE__ */ (() => {
+	const nodeMkdir = /* @__PURE__ */ effectify(NFS.mkdir, /* @__PURE__ */ handleErrnoException("FileSystem", "makeDirectory"), /* @__PURE__ */ handleBadArgument("makeDirectory"));
+	return (path, options) => nodeMkdir(path, {
+		recursive: options?.recursive ?? false,
+		mode: options?.mode
+	});
+})();
+const makeTempDirectoryFactory = (method) => {
+	const nodeMkdtemp = effectify(NFS.mkdtemp, handleErrnoException("FileSystem", method), handleBadArgument(method));
+	return (options) => Effect.suspend(() => {
+		const prefix = options?.prefix ?? "";
+		const directory = typeof options?.directory === "string" ? Path.join(options.directory, ".") : OS.tmpdir();
+		return nodeMkdtemp(prefix ? Path.join(directory, prefix) : directory + "/");
+	});
+};
+const makeTempDirectory = /* @__PURE__ */ makeTempDirectoryFactory("makeTempDirectory");
+const removeFactory = (method) => {
+	const nodeRm = effectify(NFS.rm, handleErrnoException("FileSystem", method), handleBadArgument(method));
+	return (path, options) => nodeRm(path, {
+		recursive: options?.recursive ?? false,
+		force: options?.force ?? false
+	});
+};
+const remove = /* @__PURE__ */ removeFactory("remove");
+const makeTempDirectoryScoped = /* @__PURE__ */ (() => {
+	const makeDirectory = /* @__PURE__ */ makeTempDirectoryFactory("makeTempDirectoryScoped");
+	const removeDirectory = /* @__PURE__ */ removeFactory("makeTempDirectoryScoped");
+	return (options) => Effect.acquireRelease(makeDirectory(options), (directory) => Effect.orDie(removeDirectory(directory, { recursive: true })));
+})();
+const openFactory = (method) => {
+	const nodeOpen = effectify(NFS.open, handleErrnoException("FileSystem", method), handleBadArgument(method));
+	const nodeClose = effectify(NFS.close, handleErrnoException("FileSystem", method), handleBadArgument(method));
+	return (path, options) => pipe(Effect.acquireRelease(nodeOpen(path, options?.flag ?? "r", options?.mode), (fd) => Effect.orDie(nodeClose(fd))), Effect.map((fd) => makeFile(FileDescriptor(fd), options?.flag?.startsWith("a") ?? false)));
+};
+const open = /* @__PURE__ */ openFactory("open");
+const makeFile = /* @__PURE__ */ (() => {
+	const nodeReadFactory = (method) => effectify(NFS.read, handleErrnoException("FileSystem", method), handleBadArgument(method));
+	const nodeRead = /* @__PURE__ */ nodeReadFactory("read");
+	const nodeReadAlloc = /* @__PURE__ */ nodeReadFactory("readAlloc");
+	const nodeStat = /* @__PURE__ */ effectify(NFS.fstat, /* @__PURE__ */ handleErrnoException("FileSystem", "stat"), /* @__PURE__ */ handleBadArgument("stat"));
+	const nodeTruncate = /* @__PURE__ */ effectify(NFS.ftruncate, /* @__PURE__ */ handleErrnoException("FileSystem", "truncate"), /* @__PURE__ */ handleBadArgument("truncate"));
+	const nodeSync = /* @__PURE__ */ effectify(NFS.fsync, /* @__PURE__ */ handleErrnoException("FileSystem", "sync"), /* @__PURE__ */ handleBadArgument("sync"));
+	const nodeWriteFactory = (method) => effectify(NFS.write, handleErrnoException("FileSystem", method), handleBadArgument(method));
+	const nodeWrite = /* @__PURE__ */ nodeWriteFactory("write");
+	const nodeWriteAll = /* @__PURE__ */ nodeWriteFactory("writeAll");
+	class FileImpl {
+		fd;
+		append;
+		[FileTypeId];
+		semaphore = /* @__PURE__ */ Effect.unsafeMakeSemaphore(1);
+		position = 0n;
+		constructor(fd, append) {
+			this.fd = fd;
+			this.append = append;
+			this[FileTypeId] = FileTypeId;
+		}
+		get stat() {
+			return Effect.map(nodeStat(this.fd), makeFileInfo);
+		}
+		get sync() {
+			return nodeSync(this.fd);
+		}
+		seek(offset, from) {
+			const offsetSize = Size(offset);
+			return this.semaphore.withPermits(1)(Effect.sync(() => {
+				if (from === "start") this.position = offsetSize;
+				else if (from === "current") this.position = this.position + offsetSize;
+				return this.position;
+			}));
+		}
+		read(buffer) {
+			return this.semaphore.withPermits(1)(Effect.map(Effect.suspend(() => nodeRead(this.fd, {
+				buffer,
+				position: this.position
+			})), (bytesRead) => {
+				const sizeRead = Size(bytesRead);
+				this.position = this.position + sizeRead;
+				return sizeRead;
+			}));
+		}
+		readAlloc(size) {
+			const sizeNumber = Number(size);
+			return this.semaphore.withPermits(1)(Effect.flatMap(Effect.sync(() => Buffer.allocUnsafeSlow(sizeNumber)), (buffer) => Effect.map(nodeReadAlloc(this.fd, {
+				buffer,
+				position: this.position
+			}), (bytesRead) => {
+				if (bytesRead === 0) return Option.none();
+				this.position = this.position + BigInt(bytesRead);
+				if (bytesRead === sizeNumber) return Option.some(buffer);
+				const dst = Buffer.allocUnsafeSlow(bytesRead);
+				buffer.copy(dst, 0, 0, bytesRead);
+				return Option.some(dst);
+			})));
+		}
+		truncate(length) {
+			return this.semaphore.withPermits(1)(Effect.map(nodeTruncate(this.fd, length ? Number(length) : void 0), () => {
+				if (!this.append) {
+					const len = BigInt(length ?? 0);
+					if (this.position > len) this.position = len;
+				}
+			}));
+		}
+		write(buffer) {
+			return this.semaphore.withPermits(1)(Effect.map(Effect.suspend(() => nodeWrite(this.fd, buffer, void 0, void 0, this.append ? void 0 : Number(this.position))), (bytesWritten) => {
+				const sizeWritten = Size(bytesWritten);
+				if (!this.append) this.position = this.position + sizeWritten;
+				return sizeWritten;
+			}));
+		}
+		writeAllChunk(buffer) {
+			return Effect.flatMap(Effect.suspend(() => nodeWriteAll(this.fd, buffer, void 0, void 0, this.append ? void 0 : Number(this.position))), (bytesWritten) => {
+				if (bytesWritten === 0) return Effect.fail(new SystemError({
+					module: "FileSystem",
+					method: "writeAll",
+					reason: "WriteZero",
+					pathOrDescriptor: this.fd,
+					description: "write returned 0 bytes written"
+				}));
+				if (!this.append) this.position = this.position + BigInt(bytesWritten);
+				return bytesWritten < buffer.length ? this.writeAllChunk(buffer.subarray(bytesWritten)) : Effect.void;
+			});
+		}
+		writeAll(buffer) {
+			return this.semaphore.withPermits(1)(this.writeAllChunk(buffer));
+		}
+	}
+	return (fd, append) => new FileImpl(fd, append);
+})();
+const makeTempFileFactory = (method) => {
+	const makeDirectory = makeTempDirectoryFactory(method);
+	const open = openFactory(method);
+	const randomHexString = (bytes) => Effect.sync(() => Crypto.randomBytes(bytes).toString("hex"));
+	return (options) => pipe(Effect.zip(makeDirectory(options), randomHexString(6)), Effect.map(([directory, random]) => Path.join(directory, random + (options?.suffix ?? ""))), Effect.tap((path) => Effect.scoped(open(path, { flag: "w+" }))));
+};
+const makeTempFile = /* @__PURE__ */ makeTempFileFactory("makeTempFile");
+const makeTempFileScoped = /* @__PURE__ */ (() => {
+	const makeFile = /* @__PURE__ */ makeTempFileFactory("makeTempFileScoped");
+	const removeDirectory = /* @__PURE__ */ removeFactory("makeTempFileScoped");
+	return (options) => Effect.acquireRelease(makeFile(options), (file) => Effect.orDie(removeDirectory(Path.dirname(file), { recursive: true })));
+})();
+const readDirectory = (path, options) => Effect.tryPromise({
+	try: () => NFS.promises.readdir(path, options),
+	catch: (err) => handleErrnoException("FileSystem", "readDirectory")(err, [path])
+});
+const readFile = (path) => Effect.async((resume, signal) => {
+	try {
+		NFS.readFile(path, { signal }, (err, data) => {
+			if (err) resume(Effect.fail(handleErrnoException("FileSystem", "readFile")(err, [path])));
+			else resume(Effect.succeed(data));
+		});
+	} catch (err) {
+		resume(Effect.fail(handleBadArgument("readFile")(err)));
+	}
+});
+const readLink = /* @__PURE__ */ (() => {
+	const nodeReadLink = /* @__PURE__ */ effectify(NFS.readlink, /* @__PURE__ */ handleErrnoException("FileSystem", "readLink"), /* @__PURE__ */ handleBadArgument("readLink"));
+	return (path) => nodeReadLink(path);
+})();
+const realPath = /* @__PURE__ */ (() => {
+	const nodeRealPath = /* @__PURE__ */ effectify(NFS.realpath, /* @__PURE__ */ handleErrnoException("FileSystem", "realPath"), /* @__PURE__ */ handleBadArgument("realPath"));
+	return (path) => nodeRealPath(path);
+})();
+const rename = /* @__PURE__ */ (() => {
+	const nodeRename = /* @__PURE__ */ effectify(NFS.rename, /* @__PURE__ */ handleErrnoException("FileSystem", "rename"), /* @__PURE__ */ handleBadArgument("rename"));
+	return (oldPath, newPath) => nodeRename(oldPath, newPath);
+})();
+const makeFileInfo = (stat) => ({
+	type: stat.isFile() ? "File" : stat.isDirectory() ? "Directory" : stat.isSymbolicLink() ? "SymbolicLink" : stat.isBlockDevice() ? "BlockDevice" : stat.isCharacterDevice() ? "CharacterDevice" : stat.isFIFO() ? "FIFO" : stat.isSocket() ? "Socket" : "Unknown",
+	mtime: Option.fromNullable(stat.mtime),
+	atime: Option.fromNullable(stat.atime),
+	birthtime: Option.fromNullable(stat.birthtime),
+	dev: stat.dev,
+	rdev: Option.fromNullable(stat.rdev),
+	ino: Option.fromNullable(stat.ino),
+	mode: stat.mode,
+	nlink: Option.fromNullable(stat.nlink),
+	uid: Option.fromNullable(stat.uid),
+	gid: Option.fromNullable(stat.gid),
+	size: Size(stat.size),
+	blksize: Option.map(Option.fromNullable(stat.blksize), Size),
+	blocks: Option.fromNullable(stat.blocks)
+});
+const stat = /* @__PURE__ */ (() => {
+	const nodeStat = /* @__PURE__ */ effectify(NFS.stat, /* @__PURE__ */ handleErrnoException("FileSystem", "stat"), /* @__PURE__ */ handleBadArgument("stat"));
+	return (path) => Effect.map(nodeStat(path), makeFileInfo);
+})();
+const symlink = /* @__PURE__ */ (() => {
+	const nodeSymlink = /* @__PURE__ */ effectify(NFS.symlink, /* @__PURE__ */ handleErrnoException("FileSystem", "symlink"), /* @__PURE__ */ handleBadArgument("symlink"));
+	return (target, path) => nodeSymlink(target, path);
+})();
+const truncate = /* @__PURE__ */ (() => {
+	const nodeTruncate = /* @__PURE__ */ effectify(NFS.truncate, /* @__PURE__ */ handleErrnoException("FileSystem", "truncate"), /* @__PURE__ */ handleBadArgument("truncate"));
+	return (path, length) => nodeTruncate(path, length !== void 0 ? Number(length) : void 0);
+})();
+const utimes = /* @__PURE__ */ (() => {
+	const nodeUtimes = /* @__PURE__ */ effectify(NFS.utimes, /* @__PURE__ */ handleErrnoException("FileSystem", "utime"), /* @__PURE__ */ handleBadArgument("utime"));
+	return (path, atime, mtime) => nodeUtimes(path, atime, mtime);
+})();
+const watchNode = (path, options) => Stream.asyncScoped((emit) => Effect.acquireRelease(Effect.sync(() => {
+	const watcher = NFS.watch(path, { recursive: options?.recursive }, (event, path) => {
+		if (!path) return;
+		switch (event) {
+			case "rename":
+				emit.fromEffect(Effect.matchEffect(stat(path), {
+					onSuccess: (_) => Effect.succeed(WatchEventCreate({ path })),
+					onFailure: (err) => err._tag === "SystemError" && err.reason === "NotFound" ? Effect.succeed(WatchEventRemove({ path })) : Effect.fail(err)
+				}));
+				return;
+			case "change":
+				emit.single(WatchEventUpdate({ path }));
+				return;
+		}
+	});
+	watcher.on("error", (error) => {
+		emit.fail(new SystemError({
+			module: "FileSystem",
+			reason: "Unknown",
+			method: "watch",
+			pathOrDescriptor: path,
+			cause: error
+		}));
+	});
+	watcher.on("close", () => {
+		emit.end();
+	});
+	return watcher;
+}), (watcher) => Effect.sync(() => watcher.close())));
+const watch = (backend, path, options) => stat(path).pipe(Effect.map((stat) => backend.pipe(Option.flatMap((_) => _.register(path, stat, options)), Option.getOrElse(() => watchNode(path, options)))), Stream.unwrap);
+const writeFile = (path, data, options) => Effect.async((resume, signal) => {
+	try {
+		NFS.writeFile(path, data, {
+			signal,
+			flag: options?.flag,
+			mode: options?.mode
+		}, (err) => {
+			if (err) resume(Effect.fail(handleErrnoException("FileSystem", "writeFile")(err, [path])));
+			else resume(Effect.void);
+		});
+	} catch (err) {
+		resume(Effect.fail(handleBadArgument("writeFile")(err)));
+	}
+});
+const makeFileSystem = /* @__PURE__ */ Effect.map(/* @__PURE__ */ Effect.serviceOption(WatchBackend), (backend) => make({
+	access,
+	chmod,
+	chown,
+	copy,
+	copyFile,
+	link,
+	makeDirectory,
+	makeTempDirectory,
+	makeTempDirectoryScoped,
+	makeTempFile,
+	makeTempFileScoped,
+	open,
+	readDirectory,
+	readFile,
+	readLink,
+	realPath,
+	remove,
+	rename,
+	stat,
+	symlink,
+	truncate,
+	utimes,
+	watch(path, options) {
+		return watch(backend, path, options);
+	},
+	writeFile
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node-shared@0.57.1_@effect+cluster@0.56.4_@effect+platform@0.94.5_effe_8874b4c5b98109adb0b32dd122fa88a9/node_modules/@effect/platform-node-shared/dist/esm/NodeFileSystem.js
+/**
+* @since 1.0.0
+*/
+/**
+* @since 1.0.0
+* @category layer
+*/
+const layer = /* @__PURE__ */ Layer.effect(FileSystem, makeFileSystem);
+//#endregion
+//#region ../kyju/src/v2/db/helpers.ts
+const paths = {
+	root: ({ config }) => path.join(config.dbPath, config.rootName + ".json"),
+	collection: ({ config, collectionId }) => path.join(config.dbPath, config.collectionsDirName, collectionId),
+	collectionIndex: ({ config, collectionId }) => path.join(config.dbPath, config.collectionsDirName, collectionId, config.collectionIndexName + ".json"),
+	page: ({ config, collectionId, pageId }) => path.join(config.dbPath, config.collectionsDirName, collectionId, config.pagesDirName, pageId),
+	pageIndex: ({ config, collectionId, pageId }) => path.join(config.dbPath, config.collectionsDirName, collectionId, config.pagesDirName, pageId, config.pageIndexName + ".json"),
+	pageData: ({ config, collectionId, pageId }) => path.join(config.dbPath, config.collectionsDirName, collectionId, config.pagesDirName, pageId, config.pageDataName + ".jsonl"),
+	blob: ({ config, blobId }) => path.join(config.dbPath, config.blobsDirName, blobId),
+	blobIndex: ({ config, blobId }) => path.join(config.dbPath, config.blobsDirName, blobId, config.blobIndexName + ".json"),
+	blobData: ({ config, blobId }) => path.join(config.dbPath, config.blobsDirName, blobId, config.blobDataName)
+};
+const makeAck = ({ requestId, sessionId, data }) => ({
+	type: "ack",
+	requestId,
+	sessionId,
+	...data
+});
+const makeErrorAck = ({ requestId, sessionId, _tag, message }) => ({
+	type: "ack",
+	requestId,
+	sessionId: sessionId ?? "",
+	error: {
+		_tag,
+		message
+	}
+});
+const broadcastWrite = ({ sessions, excludeSessionId, op }) => {
+	for (const [, session] of sessions) {
+		if (session.sessionId === excludeSessionId) continue;
+		session.send({
+			kind: "replicated-write",
+			op
+		});
+	}
+};
+const broadcastDbUpdate = ({ sessions, message }) => {
+	for (const [, session] of sessions) session.send({
+		kind: "db-update",
+		message
+	});
+};
+const broadcastCollectionWrite = ({ sessions, excludeSessionId, collectionId, op }) => {
+	for (const [, session] of sessions) {
+		if (session.sessionId === excludeSessionId) continue;
+		if (!session.subscriptions.has(collectionId)) continue;
+		session.send({
+			kind: "replicated-write",
+			op
+		});
+	}
+};
+const sendAck = ({ session, ack }) => {
+	session.send({
+		kind: "db-update",
+		message: ack
+	});
+};
+/**
+* 
+*todo: explore this impl im very sus with the regex testing
+*
+*/
+const setAtPath = ({ root, path: pathSegments, value }) => {
+	if (pathSegments.length === 0) return value;
+	const [head, ...rest] = pathSegments;
+	const isIndex = /^\d+$/.test(head);
+	if (Array.isArray(root)) {
+		const arr = root;
+		const index = Number(head);
+		if (rest.length === 0) {
+			arr[index] = value;
+			return arr;
+		}
+		arr[index] = setAtPath({
+			root: arr[index] ?? (/^\d+$/.test(rest[0] ?? "") ? [] : {}),
+			path: rest,
+			value
+		});
+		return arr;
+	}
+	if (typeof root !== "object" || root === null) root = isIndex ? [] : {};
+	if (Array.isArray(root)) {
+		const arr = root;
+		const index = Number(head);
+		if (rest.length === 0) {
+			arr[index] = value;
+			return arr;
+		}
+		arr[index] = setAtPath({
+			root: arr[index] ?? (/^\d+$/.test(rest[0] ?? "") ? [] : {}),
+			path: rest,
+			value
+		});
+		return arr;
+	}
+	const obj = root;
+	if (rest.length === 0) {
+		obj[head] = value;
+		return obj;
+	}
+	obj[head] = setAtPath({
+		root: obj[head] ?? (/^\d+$/.test(rest[0] ?? "") ? [] : {}),
+		path: rest,
+		value
+	});
+	return obj;
+};
+const createCollection = ({ fs, config, collectionId, data }) => Effect.gen(function* () {
+	const pageId = nanoid();
+	const items = data ?? [];
+	yield* fs.makeDirectory(paths.page({
+		config,
+		collectionId,
+		pageId
+	}), { recursive: true });
+	const jsonlContent = items.map((item) => JSON.stringify(item)).join("\n") + (items.length > 0 ? "\n" : "");
+	yield* Effect.all([
+		writeJsonFile({
+			fs,
+			config,
+			path: paths.collectionIndex({
+				config,
+				collectionId
+			}),
+			data: {
+				activePageId: pageId,
+				totalPages: 1,
+				totalCount: items.length
+			}
+		}),
+		writeJsonFile({
+			fs,
+			config,
+			path: paths.pageIndex({
+				config,
+				collectionId,
+				pageId
+			}),
+			data: {
+				pageId,
+				order: 0
+			}
+		}),
+		fs.writeFileString(paths.pageData({
+			config,
+			collectionId,
+			pageId
+		}), jsonlContent)
+	]);
+});
+const createBlob = ({ fs, config, blobId, data }) => Effect.gen(function* () {
+	yield* fs.makeDirectory(paths.blob({
+		config,
+		blobId
+	}), { recursive: true });
+	const dataPath = paths.blobData({
+		config,
+		blobId
+	});
+	yield* fs.writeFile(dataPath, data);
+	const stats = yield* fs.stat(dataPath);
+	yield* writeJsonFile({
+		fs,
+		config,
+		path: paths.blobIndex({
+			config,
+			blobId
+		}),
+		data: {
+			blobId,
+			fileSize: Number(stats.size)
+		}
+	});
+});
+const readJsonFile = ({ fs, path: filePath }) => Effect.gen(function* () {
+	const content = yield* fs.readFileString(filePath);
+	return JSON.parse(content);
+});
+/**
+* Atomic JSON write.
+*
+* Writes happen in two steps: the JSON is staged in the dedicated
+* `config.tmpDir` under a unique filename, then `rename(2)`'d over the
+* final path. `rename` is atomic within a filesystem, so readers always
+* observe either the prior contents or the fully-written new contents —
+* never a partial. A process death between write and rename leaves an
+* orphan tmp file; `cleanupStaleTmpFiles` sweeps those at boot.
+*
+* Staging all tmp files into a single, known directory (rather than
+* alongside each destination as `<file>.tmp-<id>`) means recovery is O(1)
+* in directory count: one readdir on `<dbPath>/.tmp/`. The previous
+* "sentinel suffix scattered across the tree" layout forced an O(db-size)
+* tree walk on every boot.
+*
+* Precondition: `config.tmpDir` must exist (createDb creates it during
+* init) and live on the same filesystem as `filePath` (always true when
+* both are under `config.dbPath`).
+*/
+const writeJsonFile = ({ fs, config, path: filePath, data }) => Effect.gen(function* () {
+	const json = JSON.stringify(data);
+	const tmpPath = path.join(config.tmpDir, `${path.basename(filePath)}-${nanoid(8)}`);
+	yield* fs.writeFileString(tmpPath, json);
+	yield* fs.rename(tmpPath, filePath);
+});
+/**
+* Reclaim orphan tmp files under `config.tmpDir`. Intended to run at
+* startup, before any writer is active — every file remaining in tmpDir
+* at that moment is by definition an orphan from a prior process (the
+* successful writes got rename'd away; the unsuccessful ones never made
+* it to their final destinations).
+*
+* O(pending tmp files), not O(db size). Single flat directory, no
+* recursion, no sentinel matching.
+*/
+const cleanupStaleTmpFiles = (fs, tmpDir) => Effect.gen(function* () {
+	if (!(yield* fs.exists(tmpDir))) return;
+	const entries = yield* fs.readDirectory(tmpDir).pipe(Effect.catchAll(() => Effect.succeed([])));
+	for (const name of entries) {
+		const full = path.join(tmpDir, name);
+		yield* fs.remove(full).pipe(Effect.catchAll((err) => {
+			console.error(`[kyju:db] failed to remove stale tmp ${full}:`, err);
+			return Effect.void;
+		}));
+	}
+});
+const readJsonlFile = ({ fs, path: filePath }) => Effect.gen(function* () {
+	const content = yield* fs.readFileString(filePath);
+	if (content.trim() === "") return [];
+	return content.trim().split("\n").map((line) => JSON.parse(line));
+});
+/**
+* Read items from a collection by global index range [start, end).
+* Walks the page index to find which page files contain the requested
+* items, reads only those pages, and returns the sliced items plus
+* totalCount. Pages are a storage concern — callers get a flat item
+* array.
+*/
+const readCollectionItemRange = ({ fs, config, collectionId, start, end }) => Effect.gen(function* () {
+	const collectionDir = paths.collection({
+		config,
+		collectionId
+	});
+	const pagesDir = path.join(collectionDir, config.pagesDirName);
+	const pageDirs = yield* fs.readDirectory(pagesDir);
+	const sorted = (yield* Effect.all(pageDirs.map((pageId) => Effect.gen(function* () {
+		return {
+			id: pageId,
+			order: JSON.parse(yield* fs.readFileString(paths.pageIndex({
+				config,
+				collectionId,
+				pageId
+			}))).order
+		};
+	})), { concurrency: "unbounded" })).sort((a, b) => a.order - b.order);
+	const allItems = [];
+	for (const entry of sorted) {
+		const pageItems = yield* readJsonlFile({
+			fs,
+			path: paths.pageData({
+				config,
+				collectionId,
+				pageId: entry.id
+			})
+		});
+		allItems.push(...pageItems);
+	}
+	const totalCount = allItems.length;
+	const resolvedStart = start ?? 0;
+	const resolvedEnd = end ?? totalCount;
+	return {
+		items: allItems.slice(Math.max(0, resolvedStart), Math.min(totalCount, resolvedEnd)),
+		totalCount
+	};
+});
+const validateSession = (ctx, sessionId, requestId, replicaId) => Effect.gen(function* () {
+	const session = (yield* Ref.get(ctx.sessionsRef)).get(sessionId);
+	if (!session) {
+		ctx.dbSend({
+			kind: "db-update",
+			replicaId,
+			message: makeErrorAck({
+				requestId,
+				sessionId,
+				_tag: "InvalidSessionError",
+				message: "Invalid session"
+			})
+		});
+		return yield* Effect.fail("INVALID_SESSION");
+	}
+	return session;
+});
+//#endregion
+//#region ../kyju/src/v2/db/root-cache.ts
+const makeRootCache = (fs, config, rootMutex) => Effect.gen(function* () {
+	let cached = yield* readJsonFile({
+		fs,
+		path: paths.root({ config })
+	});
+	let scheduledTimer = null;
+	let runner = null;
+	let pending = false;
+	const doFlush = () => Effect.runPromise(rootMutex.withPermits(1)(traceKyju("kyju:db.root.flush", writeJsonFile({
+		fs,
+		config,
+		path: paths.root({ config }),
+		data: cached
+	}))).pipe(Effect.catchAll((err) => {
+		console.error("[kyju:rootCache] flush failed:", err);
+		return Effect.void;
+	})));
+	const startRunner = () => {
+		scheduledTimer = null;
+		if (runner) return;
+		runner = (async () => {
+			while (pending) {
+				pending = false;
+				await doFlush();
+			}
+			runner = null;
+		})();
+	};
+	return {
+		read: () => Effect.sync(() => cached),
+		set: (root) => Effect.sync(() => {
+			cached = root;
+			pending = true;
+			if (runner || scheduledTimer) return;
+			scheduledTimer = setImmediate(startRunner);
+		}),
+		flush: () => Effect.gen(function* () {
+			if (scheduledTimer) {
+				const t = scheduledTimer;
+				scheduledTimer = null;
+				yield* Effect.sync(() => clearImmediate(t));
+				startRunner();
+			} else if (pending && !runner) startRunner();
+			if (runner) yield* Effect.promise(() => runner);
+		})
+	};
+});
+//#endregion
+//#region ../kyju/src/v2/db/handlers/write.ts
+const handleWrite = (ctx, event) => traceKyju(`kyju:db.handleWrite`, handleWriteImpl(ctx, event), { op: event.op.type });
+const handleWriteImpl = (ctx, event) => Effect.gen(function* () {
+	const session = yield* validateSession(ctx, event.sessionId, event.requestId, event.replicaId);
+	switch (event.op.type) {
+		case "root.set": {
+			const typedOp = event.op;
+			yield* traceKyju("kyju:db.root.mutex+cache", ctx.rootMutex.withPermits(1)(Effect.gen(function* () {
+				const root = yield* ctx.rootCache.read();
+				const updated = traceKyjuSync("kyju:db.root.setAtPath", () => setAtPath({
+					root,
+					path: typedOp.path,
+					value: typedOp.value
+				}));
+				yield* ctx.rootCache.set(updated);
+			})));
+			sendAck({
+				session,
+				ack: makeAck({
+					requestId: event.requestId,
+					sessionId: event.sessionId
+				})
+			});
+			const sessions = yield* Ref.get(ctx.sessionsRef);
+			traceKyjuSync("kyju:db.root.broadcast", () => broadcastWrite({
+				sessions,
+				excludeSessionId: event.sessionId,
+				op: event.op
+			}));
+			return;
+		}
+		case "collection.create":
+			yield* createCollection({
+				fs: ctx.fs,
+				config: ctx.config,
+				collectionId: event.op.collectionId,
+				data: event.op.data
+			});
+			sendAck({
+				session,
+				ack: makeAck({
+					requestId: event.requestId,
+					sessionId: event.sessionId
+				})
+			});
+			broadcastCollectionWrite({
+				sessions: yield* Ref.get(ctx.sessionsRef),
+				excludeSessionId: event.sessionId,
+				collectionId: event.op.collectionId,
+				op: event.op
+			});
+			return;
+		case "collection.concat": {
+			const typedOp = event.op;
+			yield* ctx.collectionMutex.withPermits(1)(Effect.gen(function* () {
+				if (typedOp.data.length === 0) {
+					sendAck({
+						session,
+						ack: makeAck({
+							requestId: event.requestId,
+							sessionId: event.sessionId
+						})
+					});
+					return;
+				}
+				const collectionDir = paths.collection({
+					config: ctx.config,
+					collectionId: typedOp.collectionId
+				});
+				if (!(yield* ctx.fs.exists(collectionDir))) yield* createCollection({
+					fs: ctx.fs,
+					config: ctx.config,
+					collectionId: typedOp.collectionId
+				});
+				const collectionIndexPath = paths.collectionIndex({
+					config: ctx.config,
+					collectionId: typedOp.collectionId
+				});
+				const collectionIndex = JSON.parse(yield* ctx.fs.readFileString(collectionIndexPath));
+				let activePageId = collectionIndex.activePageId;
+				const activeDataPath = paths.pageData({
+					config: ctx.config,
+					collectionId: typedOp.collectionId,
+					pageId: activePageId
+				});
+				const stats = yield* ctx.fs.stat(activeDataPath);
+				const currentSize = Number(stats.size);
+				const jsonlContent = typedOp.data.map((item) => JSON.stringify(item)).join("\n") + "\n";
+				if (currentSize >= ctx.config.maxPageSize) {
+					const newPageId = nanoid();
+					yield* ctx.fs.makeDirectory(paths.page({
+						config: ctx.config,
+						collectionId: typedOp.collectionId,
+						pageId: newPageId
+					}), { recursive: true });
+					const pIndex = {
+						pageId: newPageId,
+						order: collectionIndex.totalPages
+					};
+					yield* Effect.all([writeJsonFile({
+						fs: ctx.fs,
+						config: ctx.config,
+						path: paths.pageIndex({
+							config: ctx.config,
+							collectionId: typedOp.collectionId,
+							pageId: newPageId
+						}),
+						data: pIndex
+					}), ctx.fs.writeFileString(paths.pageData({
+						config: ctx.config,
+						collectionId: typedOp.collectionId,
+						pageId: newPageId
+					}), jsonlContent)]);
+					collectionIndex.activePageId = newPageId;
+					collectionIndex.totalPages += 1;
+					activePageId = newPageId;
+				} else yield* Effect.scoped(Effect.gen(function* () {
+					yield* (yield* ctx.fs.open(activeDataPath, { flag: "a" })).write(new TextEncoder().encode(jsonlContent));
+				}));
+				const startIndex = collectionIndex.totalCount;
+				collectionIndex.totalCount += typedOp.data.length;
+				yield* writeJsonFile({
+					fs: ctx.fs,
+					config: ctx.config,
+					path: collectionIndexPath,
+					data: collectionIndex
+				});
+				const newStats = yield* ctx.fs.stat(paths.pageData({
+					config: ctx.config,
+					collectionId: typedOp.collectionId,
+					pageId: activePageId
+				}));
+				Number(newStats.size);
+				sendAck({
+					session,
+					ack: makeAck({
+						requestId: event.requestId,
+						sessionId: event.sessionId
+					})
+				});
+				broadcastCollectionWrite({
+					sessions: yield* Ref.get(ctx.sessionsRef),
+					excludeSessionId: event.sessionId,
+					collectionId: typedOp.collectionId,
+					op: {
+						...typedOp,
+						authority: {
+							startIndex,
+							totalCount: collectionIndex.totalCount
+						}
+					}
+				});
+			}));
+			return;
+		}
+		case "collection.delete": {
+			const typedOp = event.op;
+			yield* ctx.collectionMutex.withPermits(1)(Effect.gen(function* () {
+				const collectionDir = paths.collection({
+					config: ctx.config,
+					collectionId: typedOp.collectionId
+				});
+				if (!(yield* ctx.fs.exists(collectionDir))) {
+					sendAck({
+						session,
+						ack: makeErrorAck({
+							requestId: event.requestId,
+							sessionId: event.sessionId,
+							_tag: "NotFoundError",
+							message: `Collection ${typedOp.collectionId} not found`
+						})
+					});
+					return;
+				}
+				if (ctx.config.checkReferences) {
+					const root = yield* ctx.rootCache.read();
+					if (JSON.stringify(root).includes(typedOp.collectionId)) {
+						sendAck({
+							session,
+							ack: makeErrorAck({
+								requestId: event.requestId,
+								sessionId: event.sessionId,
+								_tag: "ReferenceExistsError",
+								message: `Collection ${typedOp.collectionId} still has references`
+							})
+						});
+						return;
+					}
+				}
+				yield* ctx.fs.remove(collectionDir, { recursive: true });
+				sendAck({
+					session,
+					ack: makeAck({
+						requestId: event.requestId,
+						sessionId: event.sessionId
+					})
+				});
+				const sessions = yield* Ref.get(ctx.sessionsRef);
+				broadcastCollectionWrite({
+					sessions,
+					excludeSessionId: event.sessionId,
+					collectionId: typedOp.collectionId,
+					op: event.op
+				});
+				for (const [, s] of sessions) s.subscriptions.delete(typedOp.collectionId);
+			}));
+			return;
+		}
+		case "blob.create":
+			yield* createBlob({
+				fs: ctx.fs,
+				config: ctx.config,
+				blobId: event.op.blobId,
+				data: event.op.data
+			});
+			sendAck({
+				session,
+				ack: makeAck({
+					requestId: event.requestId,
+					sessionId: event.sessionId
+				})
+			});
+			broadcastWrite({
+				sessions: yield* Ref.get(ctx.sessionsRef),
+				excludeSessionId: event.sessionId,
+				op: event.op
+			});
+			return;
+		case "blob.set": {
+			const typedOp = event.op;
+			yield* ctx.blobMutex.withPermits(1)(Effect.gen(function* () {
+				if (!(yield* ctx.fs.exists(paths.blob({
+					config: ctx.config,
+					blobId: typedOp.blobId
+				})))) {
+					sendAck({
+						session,
+						ack: makeErrorAck({
+							requestId: event.requestId,
+							sessionId: event.sessionId,
+							_tag: "NotFoundError",
+							message: `Blob ${typedOp.blobId} not found`
+						})
+					});
+					return;
+				}
+				const dataPath = paths.blobData({
+					config: ctx.config,
+					blobId: typedOp.blobId
+				});
+				yield* ctx.fs.writeFile(dataPath, typedOp.data);
+				const blobStats = yield* ctx.fs.stat(dataPath);
+				const bIdx = {
+					blobId: typedOp.blobId,
+					fileSize: Number(blobStats.size)
+				};
+				yield* writeJsonFile({
+					fs: ctx.fs,
+					config: ctx.config,
+					path: paths.blobIndex({
+						config: ctx.config,
+						blobId: typedOp.blobId
+					}),
+					data: bIdx
+				});
+				sendAck({
+					session,
+					ack: makeAck({
+						requestId: event.requestId,
+						sessionId: event.sessionId
+					})
+				});
+				const sessions = yield* Ref.get(ctx.sessionsRef);
+				broadcastWrite({
+					sessions,
+					excludeSessionId: event.sessionId,
+					op: typedOp
+				});
+				broadcastDbUpdate({
+					sessions,
+					message: {
+						type: "blob.metadataUpdate",
+						blobId: typedOp.blobId,
+						fileSize: Number(blobStats.size)
+					}
+				});
+			}));
+			return;
+		}
+		case "blob.delete": {
+			const typedOp = event.op;
+			yield* ctx.blobMutex.withPermits(1)(Effect.gen(function* () {
+				const blobDir = paths.blob({
+					config: ctx.config,
+					blobId: typedOp.blobId
+				});
+				if (!(yield* ctx.fs.exists(blobDir))) {
+					sendAck({
+						session,
+						ack: makeErrorAck({
+							requestId: event.requestId,
+							sessionId: event.sessionId,
+							_tag: "NotFoundError",
+							message: `Blob ${typedOp.blobId} not found`
+						})
+					});
+					return;
+				}
+				if (ctx.config.checkReferences) {
+					const root = yield* ctx.rootCache.read();
+					if (JSON.stringify(root).includes(typedOp.blobId)) {
+						sendAck({
+							session,
+							ack: makeErrorAck({
+								requestId: event.requestId,
+								sessionId: event.sessionId,
+								_tag: "ReferenceExistsError",
+								message: `Blob ${typedOp.blobId} still has references`
+							})
+						});
+						return;
+					}
+				}
+				yield* ctx.fs.remove(blobDir, { recursive: true });
+				sendAck({
+					session,
+					ack: makeAck({
+						requestId: event.requestId,
+						sessionId: event.sessionId
+					})
+				});
+				broadcastWrite({
+					sessions: yield* Ref.get(ctx.sessionsRef),
+					excludeSessionId: event.sessionId,
+					op: event.op
+				});
+			}));
+			return;
+		}
+	}
+});
+//#endregion
+export { handleErrnoException as _, createBlob as a, makeErrorAck as c, readJsonFile as d, readJsonlFile as f, layer as g, writeJsonFile as h, cleanupStaleTmpFiles as i, paths as l, validateSession as m, makeRootCache as n, createCollection as o, sendAck as p, broadcastDbUpdate as r, makeAck as s, handleWrite as t, readCollectionItemRange as u, FileSystem as v, BadArgument as y };