@monimesl/dot-simulator 0.1.0-alpha.7 → 0.1.0-alpha.9

package/dist/node/index.js

@@ -1,11 +1,11 @@
 import { createRequire } from "node:module";
-import { HostError, NavigationStack, REACT_HOST_PATH, allowsHost, dotFilePathProblem, isReactCompatible, isVersionAtLeast, majorVersion, newestReactOfMajor } from "@monimesl/dot-core";
+import { HostError, NavigationStack, REACT_HOST_PATH, allowsHost, dotFilePathProblem, isReactCompatible, isVersionAtLeast, newestReactOfMajor } from "@monimesl/dot-core";
 import { appendFile, cp, lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { STATUS_CODES, createServer } from "node:http";
 import { basename, dirname, extname, join, resolve, sep } from "node:path";
 import { TextDecoder } from "node:util";
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 //#region src/compatibility.ts
 var IncompatibleDotError = class extends Error {
 	name = "IncompatibleDotError";
@@ -16,10 +16,10 @@ var IncompatibleDotError = class extends Error {
 	}
 };
 function checkCompatibility(manifest, { dashVersion, minRuntimeVersion, reactVersions }) {
-	if (!isVersionAtLeast(manifest.runtime, minRuntimeVersion)) throw new IncompatibleDotError("runtimeTooOld", `This dot was built with Dot runtime ${manifest.runtime}, but this host runs ${minRuntimeVersion} or newer. Rebuild it with a newer @monimesl/dot-runtime.`);
+	if (!isVersionAtLeast(manifest.runtime, minRuntimeVersion)) throw new IncompatibleDotError("runtimeTooOld", `This dot was built with an old Dot runtime, ${manifest.runtime}. Rebuild it with @monimesl/dot-runtime ${minRuntimeVersion} or newer.`);
 	const minDashVersion = manifest.dash?.minVersion;
-	if (minDashVersion !== void 0 && !isVersionAtLeast(dashVersion, minDashVersion)) throw new IncompatibleDotError("dashTooOld", `This dot needs Dash ${minDashVersion} or newer, and this is Dash ${dashVersion}.`);
-	if (reactVersions !== void 0 && !reactVersions.some((version) => isReactCompatible(version, manifest.react))) throw new IncompatibleDotError("reactUnavailable", `This dot needs React ${manifest.react} or a newer ${majorVersion(manifest.react)}.x, which this host doesn't ship.`);
+	if (minDashVersion !== void 0 && !isVersionAtLeast(dashVersion, minDashVersion)) throw new IncompatibleDotError("dashTooOld", `This dot needs Dash ${minDashVersion} or newer. This is Dash ${dashVersion}.`);
+	if (reactVersions !== void 0 && !reactVersions.some((version) => isReactCompatible(version, manifest.react))) throw new IncompatibleDotError("reactUnavailable", `This dot needs React ${manifest.react}, which this host doesn't have.`);
 }
 //#endregion
 //#region src/host-calls.ts
@@ -41,7 +41,7 @@ var HostCallRunner = class {
 				id,
 				error: {
 					code: "unsupported",
-					message: `This host has no "${method}"`
+					message: `This host doesn't support "${method}"`
 				}
 			});
 			return;
