@power-plant/schema 0.0.25 → 0.0.26

package/dist/storage-B8aDmNpv.cjs

@@ -0,0 +1,934 @@
+const require_rolldown_runtime = require('./rolldown-runtime-C_NdSu1c.cjs');
+let node_events = require("node:events");
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
+let node_util = require("node:util");
+let node_buffer = require("node:buffer");
+let node_worker_threads = require("node:worker_threads");
+let node_stream = require("node:stream");
+
+//#region src/storage/helpers.ts
+function toPathInput(path) {
+	if (path instanceof URL) return decodeURIComponent(path.pathname);
+	if (node_buffer.Buffer.isBuffer(path)) return path.toString();
+	return path;
+}
+function normalizeKey(path) {
+	let value = toPathInput(path).replace(/\\/g, "/");
+	while (value.startsWith("./")) value = value.slice(2);
+	value = value.replace(/^\/+/, "");
+	value = value.replace(/\/+/g, "/");
+	if (value.length > 1 && value.endsWith("/")) value = value.slice(0, -1);
+	return value;
+}
+function resolveKey(...segments) {
+	const parts = [];
+	for (const segment of segments) for (const part of normalizeKey(segment).split("/")) {
+		if (!part || part === ".") continue;
+		if (part === "..") {
+			parts.pop();
+			continue;
+		}
+		parts.push(part);
+	}
+	return parts.join("/");
+}
+function dirname(key) {
+	const index = key.lastIndexOf("/");
+	return index === -1 ? "" : key.slice(0, index);
+}
+function basename(key) {
+	const index = key.lastIndexOf("/");
+	return index === -1 ? key : key.slice(index + 1);
+}
+function isMetaStorageKey(key) {
+	return key.endsWith("$");
+}
+function parentPrefix(key) {
+	return key ? `${key}/` : "";
+}
+function getImmediateChildren(base, keys) {
+	const prefix = parentPrefix(base);
+	const children = /* @__PURE__ */ new Set();
+	for (const key of keys) {
+		if (isMetaStorageKey(key)) continue;
+		const relative = prefix ? key.startsWith(prefix) ? key.slice(prefix.length) : "" : key;
+		if (!relative || relative === key) continue;
+		const slashIndex = relative.indexOf("/");
+		children.add(slashIndex === -1 ? relative : relative.slice(0, slashIndex));
+	}
+	return [...children].sort();
+}
+function createFsError(code, syscall, path, message) {
+	const suffix = path ? ` '${path}'` : "";
+	const error = new Error(message ?? `${code}: ${syscall}${suffix}`);
+	error.code = code;
+	error.syscall = syscall;
+	if (path) error.path = path;
+	return error;
+}
+function runSync(operation) {
+	const { port1, port2 } = new node_worker_threads.MessageChannel();
+	operation().then((value) => {
+		port1.postMessage({
+			ok: true,
+			value
+		});
+	}, (error) => {
+		port1.postMessage({
+			ok: false,
+			error
+		});
+	});
+	const response = (0, node_worker_threads.receiveMessageOnPort)(port2);
+	port1.close();
+	port2.close();
+	if (!response) throw new Error("Storage operation did not complete.");
+	if (!response.message.ok) throw response.message.error;
+	return response.message.value;
+}
+function toBuffer(value) {
+	if (value == null) return node_buffer.Buffer.alloc(0);
+	if (node_buffer.Buffer.isBuffer(value)) return value;
+	if (value instanceof Uint8Array) return node_buffer.Buffer.from(value);
+	return node_buffer.Buffer.from(value);
+}
+function getEncoding(options) {
+	if (typeof options === "string") return options;
+	if (options == null) return;
+	return options.encoding ?? void 0;
+}
+function shouldReadRaw(options) {
+	const encoding = getEncoding(options);
+	return encoding === void 0 || encoding === null || encoding === "buffer";
+}
+function decodeStoredValue(value, encoding) {
+	const buffer = toBuffer(typeof value === "string" || node_buffer.Buffer.isBuffer(value) || value instanceof Uint8Array ? value : value == null ? "" : JSON.stringify(value));
+	if (encoding === void 0 || encoding === null || encoding === "buffer") return buffer;
+	return buffer.toString(encoding);
+}
+function encodeWriteValue(data) {
+	if (typeof data === "string") return data;
+	return toBuffer(node_buffer.Buffer.from(data.buffer, data.byteOffset, data.byteLength));
+}
+function createStats(type, meta, size = 0) {
+	const now = Date.now();
+	const atime = meta?.atime instanceof Date ? meta.atime : new Date(now);
+	const mtime = meta?.mtime instanceof Date ? meta.mtime : new Date(now);
+	const mode = type === "directory" ? 16877 : type === "symlink" ? 41471 : 33188;
+	const stat = Object.create(node_fs.Stats.prototype);
+	Object.assign(stat, {
+		dev: 0,
+		ino: 0,
+		mode,
+		nlink: 1,
+		uid: typeof meta?.uid === "number" ? meta.uid : 0,
+		gid: typeof meta?.gid === "number" ? meta.gid : 0,
+		rdev: 0,
+		size,
+		blksize: 4096,
+		blocks: Math.ceil(size / 512),
+		atimeMs: atime.getTime(),
+		mtimeMs: mtime.getTime(),
+		ctimeMs: mtime.getTime(),
+		birthtimeMs: mtime.getTime(),
+		atime,
+		mtime,
+		ctime: mtime,
+		birthtime: mtime
+	});
+	return stat;
+}
+function matchesGlobPattern(pattern, value) {
+	return new RegExp(`^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".")}$`).test(value);
+}
+function randomSuffix(length = 6) {
+	return Array.from({ length }, () => "abcdefghijklmnopqrstuvwxyz0123456789".charAt(Math.floor(Math.random() * 36))).join("");
+}
+
+//#endregion
+//#region src/storage/promises.ts
+const SYMLINK_META_KEY = "symlinkTarget";
+function createStoragePromises(storage) {
+	const openDescriptors = /* @__PURE__ */ new Map();
+	let nextDescriptor = 3;
+	async function getMetaSafe(key) {
+		try {
+			return await storage.getMeta(key) ?? null;
+		} catch {
+			return null;
+		}
+	}
+	async function getEntry(path, followSymlinks = true) {
+		const key = normalizeKey(path);
+		if (!key && path !== "." && path !== "/") return null;
+		const meta = await getMetaSafe(key);
+		if (meta?.[SYMLINK_META_KEY] && typeof meta[SYMLINK_META_KEY] === "string") {
+			if (!followSymlinks) return {
+				key,
+				type: "symlink",
+				meta
+			};
+			return getEntry(meta[SYMLINK_META_KEY], true);
+		}
+		if (await storage.hasItem(key)) return {
+			key,
+			type: "file",
+			meta
+		};
+		if (getImmediateChildren(key, (await storage.getKeys(key)).filter((storageKey) => storageKey !== key && !isMetaStorageKey(storageKey))).length > 0) return {
+			key,
+			type: "directory",
+			meta
+		};
+		return null;
+	}
+	async function requireEntry(path, followSymlinks = true) {
+		const entry = await getEntry(path, followSymlinks);
+		if (!entry) throw createFsError("ENOENT", "stat", normalizeKey(path));
+		return entry;
+	}
+	async function getFileSize(key) {
+		const meta = await getMetaSafe(key);
+		if (typeof meta?.size === "number") return meta.size;
+		if (shouldReadRaw()) {
+			const raw = await storage.getItemRaw(key);
+			return raw == null ? 0 : toBuffer(raw).byteLength;
+		}
+		const value = await storage.getItem(key);
+		return value == null ? 0 : toBuffer(String(value)).byteLength;
+	}
+	async function readStoredFile(path, options) {
+		const key = normalizeKey(path);
+		if ((await requireEntry(key, true)).type !== "file") throw createFsError("EISDIR", "read", key, "EISDIR: illegal operation on a directory, read");
+		const encoding = getEncoding(options);
+		const value = shouldReadRaw(options) ? await storage.getItemRaw(key) : await storage.getItem(key);
+		if (value == null) throw createFsError("ENOENT", "open", key);
+		return decodeStoredValue(value, encoding);
+	}
+	async function writeStoredFile(path, data, options) {
+		const key = normalizeKey(path);
+		const encoding = getEncoding(options);
+		const payload = typeof data === "string" ? data : encoding && encoding !== "buffer" ? toBuffer(encodeWriteValue(data)).toString(encoding) : encodeWriteValue(data);
+		await storage.setItem(key, payload);
+		await storage.setMeta(key, {
+			mtime: /* @__PURE__ */ new Date(),
+			atime: /* @__PURE__ */ new Date(),
+			size: toBuffer(payload).byteLength
+		});
+	}
+	async function removePath(path, options) {
+		const key = normalizeKey(path);
+		const entry = await getEntry(key, false);
+		if (!entry) {
+			if (typeof options === "object" && options && "recursive" in options && options.recursive) return;
+			throw createFsError("ENOENT", "unlink", key);
+		}
+		if (entry.type === "directory") {
+			const recursive = options === true || (typeof options === "object" && options && "recursive" in options ? Boolean(options.recursive) : false);
+			const descendants = (await storage.getKeys(key)).filter((storageKey) => storageKey !== key && !isMetaStorageKey(storageKey) && storageKey.startsWith(parentPrefix(key)));
+			if (!recursive && descendants.length > 0) throw createFsError("ENOTEMPTY", "rmdir", key);
+			await Promise.all(descendants.map(async (descendant) => storage.removeItem(descendant)));
+			if (await storage.hasItem(key)) await storage.removeItem(key);
+			return;
+		}
+		await storage.removeItem(key);
+	}
+	async function copyEntry(source, destination, recursive = false) {
+		if ((await requireEntry(source, true)).type === "directory") {
+			if (!recursive) throw createFsError("EISDIR", "copy", source, "EISDIR: illegal operation on a directory, copy");
+			const keys = await storage.getKeys(source);
+			for (const key of keys) {
+				if (isMetaStorageKey(key) || key === source) continue;
+				await copyEntry(key, resolveKey(destination, key.slice(source.length).replace(/^\//, "")), true);
+			}
+			return;
+		}
+		const content = await readStoredFile(source);
+		await writeStoredFile(destination, typeof content === "string" ? content : toBuffer(content));
+		const meta = await getMetaSafe(source);
+		if (meta) await storage.setMeta(normalizeKey(destination), meta);
+	}
+	async function statPath(path, followSymlinks = true) {
+		const entry = await requireEntry(path, followSymlinks);
+		const size = entry.type === "file" ? await getFileSize(entry.key) : 4096;
+		return createStats(entry.type, entry.meta, size);
+	}
+	async function chmodPath(path, mode) {
+		const key = normalizeKey(path);
+		await requireEntry(key, true);
+		await storage.setMeta(key, { mode });
+	}
+	async function chownPath(path, uid, gid) {
+		const key = normalizeKey(path);
+		await requireEntry(key, true);
+		await storage.setMeta(key, {
+			uid,
+			gid
+		});
+	}
+	async function mkdirPath(path, options) {
+		const key = normalizeKey(path);
+		const recursive = typeof options === "object" && options ? Boolean(options.recursive) : false;
+		if (!key) return;
+		const parent = dirname(key);
+		if (parent) {
+			const parentEntry = await getEntry(parent, true);
+			if (!parentEntry && !recursive) throw createFsError("ENOENT", "mkdir", key);
+			if (!parentEntry && recursive) await mkdirPath(parent, { recursive: true });
+		}
+		if ((await getEntry(key, true))?.type === "file") throw createFsError("EEXIST", "mkdir", key);
+	}
+	async function mkdtempPath(prefix, options) {
+		const directory = `${normalizeKey(prefix)}${randomSuffix()}`;
+		await mkdirPath(directory, { recursive: true });
+		if (options?.encoding === "buffer") return node_buffer.Buffer.from(directory);
+		return directory;
+	}
+	function createDir(path, options) {
+		const key = normalizeKey(path);
+		let entries = [];
+		let loaded = false;
+		let index = 0;
+		let closed = false;
+		const loadEntries = async () => {
+			if (loaded) return;
+			await requireEntry(key, true);
+			const keys = await storage.getKeys(key);
+			entries = getImmediateChildren(key, keys.filter((storageKey) => !isMetaStorageKey(storageKey)));
+			loaded = true;
+		};
+		const toDirent = (name) => ({
+			name,
+			isFile: () => true,
+			isDirectory: () => false,
+			isBlockDevice: () => false,
+			isCharacterDevice: () => false,
+			isSymbolicLink: () => false,
+			isFIFO: () => false,
+			isSocket: () => false
+		});
+		return {
+			path: key,
+			async read() {
+				if (closed) throw createFsError("EBADF", "readdir", key);
+				await loadEntries();
+				if (index >= entries.length) return null;
+				const name = entries[index++];
+				if (options?.encoding === "buffer") return node_buffer.Buffer.from(name);
+				return toDirent(name);
+			},
+			async close() {
+				closed = true;
+			},
+			async *[Symbol.asyncIterator]() {
+				while (true) {
+					const entry = await this.read();
+					if (!entry) break;
+					yield entry;
+				}
+			}
+		};
+	}
+	function createReadStream(path, options) {
+		const key = normalizeKey(path);
+		const start = options?.start ?? 0;
+		const end = options?.end;
+		return node_stream.Readable.from((async function* () {
+			let content = toBuffer(await readStoredFile(key));
+			if (start > 0) content = content.subarray(start);
+			if (end != null) {
+				yield content.subarray(0, Math.max(0, end - start + 1));
+				return;
+			}
+			yield content;
+		})());
+	}
+	function createWriteStream(path, options) {
+		const key = normalizeKey(path);
+		const chunks = [];
+		return new node_stream.Writable({
+			write(chunk, _encoding, callback) {
+				chunks.push(toBuffer(chunk));
+				callback();
+			},
+			final: (callback) => {
+				const content = node_buffer.Buffer.concat(chunks);
+				const payload = options?.encoding && options.encoding !== "buffer" ? content.toString(options.encoding) : content;
+				writeStoredFile(key, payload, options).then(() => callback()).catch((error) => callback(error));
+			}
+		});
+	}
+	function createFileHandle(descriptor, key) {
+		const getDescriptor = () => {
+			const current = openDescriptors.get(descriptor);
+			if (!current) throw createFsError("EBADF", "read", key);
+			return current;
+		};
+		return {
+			fd: descriptor,
+			async appendFile(data, options) {
+				const current = await readStoredFile(key).catch(() => node_buffer.Buffer.alloc(0));
+				await writeStoredFile(key, node_buffer.Buffer.concat([toBuffer(current), toBuffer(typeof data === "string" ? data : encodeWriteValue(data))]), options);
+			},
+			async chmod(_mode) {},
+			async chown(_uid, _gid) {},
+			async close() {
+				openDescriptors.delete(descriptor);
+			},
+			createReadStream(options) {
+				return createReadStream(key, options);
+			},
+			createWriteStream(options) {
+				return createWriteStream(key, options);
+			},
+			async datasync() {},
+			async read(buffer, offset, length, position) {
+				const current = getDescriptor();
+				const content = toBuffer(await readStoredFile(key, { encoding: void 0 }));
+				const readPosition = position ?? current.position;
+				const readOffset = offset ?? 0;
+				const readLength = length ?? buffer.length - readOffset;
+				const bytesRead = content.copy(buffer, readOffset, readPosition, readPosition + readLength);
+				if (position === null || position === void 0) current.position += bytesRead;
+				return {
+					bytesRead,
+					buffer
+				};
+			},
+			async readFile(options) {
+				return readStoredFile(key, options);
+			},
+			async stat(_options) {
+				return statPath(key);
+			},
+			async sync() {},
+			async truncate(len = 0) {
+				await writeStoredFile(key, toBuffer(await readStoredFile(key)).subarray(0, len));
+			},
+			async utimes(_atime, _mtime) {
+				await storage.setMeta(key, {
+					atime: new Date(_atime),
+					mtime: new Date(_mtime)
+				});
+			},
+			async write(buffer, offset, length, position) {
+				const current = getDescriptor();
+				const content = toBuffer(await readStoredFile(key).catch(() => ""));
+				const writeOffset = offset ?? 0;
+				const writeLength = length ?? buffer.length - writeOffset;
+				const writePosition = position ?? current.position;
+				buffer.copy(content, writePosition, writeOffset, writeOffset + writeLength);
+				await writeStoredFile(key, content);
+				if (position === null || position === void 0) current.position += writeLength;
+				return {
+					bytesWritten: writeLength,
+					buffer
+				};
+			},
+			async writeFile(data, options) {
+				await writeStoredFile(key, typeof data === "string" ? data : encodeWriteValue(data), options);
+			}
+		};
+	}
+	const promises = {
+		async access(path, mode = node_fs.constants.F_OK) {
+			const entry = await getEntry(path, true);
+			if (!entry) throw createFsError("ENOENT", "access", normalizeKey(path));
+			if (mode & node_fs.constants.W_OK && entry.type === "directory") throw createFsError("EISDIR", "access", normalizeKey(path));
+		},
+		async appendFile(path, data, options) {
+			const key = normalizeKey(path);
+			const current = await readStoredFile(key).catch(() => "");
+			await writeStoredFile(key, node_buffer.Buffer.concat([toBuffer(current), toBuffer(typeof data === "string" ? data : encodeWriteValue(data))]), options);
+		},
+		async chmod(path, mode) {
+			const key = normalizeKey(path);
+			await requireEntry(key, true);
+			await storage.setMeta(key, { mode });
+		},
+		async chown(path, uid, gid) {
+			const key = normalizeKey(path);
+			await requireEntry(key, true);
+			await storage.setMeta(key, {
+				uid,
+				gid
+			});
+		},
+		async copyFile(src, dest, _mode) {
+			await copyEntry(normalizeKey(src), normalizeKey(dest), false);
+		},
+		async cp(src, dest, options) {
+			await copyEntry(normalizeKey(src), normalizeKey(dest), Boolean(options?.recursive));
+		},
+		async glob(pattern, options) {
+			const cwd = normalizeKey(options?.cwd ?? ".");
+			const matches = (await storage.getKeys(cwd)).filter((key) => !isMetaStorageKey(key)).filter((key) => matchesGlobPattern(String(pattern), key));
+			async function* iterator() {
+				for (const match of matches) if (options && "withFileTypes" in options && options.withFileTypes) {
+					const entry = await getEntry(match, true);
+					yield {
+						name: basename(match),
+						relative: match.slice(cwd.length).replace(/^\//, ""),
+						absolute: match,
+						isFile: () => entry?.type === "file",
+						isDirectory: () => entry?.type === "directory",
+						isSymbolicLink: () => entry?.type === "symlink"
+					};
+				} else yield match;
+			}
+			return iterator();
+		},
+		async lchmod(path, mode) {
+			await chmodPath(path, mode);
+		},
+		async lchown(path, uid, gid) {
+			await chownPath(path, uid, gid);
+		},
+		async lutimes(path, atime, mtime) {
+			const key = normalizeKey(path);
+			await requireEntry(key, false);
+			await storage.setMeta(key, {
+				atime: new Date(atime),
+				mtime: new Date(mtime)
+			});
+		},
+		async link(existingPath, newPath) {
+			const source = normalizeKey(existingPath);
+			const destination = normalizeKey(newPath);
+			const content = await readStoredFile(source);
+			await writeStoredFile(destination, typeof content === "string" ? content : toBuffer(content));
+		},
+		async lstat(path, _options) {
+			return statPath(path, false);
+		},
+		async mkdir(path, options) {
+			return mkdirPath(path, options);
+		},
+		async mkdtemp(prefix, options) {
+			return mkdtempPath(prefix, options);
+		},
+		async mkdtempDisposable(prefix, options) {
+			const directory = await mkdtempPath(prefix, options);
+			return {
+				path: directory,
+				async [Symbol.asyncDispose]() {
+					await removePath(directory, {
+						recursive: true,
+						force: true
+					});
+				},
+				[Symbol.dispose]() {
+					runSync(async () => removePath(directory, {
+						recursive: true,
+						force: true
+					}));
+				}
+			};
+		},
+		async open(path, _flags, _mode) {
+			const key = normalizeKey(path);
+			await requireEntry(key, true).catch(async (error) => {
+				if (error.code === "ENOENT") {
+					await writeStoredFile(key, "");
+					return;
+				}
+				throw error;
+			});
+			const descriptor = nextDescriptor++;
+			openDescriptors.set(descriptor, {
+				key,
+				position: 0
+			});
+			return createFileHandle(descriptor, key);
+		},
+		async opendir(path, options) {
+			return createDir(path, options);
+		},
+		async readdir(path, options) {
+			const key = normalizeKey(path);
+			await requireEntry(key, true);
+			const keys = await storage.getKeys(key);
+			let children = getImmediateChildren(key, keys.filter((storageKey) => !isMetaStorageKey(storageKey)));
+			if (options && typeof options === "object" && "recursive" in options && options.recursive) children = keys.filter((storageKey) => !isMetaStorageKey(storageKey)).map((storageKey) => storageKey.slice(key.length).replace(/^\//, "")).filter(Boolean);
+			if (options && typeof options === "object" && "withFileTypes" in options && options.withFileTypes) return await Promise.all(children.map(async (name) => {
+				const entry = await getEntry(resolveKey(key, name), true);
+				return {
+					name,
+					isFile: () => entry?.type === "file",
+					isDirectory: () => entry?.type === "directory",
+					isBlockDevice: () => false,
+					isCharacterDevice: () => false,
+					isSymbolicLink: () => entry?.type === "symlink",
+					isFIFO: () => false,
+					isSocket: () => false
+				};
+			}));
+			if (options && typeof options === "object" && "encoding" in options && options.encoding === "buffer") return children.map((name) => node_buffer.Buffer.from(name));
+			return children;
+		},
+		async readFile(path, options) {
+			return readStoredFile(path, options);
+		},
+		async readlink(path, options) {
+			const key = normalizeKey(path);
+			const entry = await requireEntry(key, false);
+			if (entry.type !== "symlink") throw createFsError("EINVAL", "readlink", key);
+			const target = entry.meta?.[SYMLINK_META_KEY];
+			if (typeof target !== "string") throw createFsError("EINVAL", "readlink", key);
+			if (options && typeof options === "object" && options.encoding === "buffer") return node_buffer.Buffer.from(target);
+			return target;
+		},
+		async realpath(path, options) {
+			const resolved = resolveKey(path);
+			if (!await getEntry(resolved, true)) throw createFsError("ENOENT", "realpath", resolved);
+			if (options && typeof options === "object" && options.encoding === "buffer") return node_buffer.Buffer.from(resolved);
+			return resolved;
+		},
+		async rename(oldPath, newPath) {
+			const source = normalizeKey(oldPath);
+			const destination = normalizeKey(newPath);
+			if ((await requireEntry(source, true)).type === "directory") {
+				const keys = await storage.getKeys(source);
+				for (const key of keys) {
+					if (isMetaStorageKey(key)) continue;
+					const relative = key === source ? "" : key.slice(source.length).replace(/^\//, "");
+					const target = relative ? resolveKey(destination, relative) : destination;
+					if (key === source && await storage.hasItem(key)) {
+						const value = await storage.getItem(key);
+						if (value != null) await storage.setItem(target, value);
+					} else if (key !== source) {
+						const value = await storage.getItem(key);
+						if (value != null) await storage.setItem(target, value);
+						const meta = await getMetaSafe(key);
+						if (meta) await storage.setMeta(target, meta);
+						await storage.removeItem(key);
+					}
+				}
+				if (await storage.hasItem(source)) await storage.removeItem(source);
+				return;
+			}
+			const content = await storage.getItem(source);
+			if (content != null) await storage.setItem(destination, content);
+			const meta = await getMetaSafe(source);
+			if (meta) await storage.setMeta(destination, meta);
+			await storage.removeItem(source);
+		},
+		async rm(path, options) {
+			await removePath(path, options);
+		},
+		async rmdir(path, options) {
+			await removePath(path, options);
+		},
+		async stat(path, _options) {
+			return statPath(path);
+		},
+		async statfs(path, _options) {
+			const keys = await storage.getKeys(normalizeKey(path));
+			const stats = Object.create(node_fs.Stats.prototype);
+			Object.assign(stats, {
+				type: 0,
+				bsize: 4096,
+				blocks: keys.length,
+				bfree: 0,
+				bavail: 0,
+				files: keys.length,
+				ffree: 0
+			});
+			return stats;
+		},
+		async symlink(target, path, _type) {
+			const key = normalizeKey(path);
+			await storage.setMeta(key, {
+				[SYMLINK_META_KEY]: normalizeKey(target),
+				mtime: /* @__PURE__ */ new Date(),
+				atime: /* @__PURE__ */ new Date()
+			});
+		},
+		async truncate(path, len = 0) {
+			const key = normalizeKey(path);
+			await writeStoredFile(key, toBuffer(await readStoredFile(key)).subarray(0, len));
+		},
+		async unlink(path) {
+			const key = normalizeKey(path);
+			const entry = await getEntry(key, false);
+			if (!entry) throw createFsError("ENOENT", "unlink", key);
+			if (entry.type === "directory") throw createFsError("EISDIR", "unlink", key);
+			await storage.removeItem(key);
+		},
+		async utimes(path, atime, mtime) {
+			const key = normalizeKey(path);
+			await requireEntry(key, true);
+			await storage.setMeta(key, {
+				atime: new Date(atime),
+				mtime: new Date(mtime)
+			});
+		},
+		async watch(path, options) {
+			const key = normalizeKey(path);
+			const unwatch = await storage.watch((event, watchedKey) => {
+				if (watchedKey === key || watchedKey.startsWith(parentPrefix(key))) (typeof options === "function" ? options : options.listener)?.(event, watchedKey);
+			});
+			return {
+				async close() {
+					await unwatch();
+				},
+				[Symbol.asyncDispose]: async () => {
+					await unwatch();
+				}
+			};
+		},
+		async writeFile(path, data, options) {
+			await writeStoredFile(path, data, options);
+		}
+	};
+	async function openFd(path, flags, mode) {
+		return (await promises.open(path, flags, mode)).fd;
+	}
+	async function closeFd(fd) {
+		if (!openDescriptors.has(fd)) throw createFsError("EBADF", "close");
+		openDescriptors.delete(fd);
+	}
+	async function fstatFd(fd, _options) {
+		const descriptor = openDescriptors.get(fd);
+		if (!descriptor) throw createFsError("EBADF", "fstat");
+		return statPath(descriptor.key);
+	}
+	async function readFd(fd, buffer, offset, length, position) {
+		const descriptor = openDescriptors.get(fd);
+		if (!descriptor) throw createFsError("EBADF", "read");
+		return createFileHandle(fd, descriptor.key).read(buffer, offset, length, position);
+	}
+	async function writeFd(fd, buffer, offset, length, position) {
+		const descriptor = openDescriptors.get(fd);
+		if (!descriptor) throw createFsError("EBADF", "write");
+		return createFileHandle(fd, descriptor.key).write(buffer, offset, length, position);
+	}
+	async function ftruncateFd(fd, len = 0) {
+		const descriptor = openDescriptors.get(fd);
+		if (!descriptor) throw createFsError("EBADF", "ftruncate");
+		await promises.truncate(descriptor.key, len);
+	}
+	async function futimesFd(fd, atime, mtime) {
+		const descriptor = openDescriptors.get(fd);
+		if (!descriptor) throw createFsError("EBADF", "futimes");
+		await promises.utimes(descriptor.key, atime, mtime);
+	}
+	async function readvFd(fd, buffers, position) {
+		let offset = 0;
+		let readPosition = position ?? openDescriptors.get(fd)?.position ?? 0;
+		for (const view of buffers) {
+			const buffer = node_buffer.Buffer.from(view.buffer, view.byteOffset, view.byteLength);
+			const result = await readFd(fd, buffer, 0, buffer.length, readPosition);
+			offset += result.bytesRead;
+			readPosition += result.bytesRead;
+		}
+		return {
+			bytesRead: offset,
+			buffers
+		};
+	}
+	async function writevFd(fd, buffers, position) {
+		const content = node_buffer.Buffer.concat(buffers.map((view) => node_buffer.Buffer.from(view.buffer, view.byteOffset, view.byteLength)));
+		const descriptor = openDescriptors.get(fd);
+		if (!descriptor) throw createFsError("EBADF", "writev");
+		const writePosition = position ?? descriptor.position;
+		const existing = toBuffer(await readStoredFile(descriptor.key).catch(() => ""));
+		content.copy(existing, writePosition);
+		await writeStoredFile(descriptor.key, existing);
+		if (position == null) descriptor.position += content.byteLength;
+		return {
+			bytesWritten: content.byteLength,
+			buffers
+		};
+	}
+	return {
+		promises,
+		createReadStream,
+		createWriteStream,
+		openFd,
+		closeFd,
+		fstatFd,
+		readFd,
+		writeFd,
+		ftruncateFd,
+		futimesFd,
+		readvFd,
+		writevFd
+	};
+}
+
+//#endregion
+//#region src/storage/index.ts
+function bindCallback(fn) {
+	const callback = (0, node_util.callbackify)(fn);
+	callback.__promisify__ = fn;
+	return callback;
+}
+function createNoopAsync() {
+	return async () => void 0;
+}
+function createNoopSync() {
+	return () => void 0;
+}
+function mapStorageToFileSystem(storage) {
+	const core = createStoragePromises(storage);
+	const { promises } = core;
+	const globAsync = async (...args) => {
+		const iterator = promises.glob(...args);
+		const results = [];
+		for await (const entry of iterator) results.push(typeof entry === "string" ? entry : "absolute" in entry ? String(entry.absolute) : String(entry));
+		return results;
+	};
+	const watchEmitter = (path) => {
+		const watcher = new node_events.EventEmitter();
+		storage.watch((event, key) => {
+			const normalized = normalizeKey(path);
+			if (key === normalized || key.startsWith(`${normalized}/`)) watcher.emit("change", event, key);
+		}).then((unwatch) => {
+			watcher.on("close", () => {
+				unwatch();
+			});
+		});
+		return watcher;
+	};
+	return {
+		promises,
+		access: bindCallback(promises.access),
+		appendFile: bindCallback(promises.appendFile),
+		chmod: bindCallback(promises.chmod),
+		chown: bindCallback(promises.chown),
+		close: bindCallback(core.closeFd),
+		copyFile: bindCallback(promises.copyFile),
+		cp: bindCallback(promises.cp),
+		createReadStream: core.createReadStream,
+		createWriteStream: core.createWriteStream,
+		exists: ((path, callback) => {
+			promises.access(path).then(() => callback(true)).catch(() => callback(false));
+		}),
+		fchmod: bindCallback(createNoopAsync()),
+		fchown: bindCallback(createNoopAsync()),
+		fdatasync: bindCallback(createNoopAsync()),
+		fstat: bindCallback(core.fstatFd),
+		fsync: bindCallback(createNoopAsync()),
+		ftruncate: bindCallback(core.ftruncateFd),
+		futimes: bindCallback(core.futimesFd),
+		glob: bindCallback(globAsync),
+		lchmod: bindCallback(promises.lchmod),
+		lchown: bindCallback(promises.lchown),
+		lutimes: bindCallback(promises.lutimes),
+		link: bindCallback(promises.link),
+		lstat: bindCallback(promises.lstat),
+		mkdir: bindCallback(promises.mkdir),
+		mkdtemp: bindCallback(promises.mkdtemp),
+		open: bindCallback(core.openFd),
+		openAsBlob: bindCallback(async (path) => {
+			const content = await promises.readFile(path);
+			return new Blob([content]);
+		}),
+		opendir: bindCallback(promises.opendir),
+		read: bindCallback(core.readFd),
+		readdir: bindCallback(promises.readdir),
+		readFile: bindCallback(promises.readFile),
+		readlink: bindCallback(promises.readlink),
+		readv: bindCallback(core.readvFd),
+		realpath: bindCallback(promises.realpath),
+		rename: bindCallback(promises.rename),
+		rmdir: bindCallback(promises.rmdir),
+		rm: bindCallback(promises.rm),
+		stat: bindCallback(promises.stat),
+		statfs: bindCallback(promises.statfs),
+		symlink: bindCallback(promises.symlink),
+		truncate: bindCallback(promises.truncate),
+		unlink: bindCallback(promises.unlink),
+		unwatchFile: node_fs.unwatchFile,
+		utimes: bindCallback(promises.utimes),
+		watch: ((path, options, listener) => {
+			const watcher = watchEmitter(path);
+			const attachListener = (handler) => {
+				watcher.on("change", handler);
+			};
+			if (typeof options === "function") {
+				attachListener(options);
+				return watcher;
+			}
+			if (typeof listener === "function") attachListener(listener);
+			else if (options && typeof options === "object" && "listener" in options && typeof options.listener === "function") attachListener(options.listener);
+			return watcher;
+		}),
+		watchFile: node_fs.watchFile,
+		write: bindCallback(core.writeFd),
+		writeFile: bindCallback(promises.writeFile),
+		writev: bindCallback(core.writevFd),
+		accessSync: ((path, mode) => runSync(async () => promises.access(path, mode))),
+		appendFileSync: ((path, data, options) => runSync(async () => promises.appendFile(path, data, options))),
+		chmodSync: ((path, mode) => runSync(async () => promises.chmod(path, mode))),
+		chownSync: ((path, uid, gid) => runSync(async () => promises.chown(path, uid, gid))),
+		closeSync: ((fd) => runSync(async () => core.closeFd(fd))),
+		copyFileSync: ((src, dest, mode) => runSync(async () => promises.copyFile(src, dest, mode))),
+		cpSync: ((src, dest, options) => runSync(async () => promises.cp(src, dest, options))),
+		existsSync: ((path) => {
+			try {
+				runSync(async () => promises.access(path));
+				return true;
+			} catch {
+				return false;
+			}
+		}),
+		fchmodSync: createNoopSync(),
+		fchownSync: createNoopSync(),
+		fdatasyncSync: createNoopSync(),
+		fstatSync: ((fd, options) => runSync(async () => core.fstatFd(fd, options))),
+		fsyncSync: createNoopSync(),
+		ftruncateSync: ((fd, len) => runSync(async () => core.ftruncateFd(fd, len))),
+		futimesSync: ((fd, atime, mtime) => runSync(async () => core.futimesFd(fd, atime, mtime))),
+		globSync: ((pattern, options) => runSync(async () => globAsync(pattern, options))),
+		lchmodSync: ((path, mode) => runSync(async () => promises.lchmod(path, mode))),
+		lchownSync: ((path, uid, gid) => runSync(async () => promises.lchown(path, uid, gid))),
+		lutimesSync: ((path, atime, mtime) => runSync(async () => promises.lutimes(path, atime, mtime))),
+		linkSync: ((existingPath, newPath) => runSync(async () => promises.link(existingPath, newPath))),
+		lstatSync: ((path, options) => runSync(async () => promises.lstat(path, options))),
+		mkdirSync: ((path, options) => runSync(async () => promises.mkdir(path, options))),
+		mkdtempSync: ((prefix, options) => runSync(async () => promises.mkdtemp(prefix, options))),
+		openSync: ((path, flags, mode) => runSync(async () => core.openFd(path, flags, mode ?? void 0))),
+		opendirSync: ((path, options) => runSync(async () => promises.opendir(path, options))),
+		readdirSync: ((path, options) => runSync(async () => promises.readdir(path, options))),
+		readFileSync: ((path, options) => runSync(async () => promises.readFile(path, options))),
+		readlinkSync: ((path, options) => runSync(async () => promises.readlink(path, options))),
+		readSync: ((fd, buffer, offset, length, position) => runSync(async () => core.readFd(fd, buffer, offset ?? 0, length ?? buffer.byteLength, position == null ? null : Number(position))).bytesRead),
+		readvSync: ((fd, buffers, position) => runSync(async () => core.readvFd(fd, [...buffers], position)).bytesRead),
+		realpathSync: ((path, options) => runSync(async () => promises.realpath(path, options))),
+		renameSync: ((oldPath, newPath) => runSync(async () => promises.rename(oldPath, newPath))),
+		rmdirSync: ((path) => runSync(async () => promises.rm(path, { recursive: false }))),
+		rmSync: ((path, options) => runSync(async () => promises.rm(path, options))),
+		statSync: ((path, options) => runSync(async () => promises.stat(path, options))),
+		statfsSync: ((path, options) => runSync(async () => promises.statfs(path, options))),
+		symlinkSync: ((target, path, type) => runSync(async () => promises.symlink(target, path, type))),
+		truncateSync: ((path, len) => runSync(async () => promises.truncate(path, len))),
+		unlinkSync: ((path) => runSync(async () => promises.unlink(path))),
+		utimesSync: ((path, atime, mtime) => runSync(async () => promises.utimes(path, atime, mtime))),
+		writeFileSync: ((file, data, options) => runSync(async () => promises.writeFile(file, data, options))),
+		writeSync: ((fd, buffer, offset, length, position) => runSync(async () => core.writeFd(fd, buffer, offset ?? 0, length ?? buffer.byteLength, position == null ? null : Number(position))).bytesWritten),
+		writevSync: ((fd, buffers, position) => runSync(async () => core.writevFd(fd, [...buffers], position)).bytesWritten)
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'createStoragePromises', {
+  enumerable: true,
+  get: function () {
+    return createStoragePromises;
+  }
+});
+Object.defineProperty(exports, 'mapStorageToFileSystem', {
+  enumerable: true,
+  get: function () {
+    return mapStorageToFileSystem;
+  }
+});
+Object.defineProperty(exports, 'normalizeKey', {
+  enumerable: true,
+  get: function () {
+    return normalizeKey;
+  }
+});