@@ -64,7 +64,7 @@ var HostCallRunner = class {
 		this.#end(id)?.controller.abort();
 	}
 	dismissUI() {
-		for (const [id, call] of this.#running) if (call.method.startsWith(UI_METHOD_PREFIX)) this.#fail(id, new HostError("cancelled", "The page it was shown on is no longer on top"));
+		for (const [id, call] of this.#running) if (call.method.startsWith(UI_METHOD_PREFIX)) this.#fail(id, new HostError("cancelled", "Its page is no longer on screen"));
 	}
 	async #invoke(id, entry, call) {
 		try {
@@ -126,7 +126,7 @@ var PermissionGate = class {
 	}
 	async check(method, permission, signal) {
 		const reason = this.#declared[permission];
-		if (reason === void 0) throw new HostError("denied", `"${method}" needs the "${permission}" permission. Add it to dot.json's permissions, with the reason Dash shows the person.`);
+		if (reason === void 0) throw new HostError("denied", `"${method}" needs the "${permission}" permission. Add it to permissions in dot.json, with a reason to show the person.`);
 		let allowed = this.#answers.get(permission);
 		if (allowed === void 0) {
 			allowed = await this.#ask({
@@ -136,7 +136,7 @@ var PermissionGate = class {
 			}, signal);
 			this.#answers.set(permission, allowed);
 		}
-		if (!allowed) throw new HostError("denied", `The person did not allow "${permission}"`);
+		if (!allowed) throw new HostError("denied", `The person didn't allow "${permission}"`);
 	}
 };
 //#endregion
@@ -286,7 +286,10 @@ const SIMULATOR_VERSIONS = {
 const CLIENT_PATH = "/__dot/";
 const EVENTS_PATH = `${CLIENT_PATH}events`;
 const HTTP_PATH = `${CLIENT_PATH}network/http/`;
-const FILE_PATH = `${CLIENT_PATH}file/`;
+const FILE_PATH = `${CLIENT_PATH}storage/file/`;
+const CACHE_PATH = `${CLIENT_PATH}storage/cache/`;
+const SECRET_PATH = `${CLIENT_PATH}storage/secret/`;
+const TEMPORARY_FILES_PATH = `${CLIENT_PATH}files/`;
 const WEBVIEW_URL = `/dot/ui/index.html`;
 //#endregion
 //#region src/page.ts
@@ -304,14 +307,6 @@ function simulatorPage(appName) {
     <header>
       <strong>${escapeHtml(appName)}</strong>
       <span class="subtle">Dot simulator</span>
-      <select id="platform" aria-label="Target platform">
-        <option value="ios">iOS</option>
-        <option value="android">Android</option>
-      </select>
-      <select id="input-mode" aria-label="Input mode" title="Choose whether the simulator emulates a touch pointer">
-        <option value="touch">Touch</option>
-        <option value="browser">Browser</option>
-      </select>
       <select id="scheme" aria-label="Device appearance">
         <option value="light">Light</option>
         <option value="dark">Dark</option>
@@ -370,14 +365,13 @@ const STYLES = `
   * { box-sizing: border-box; }
   body { margin: 0; height: 100vh; display: flex; flex-direction: column; background: var(--bg); color: var(--text); }
   header { display: flex; align-items: center; gap: 12px; padding: 8px 16px; background: var(--panel); border-bottom: 1px solid var(--border); }
-  #platform { margin-left: auto; }
+  #scheme { margin-left: auto; }
   button, select { font: inherit; color: inherit; background: var(--bg); border: 1px solid var(--border); border-radius: 6px; padding: 4px 10px; cursor: pointer; }
   .subtle { color: var(--subtle); }
   main { flex: 1; display: flex; min-height: 0; }
   .stage { flex: 1; overflow: auto; display: flex; flex-direction: column; align-items: center; gap: 12px; padding: 24px 16px; }
-  .phone { flex: none; position: relative; display: flex; flex-direction: column; width: 393px; height: 852px; box-sizing: content-box; border: 12px solid #0b0b0c; border-radius: 67px; overflow: hidden; background: var(--screen); box-shadow: 0 0 0 2px #3a3a3c, 0 18px 50px rgb(0 0 0 / 0.3); --screen: #f2f2f2; --screen-text: #000; }
+  .phone { flex: none; position: relative; display: flex; flex-direction: column; width: 393px; height: 852px; box-sizing: content-box; border: 12px solid #0b0b0c; border-radius: 67px; overflow: hidden; background: var(--screen); box-shadow: 0 0 0 2px #3a3a3c, 0 18px 50px rgb(0 0 0 / 0.3); --screen: #f2f2f2; --screen-text: #000; --dialog: #f7f7f7; --dialog-line: #d1d1d6; }
   .phone[data-scheme="dark"] { --screen: #121212; --screen-text: #fff; --dialog: #2c2c2e; --dialog-line: #48484a; }
-  .phone { --dialog: #f7f7f7; --dialog-line: #d1d1d6; }
   .torch { display: none; }
   .phone[data-torch="on"] .torch { display: block; }
   .dialog-layer { position: absolute; inset: 0; z-index: 1; display: flex; align-items: center; justify-content: center; background: rgb(0 0 0 / 0.3); }
@@ -450,6 +444,7 @@ function contentTypeFor(name) {
 //#region src/network.ts
 const MAX_RESPONSE_BYTES = 5 * MEGABYTE;
 const MAX_DOWNLOAD_BYTES = 100 * MEGABYTE;
+const MAX_REDIRECTS = 10;
 const METHODS = [
 	"GET",
 	"POST",
@@ -481,13 +476,18 @@ const HOST_HEADERS = [
 	"upgrade"
 ];
 const CONTENT_TYPE = /^[\w.+-]+\/[\w.+*-]+\s*(;.*)?$/;
+function runHttpCall(call, params, hosts, files, signal) {
+	if (call === "download") return downloadHttpFile(params, hosts, files, signal);
+	if (call === "upload") return uploadHttpFiles(params, hosts, files, signal);
+	return sendHttpRequest(params, hosts, signal);
+}
 async function sendHttpRequest(request, hosts, signal) {
-	return exchange(textRequest(request), hosts, signal, async (response) => result(response, await readBody(response)));
+	return exchange(textRequest(request), hosts, signal, readResponse);
 }
 async function downloadHttpFile(request, hosts, files, signal) {
 	return exchange(textRequest(request), hosts, signal, async (response) => {
 		if (!response.ok) return {
-			...result(response, await readBody(response)),
+			...await readResponse(response),
 			ok: false
 		};
 		const file = await save$1(response, request.name, files);
@@ -502,7 +502,7 @@ async function downloadHttpFile(request, hosts, files, signal) {
 	});
 }
 async function uploadHttpFiles(request, hosts, files, signal) {
-	if (request.files.length === 0) throw invalid("An upload needs at least one file; send text with http.request");
+	if (request.files.length === 0) throw invalid("An upload needs at least one file. To send only text, use http.request");
 	const parts = request.files.map((upload) => {
 		if (!upload.field.trim()) throw invalid("Each file needs a field name");
 		const file = files.requireFile(upload.file);
@@ -529,19 +529,19 @@ async function uploadHttpFiles(request, hosts, files, signal) {
 			kind: "form",
 			form: makeForm
 		}
-	}, hosts, signal, async (response) => result(response, await readBody(response)));
+	}, hosts, signal, readResponse);
 }
 async function exchange(request, hosts, signal, read) {
 	let outgoing = request;
-	for (let redirects = 0; redirects <= 10; redirects++) {
-		if (!allowsHost(hosts, outgoing.url.hostname)) throw new HostError("denied", `"${outgoing.url.hostname}" is not in dot.json's network.hosts. List every host the dot sends requests to there.`);
+	for (let redirects = 0; redirects <= MAX_REDIRECTS; redirects++) {
+		if (!allowsHost(hosts, outgoing.url.hostname)) throw new HostError("denied", `"${outgoing.url.hostname}" isn't in network.hosts in dot.json. Add it there to send requests to it.`);
 		const response = await send$1(outgoing, signal);
 		const location = response.headers.get("location");
 		if (!REDIRECT_STATUSES.includes(response.status) || location === null) return read(response);
 		await response.body?.cancel();
 		outgoing = redirected(outgoing, location, response.status);
 	}
-	throw new HostError("failed", `"${request.url.href}" redirected more than 10 times`);
+	throw new HostError("failed", `"${request.url.href}" redirected more than ${MAX_REDIRECTS} times`);
 }
 function textRequest(request) {
 	const method = parseMethod(request.method ?? "GET", METHODS);
@@ -601,7 +601,7 @@ async function send$1(request, signal) {
 }
 function redirected(request, location, status) {
 	const url = URL.parse(location, request.url.href);
-	if (!url || url.protocol !== "http:" && url.protocol !== "https:") throw new HostError("failed", `${request.url.hostname} redirected to "${location}", which is not an http(s) URL`);
+	if (!url || url.protocol !== "http:" && url.protocol !== "https:") throw new HostError("failed", `${request.url.hostname} redirected to "${location}", which isn't a web address`);
 	const becomesGet = status === 303 && request.method !== "HEAD" || (status === 301 || status === 302) && request.method === "POST";
 	const headers = new Headers(request.headers);
 	if (url.origin !== request.url.origin) headers.delete("authorization");
@@ -621,6 +621,9 @@ function result(response, body) {
 		body
 	};
 }
+async function readResponse(response) {
+	return result(response, await readBody(response));
+}
 async function readBody(response) {
 	const chunks = [];
 	await readChunks(response, MAX_RESPONSE_BYTES, (chunk) => {
@@ -705,7 +708,7 @@ function parseUrl(text) {
 }
 function parseMethod(name, methods) {
 	const method = name.toUpperCase();
-	if (!methods.includes(method)) throw invalid(`"${name}" is not an HTTP method here: use ${methods.join(", ")}`);
+	if (!methods.includes(method)) throw invalid(`"${name}" is not an HTTP method. Use ${methods.join(", ")}`);
 	return method;
 }
 function invalid(message) {
@@ -715,15 +718,291 @@ function tooLarge(limit) {
 	return new HostError("failed", `The response is larger than ${megabytes(limit)} MB`);
 }
 //#endregion
+//#region src/serial.ts
+var Serial = class {
+	#queue = Promise.resolve();
+	run(work) {
+		const result = this.#queue.then(work);
+		this.#queue = result.catch(() => void 0);
+		return result;
+	}
+};
+//#endregion
+//#region src/cache.ts
+const DEFAULT_LIMIT = 64 * MEGABYTE;
+const MAX_ENTRY_BYTES = MEGABYTE;
+const MAX_KEY_LENGTH = 512;
+const PARTIAL = ".partial";
+var DotCache = class {
+	root;
+	limit;
+	#now;
+	#lock = new Serial();
+	#index = null;
+	#used = 0;
+	constructor(root, limit = DEFAULT_LIMIT, now = Date.now) {
+		this.root = root;
+		this.limit = limit;
+		this.#now = now;
+	}
+	get(key) {
+		return this.#lock.run(async () => await this.#live(key) ? this.#readValue(key) : null);
+	}
+	exists(key) {
+		return this.#lock.run(async () => await this.#live(key) !== null);
+	}
+	set(key, value, ttl) {
+		return this.#lock.run(async () => {
+			checkKey(key);
+			if (value === null) throw new HostError("invalid", `"${key}" needs a value. To delete it, use remove`);
+			const entry = {
+				key,
+				value
+			};
+			if (ttl !== void 0 && ttl > 0) entry.expiresAt = this.#now() + Math.trunc(ttl * 1e3);
+			const bytes = Buffer.from(JSON.stringify(entry));
+			if (bytes.length > MAX_ENTRY_BYTES) throw new HostError("invalid", `"${key}" is ${megabytes(bytes.length)} MB. A cache value can be at most ${megabytes(MAX_ENTRY_BYTES)} MB`);
+			const index = await this.#loadIndex();
+			const addedBytes = bytes.length - (index.get(key)?.size ?? 0);
+			if (this.#used + addedBytes > this.limit) {
+				await this.#dropExpired();
+				if (this.#used + addedBytes > this.limit) throw new HostError("failed", `The cache is full: ${megabytes(this.#used)} of ${megabytes(this.limit)} MB used`);
+			}
+			await mkdir(this.root, { recursive: true });
+			const file = this.#fileFor(key);
+			await writeFile(`${file}${PARTIAL}`, bytes);
+			await rename(`${file}${PARTIAL}`, file);
+			this.#remember(index, key, {
+				size: bytes.length,
+				expiresAt: entry.expiresAt
+			});
+		});
+	}
+	remove(key) {
+		return this.#lock.run(async () => {
+			checkKey(key);
+			await this.#forget(key);
+		});
+	}
+	keys() {
+		return this.#lock.run(async () => {
+			await this.#dropExpired();
+			return [...(await this.#loadIndex()).keys()].sort();
+		});
+	}
+	clear() {
+		return this.#lock.run(async () => {
+			await rm(this.root, {
+				recursive: true,
+				force: true
+			});
+			this.#index = /* @__PURE__ */ new Map();
+			this.#used = 0;
+		});
+	}
+	tidy() {
+		return this.#lock.run(async () => {
+			this.#index = null;
+			await this.#loadIndex();
+		});
+	}
+	usage() {
+		return this.#lock.run(async () => {
+			await this.#loadIndex();
+			return this.#used;
+		});
+	}
+	async #loadIndex() {
+		if (this.#index) return this.#index;
+		const index = /* @__PURE__ */ new Map();
+		this.#index = index;
+		this.#used = 0;
+		for (const name of await readdir(this.root).catch(() => [])) {
+			const file = join(this.root, name);
+			const entry = name.endsWith(PARTIAL) ? null : await entryAt(file);
+			if (!entry || this.#expired(entry.expiresAt)) {
+				await rm(file, { force: true });
+				continue;
+			}
+			this.#remember(index, entry.key, {
+				size: (await stat(file)).size,
+				expiresAt: entry.expiresAt
+			});
+		}
+		return index;
+	}
+	async #live(key) {
+		checkKey(key);
+		const indexed = (await this.#loadIndex()).get(key);
+		if (!indexed) return null;
+		if (this.#expired(indexed.expiresAt)) {
+			await this.#forget(key);
+			return null;
+		}
+		return indexed;
+	}
+	async #readValue(key) {
+		const entry = await entryAt(this.#fileFor(key));
+		if (!entry) await this.#forget(key);
+		return entry?.value ?? null;
+	}
+	#remember(index, key, indexed) {
+		this.#used += indexed.size - (index.get(key)?.size ?? 0);
+		index.set(key, indexed);
+	}
+	async #forget(key) {
+		await rm(this.#fileFor(key), { force: true });
+		const index = await this.#loadIndex();
+		this.#used -= index.get(key)?.size ?? 0;
+		index.delete(key);
+	}
+	async #dropExpired() {
+		for (const [key, indexed] of await this.#loadIndex()) if (this.#expired(indexed.expiresAt)) await this.#forget(key);
+	}
+	#expired(expiresAt) {
+		return expiresAt !== void 0 && expiresAt <= this.#now();
+	}
+	#fileFor(key) {
+		return join(this.root, `${createHash("sha256").update(key).digest("hex")}.json`);
+	}
+};
+function runCacheCall(operation, params, cache) {
+	switch (operation) {
+		case "get": return cache.get(params.key);
+		case "set": {
+			const { key, value, ttl } = params;
+			return cache.set(key, value ?? null, ttl);
+		}
+		case "remove": return cache.remove(params.key);
+		case "exists": return cache.exists(params.key);
+		case "keys": return cache.keys();
+		case "clear": return cache.clear();
+		default: return Promise.reject(new HostError("unsupported", `This host doesn't support "dash.storage.cache.${operation}"`));
+	}
+}
+async function entryAt(file) {
+	if (!file.endsWith(".json")) return null;
+	try {
+		return JSON.parse(await readFile(file, "utf8"));
+	} catch {
+		return null;
+	}
+}
+function checkKey(key) {
+	if (key === "") throw new HostError("invalid", "A key is needed");
+	if (key.length > MAX_KEY_LENGTH) throw new HostError("invalid", `"${key.slice(0, 40)}…" is longer than ${MAX_KEY_LENGTH} characters`);
+}
+//#endregion
+//#region src/secrets.ts
+const MAX_ENTRIES = 8;
+const MAX_VALUE_BYTES = 4096;
+var DotSecrets = class {
+	file;
+	#partial;
+	#lock = new Serial();
+	constructor(file) {
+		this.file = file;
+		this.#partial = `${file}.partial`;
+	}
+	get(key) {
+		return this.#lock.run(async () => {
+			checkKey(key);
+			return (await this.#read()).get(key) ?? null;
+		});
+	}
+	set(key, value) {
+		return this.#lock.run(async () => {
+			checkKey(key);
+			if (typeof value !== "string") throw new HostError("invalid", `"${key}" needs a text value`);
+			if (Buffer.byteLength(value) > MAX_VALUE_BYTES) throw new HostError("invalid", `"${key}" is too long: a secret can be at most 4 KB`);
+			const entries = await this.#read();
+			if (!entries.has(key) && entries.size >= MAX_ENTRIES) throw new HostError("failed", `A dot can only write a maximum of ${MAX_ENTRIES} secrets. Remove one first`);
+			await this.#write(entries.set(key, value));
+		});
+	}
+	remove(key) {
+		return this.#lock.run(async () => {
+			checkKey(key);
+			const entries = await this.#read();
+			if (entries.delete(key)) await this.#write(entries);
+		});
+	}
+	clear() {
+		return this.#lock.run(() => this.#write(/* @__PURE__ */ new Map()));
+	}
+	tidy() {
+		return this.#lock.run(() => rm(this.#partial, { force: true }));
+	}
+	async #read() {
+		try {
+			return new Map(Object.entries(JSON.parse(await readFile(this.file, "utf8"))));
+		} catch {
+			return /* @__PURE__ */ new Map();
+		}
+	}
+	async #write(entries) {
+		if (entries.size === 0) {
+			await rm(this.file, { force: true });
+			return;
+		}
+		await mkdir(dirname(this.file), { recursive: true });
+		await writeFile(this.#partial, JSON.stringify(Object.fromEntries(entries)));
+		await rename(this.#partial, this.file);
+	}
+};
+function runSecretCall(operation, params, secrets) {
+	switch (operation) {
+		case "get": return secrets.get(params.key);
+		case "set": {
+			const { key, value } = params;
+			return secrets.set(key, value);
+		}
+		case "remove": return secrets.remove(params.key);
+		case "clear": return secrets.clear();
+		default: return Promise.reject(new HostError("unsupported", `This host doesn't support "dash.storage.secret.${operation}"`));
+	}
+}
+//#endregion
 //#region src/files.ts
-const DEFAULT_QUOTA = 100 * MEGABYTE;
+const DEFAULT_QUOTA = 256 * MEGABYTE;
+const CACHE_FOLDER = ".cache";
+const SECRETS_FOLDER = ".secrets";
+const STAGING_FOLDER = ".staging";
 const MAX_READ_BYTES = 5 * MEGABYTE;
 var DotStorage = class {
 	#root;
+	#staging;
 	quota;
+	cache;
+	secrets;
+	lock = new Serial();
 	constructor(root, quota = DEFAULT_QUOTA) {
 		this.#root = root;
+		this.#staging = join(dirname(root), STAGING_FOLDER, basename(root));
 		this.quota = quota;
+		this.cache = new DotCache(join(dirname(root), CACHE_FOLDER, basename(root)));
+		this.secrets = new DotSecrets(join(dirname(root), SECRETS_FOLDER, `${basename(root)}.json`));
+	}
+	async tidy() {
+		await rm(this.#staging, {
+			recursive: true,
+			force: true
+		});
+		await this.cache.tidy();
+		await this.secrets.tidy();
+	}
+	async replace(target, write) {
+		await mkdir(this.#staging, { recursive: true });
+		const staged = join(this.#staging, randomUUID());
+		try {
+			await write(staged);
+			await moveInto(staged, target);
+		} finally {
+			await rm(staged, {
+				recursive: true,
+				force: true
+			});
+		}
 	}
 	async resolve(path, { allowRoot = false } = {}) {
 		const problem = dotFilePathProblem(path, { allowRoot });
@@ -735,12 +1014,6 @@ var DotStorage = class {
 	async usage() {
 		return sizeOf(this.#root);
 	}
-	async clear() {
-		await rm(this.#root, {
-			recursive: true,
-			force: true
-		});
-	}
 	async ensureRoot() {
 		await mkdir(this.#root, { recursive: true });
 	}
@@ -750,53 +1023,54 @@ var DotStorage = class {
 		let existing = path;
 		while (!await exists(existing)) existing = dirname(existing);
 		const real = await realpath(existing);
-		if (real !== realRoot && !real.startsWith(`${realRoot}/`)) throw new HostError("denied", "That path leads outside the dot's storage");
+		if (real !== realRoot && !real.startsWith(`${realRoot}/`)) throw new HostError("denied", "That path goes outside the dot's folder");
 	}
 };
 async function runFileCall(operation, params, storage, temporaryFiles) {
-	switch (operation) {
-		case "read": return read(params, storage);
-		case "write": return write(params, storage);
-		case "stat": {
-			const { path } = params;
-			return entry(path, await storage.resolve(path, { allowRoot: true }));
+	return storage.lock.run(async () => {
+		switch (operation) {
+			case "read": return read(params, storage);
+			case "write": return write(params, storage);
+			case "stat": {
+				const { path } = params;
+				return entry(path, await storage.resolve(path, { allowRoot: true }));
+			}
+			case "list": return list(params, storage);
+			case "createFolder": return createFolder(params.path, storage);
+			case "move": return transfer(params, storage, false);
+			case "copy": return transfer(params, storage, true);
+			case "remove": return remove(params, storage);
+			case "save": return save(params, storage, temporaryFiles);
+			case "open": return open$1(params.path, storage, temporaryFiles);
+			case "usage": return {
+				used: await storage.usage(),
+				quota: storage.quota
+			};
+			default: throw new HostError("unsupported", `This host doesn't support "dash.storage.file.${operation}"`);
 		}
-		case "list": return list(params, storage);
-		case "createFolder": return createFolder(params.path, storage);
-		case "move": return transfer(params, storage, false);
-		case "copy": return transfer(params, storage, true);
-		case "remove": return remove(params, storage);
-		case "save": return save(params, storage, temporaryFiles);
-		case "open": return open$1(params.path, storage, temporaryFiles);
-		case "usage": return {
-			used: await storage.usage(),
-			quota: storage.quota
-		};
-		default: throw new HostError("unsupported", `This host has no "dash.file.${operation}"`);
-	}
+	});
 }
 async function read({ path, as }, storage) {
-	const encoding = parseEncoding(as);
+	const encoding = bufferEncoding(as);
 	const file = await storage.resolve(path);
 	const info = await statOrNull(file);
 	if (!info) throw failed(`There is no file at "${path}"`);
 	if (info.isDirectory()) throw failed(`"${path}" is a folder`);
 	if (info.size > MAX_READ_BYTES) throw failed(`"${path}" is larger than ${megabytes(MAX_READ_BYTES)} MB, too large to read at once`);
-	const bytes = await readFile(file);
-	return encoding === "base64" ? bytes.toString("base64") : bytes.toString("utf8");
+	return (await readFile(file)).toString(encoding);
 }
 async function write({ path, data, as, append = false }, storage) {
-	const encoding = parseEncoding(as);
+	const encoding = bufferEncoding(as);
 	const file = await storage.resolve(path);
 	const existing = await statOrNull(file);
 	if (existing?.isDirectory()) throw failed(`"${path}" is a folder`);
 	if (encoding === "base64" && !/^[A-Za-z0-9+/]*={0,2}$/.test(data)) throw new HostError("invalid", "The data isn't base64");
-	const bytes = Buffer.from(data, encoding === "base64" ? "base64" : "utf8");
+	const bytes = Buffer.from(data, encoding);
 	const replacedBytes = append ? 0 : existing?.size ?? 0;
 	await checkQuota(storage, bytes.length - replacedBytes);
 	await createParent(storage, file, path);
 	if (append) await appendFile(file, bytes);
-	else await writeFile(file, bytes);
+	else await storage.replace(file, (staged) => writeFile(staged, bytes));
 	return written(path, file);
 }
 async function list({ path, recursive = false }, storage) {
@@ -822,17 +1096,17 @@ async function transfer({ from, to, overwrite = false }, storage, keepSource) {
 	const source = await storage.resolve(from);
 	const target = await storage.resolve(to);
 	if (!await exists(source)) throw failed(`There is nothing at "${from}"`);
-	if (to === from || to.startsWith(`${from}/`)) throw new HostError("invalid", `"${to}" is inside "${from}"`);
+	if (to === from || to.startsWith(`${from}/`)) throw new HostError("invalid", `Can't put "${from}" inside itself, at "${to}"`);
 	await makeRoom(storage, target, to, overwrite, keepSource ? await sizeOf(source) : 0);
-	if (keepSource) await cp(source, target, { recursive: true });
-	else await rename(source, target);
+	if (keepSource) await storage.replace(target, (staged) => cp(source, staged, { recursive: true }));
+	else await moveInto(source, target);
 	return written(to, target);
 }
 async function remove({ path, recursive = false }, storage) {
 	const target = await storage.resolve(path);
 	const info = await statOrNull(target);
 	if (!info) return;
-	if (info.isDirectory() && !recursive && (await readdir(target)).length > 0) throw failed(`"${path}" is a folder with files in it: pass { recursive: true } to remove them too`);
+	if (info.isDirectory() && !recursive && (await readdir(target)).length > 0) throw failed(`"${path}" is a folder with files in it. To remove them too, pass { recursive: true }`);
 	await rm(target, {
 		recursive: true,
 		force: true
@@ -842,7 +1116,7 @@ async function save({ file: id, path, overwrite = false }, storage, temporaryFil
 	const file = temporaryFiles.requireFile(id);
 	const target = await storage.resolve(path);
 	await makeRoom(storage, target, path, overwrite, file.size);
-	await cp(file.path, target);
+	await storage.replace(target, (staged) => cp(file.path, staged));
 	return written(path, target);
 }
 async function open$1(path, storage, temporaryFiles) {
@@ -888,24 +1162,28 @@ async function written(path, file) {
 	return found;
 }
 async function makeRoom(storage, target, path, overwrite, addedBytes) {
-	if (await exists(target) && !overwrite) throw failed(`"${path}" already exists: pass { overwrite: true } to replace it`);
+	if (await exists(target) && !overwrite) throw failed(`"${path}" already exists. To replace it, pass { overwrite: true }`);
 	await checkQuota(storage, addedBytes - await sizeOf(target));
-	await rm(target, {
+	await createParent(storage, target, path);
+}
+async function moveInto(from, target) {
+	const targetInfo = await statOrNull(target);
+	if (targetInfo && (targetInfo.isDirectory() || (await statOrNull(from))?.isDirectory())) await rm(target, {
 		recursive: true,
 		force: true
 	});
-	await createParent(storage, target, path);
+	await rename(from, target);
 }
 async function createParent(storage, file, path) {
 	await storage.ensureRoot();
 	const parent = dirname(file);
-	if ((await statOrNull(parent))?.isFile()) throw failed(`A folder in "${path}" is a file`);
+	if ((await statOrNull(parent))?.isFile()) throw failed(`Part of "${path}" is a file, not a folder`);
 	await mkdir(parent, { recursive: true });
 }
 async function checkQuota(storage, addedBytes) {
 	if (addedBytes <= 0) return;
 	const used = await storage.usage();
-	if (used + addedBytes > storage.quota) throw failed(`The dot's storage is full: it uses ${megabytes(used)} of ${megabytes(storage.quota)} MB, and this needs ${megabytes(addedBytes)} MB more`);
+	if (used + addedBytes > storage.quota) throw failed(`The dot's folder is full: ${megabytes(used)} of ${megabytes(storage.quota)} MB used, and this needs ${megabytes(addedBytes)} MB more`);
 }
 async function sizeOf(path) {
 	const info = await lstat(path).catch(() => null);
@@ -921,16 +1199,16 @@ async function exists(path) {
 async function statOrNull(path) {
 	return stat(path).catch(() => null);
 }
-function parseEncoding(name) {
-	if (name === void 0 || name === "text" || name === "base64") return name ?? "text";
-	throw new HostError("invalid", `"${String(name)}" is not an encoding: use "text" or "base64"`);
+function bufferEncoding(name) {
+	if (name === void 0 || name === "text") return "utf8";
+	if (name === "base64") return "base64";
+	throw new HostError("invalid", `"${String(name)}" is not an encoding. Use "text" or "base64"`);
 }
 function failed(message) {
 	return new HostError("failed", message);
 }
 //#endregion
 //#region src/temporary-files.ts
-const TEMPORARY_FILES_PATH = "/__dot/files/";
 var TemporaryFiles = class {
 	#directory;
 	#files = /* @__PURE__ */ new Map();
@@ -942,7 +1220,7 @@ var TemporaryFiles = class {
 	}
 	requireFile(id) {
 		const file = this.#files.get(id);
-		if (!file) throw new HostError("invalid", `"${id}" is not a file this dot has`);
+		if (!file) throw new HostError("invalid", `"${id}" isn't one of this dot's files`);
 		return file;
 	}
 	async clear() {
@@ -1008,6 +1286,7 @@ async function startSimulator({ dotDir, reactHostDir, name = "Dot", port = DEFAU
 	const clients = /* @__PURE__ */ new Set();
 	const files = new TemporaryFiles(await mkdtemp(join(tmpdir(), "dot-simulator-files-")));
 	const storage = new DotStorage(storageDir ?? await mkdtemp(join(tmpdir(), "dot-simulator-storage-")));
+	await storage.tidy();
 	let buildError = null;
 	const broadcast = (event, data = "") => {
 		for (const client of clients) client.write(serverEvent(event, data));
@@ -1035,7 +1314,8 @@ async function startSimulator({ dotDir, reactHostDir, name = "Dot", port = DEFAU
 			return;
 		}
 		if (pathname.startsWith(HTTP_PATH) && request.method === "POST") {
-			relayHttpCall(request, response, pathname.slice(HTTP_PATH.length), dotDir, files);
+			const call = pathname.slice(HTTP_PATH.length);
+			answer(request, response, async (params, signal) => runHttpCall(call, params, await networkHosts(dotDir), files, signal));
 			return;
 		}
 		if (pathname.startsWith(FILE_PATH) && request.method === "POST") {
@@ -1043,8 +1323,18 @@ async function startSimulator({ dotDir, reactHostDir, name = "Dot", port = DEFAU
 			answer(request, response, (params) => runFileCall(operation, params, storage, files));
 			return;
 		}
-		if (pathname.startsWith("/__dot/files/")) {
-			serveTemporaryFile(response, files, pathname.slice(13));
+		if (pathname.startsWith(CACHE_PATH) && request.method === "POST") {
+			const operation = pathname.slice(CACHE_PATH.length);
+			answer(request, response, (params) => runCacheCall(operation, params, storage.cache));
+			return;
+		}
+		if (pathname.startsWith(SECRET_PATH) && request.method === "POST") {
+			const operation = pathname.slice(SECRET_PATH.length);
+			answer(request, response, (params) => runSecretCall(operation, params, storage.secrets));
+			return;
+		}
+		if (pathname.startsWith(TEMPORARY_FILES_PATH)) {
+			serveTemporaryFile(response, files, pathname.slice(TEMPORARY_FILES_PATH.length));
 			return;
 		}
 		if (pathname.startsWith(REACT_HOST_PATH) && reactHostDir !== void 0) {
@@ -1060,7 +1350,7 @@ async function startSimulator({ dotDir, reactHostDir, name = "Dot", port = DEFAU
 			serveFile(response, dotDir, pathname.slice(5), injectBridge);
 			return;
 		}
-		send(response, 404, "Not found");
+		notFound(response);
 	});
 	await listen(server, port, host);
 	return {
@@ -1078,20 +1368,15 @@ async function startSimulator({ dotDir, reactHostDir, name = "Dot", port = DEFAU
 			buildError = message;
 			broadcast("build-error", message);
 		},
-		close: () => new Promise((resolvePromise) => {
+		close: async () => {
 			for (const client of clients) client.end();
-			server.close(() => void files.clear().then(() => resolvePromise()));
-		})
+			await new Promise((resolvePromise) => {
+				server.close(() => resolvePromise());
+			});
+			await files.clear();
+		}
 	};
 }
-function relayHttpCall(request, response, call, dotDir, files) {
-	return answer(request, response, async (params, signal) => {
-		const hosts = await networkHosts(dotDir);
-		if (call === "download") return downloadHttpFile(params, hosts, files, signal);
-		if (call === "upload") return uploadHttpFiles(params, hosts, files, signal);
-		return sendHttpRequest(params, hosts, signal);
-	});
-}
 async function answer(request, response, run) {
 	const controller = new AbortController();
 	response.on("close", () => controller.abort());
@@ -1112,7 +1397,7 @@ async function answer(request, response, run) {
 async function serveTemporaryFile(response, files, id) {
 	const file = files.file(id);
 	if (!file) {
-		send(response, 404, "Not found");
+		notFound(response);
 		return;
 	}
 	response.writeHead(200, {
@@ -1147,7 +1432,7 @@ async function serveReact(response, reactHostDir, path) {
 	const versions = await readdir(reactHostDir).catch(() => []);
 	const version = newestReactOfMajor(versions, Number(major));
 	if (version === void 0) {
-		send(response, 404, "Not found");
+		notFound(response);
 		return;
 	}
 	await serveFile(response, join(reactHostDir, version), file.join("/"));
@@ -1156,7 +1441,7 @@ async function serveFile(response, root, path, injectBridge = false) {
 	const base = resolve(root);
 	let file = resolve(base, decodeURIComponent(path));
 	if (file !== base && !file.startsWith(base + sep)) {
-		send(response, 404, "Not found");
+		notFound(response);
 		return;
 	}
 	try {
@@ -1169,7 +1454,7 @@ async function serveFile(response, root, path, injectBridge = false) {
 		const bridge = `<script src="${CLIENT_PATH}webview-bridge.js"><\/script>`;
 		send(response, 200, body.toString("utf8").replace("<head>", `<head>\n    ${bridge}`), ".html");
 	} catch {
-		send(response, 404, "Not found");
+		notFound(response);
 	}
 }
 function send(response, status, body, extension = ".txt") {
@@ -1179,6 +1464,9 @@ function send(response, status, body, extension = ".txt") {
 	});
 	response.end(body);
 }
+function notFound(response) {
+	send(response, 404, "Not found");
+}
 function defaultClientDir() {
 	const manifest = createRequire(import.meta.url).resolve("@monimesl/dot-simulator/package.json");
 	return join(dirname(manifest), "dist/client");