@monimesl/dot-simulator 0.1.0-alpha.10

package/dist/node/index.js

@@ -0,0 +1,1477 @@
+import { createRequire } from "node:module";
+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 { createHash, randomBytes, randomUUID } from "node:crypto";
+//#region src/compatibility.ts
+var IncompatibleDotError = class extends Error {
+	name = "IncompatibleDotError";
+	reason;
+	constructor(reason, message) {
+		super(message);
+		this.reason = reason;
+	}
+};
+function checkCompatibility(manifest, { dashVersion, minRuntimeVersion, reactVersions }) {
+	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. 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
+const UI_METHOD_PREFIX = "dash.ui.";
+var HostCallRunner = class {
+	#handlers;
+	#permissions;
+	#answer;
+	#running = /* @__PURE__ */ new Map();
+	constructor(handlers, permissions, answer) {
+		this.#handlers = handlers;
+		this.#permissions = permissions;
+		this.#answer = answer;
+	}
+	run({ id, method, params, timeout }) {
+		const entry = this.#handlers[method];
+		if (!entry) {
+			this.#answer({
+				id,
+				error: {
+					code: "unsupported",
+					message: `This host doesn't support "${method}"`
+				}
+			});
+			return;
+		}
+		const call = {
+			method,
+			controller: new AbortController()
+		};
+		if (timeout !== void 0) call.timer = setTimeout(() => {
+			this.#fail(id, new HostError("timeout", `"${method}" took longer than ${timeout}ms`));
+		}, timeout);
+		this.#running.set(id, call);
+		this.#invoke(id, entry, {
+			method,
+			params,
+			signal: call.controller.signal
+		});
+	}
+	cancel(id) {
+		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 that showed this dialog is no longer on screen"));
+	}
+	async #invoke(id, entry, call) {
+		try {
+			if (typeof entry === "function") {
+				this.#succeed(id, await entry(call));
+				return;
+			}
+			await this.#permissions.check(call.method, entry.permission, call.signal);
+			this.#succeed(id, await entry.handle(call));
+		} catch (error) {
+			this.#fail(id, error);
+		}
+	}
+	#succeed(id, value) {
+		if (this.#end(id)) this.#answer({
+			id,
+			value
+		});
+	}
+	#fail(id, error) {
+		const call = this.#end(id);
+		if (!call) return;
+		call.controller.abort();
+		this.#answer({
+			id,
+			error: describeError(error)
+		});
+	}
+	#end(id) {
+		const call = this.#running.get(id);
+		if (call) {
+			this.#running.delete(id);
+			clearTimeout(call.timer);
+		}
+		return call;
+	}
+};
+function describeError(error) {
+	if (error instanceof HostError) return {
+		code: error.code,
+		message: error.message
+	};
+	return {
+		code: "failed",
+		message: error instanceof Error ? error.message : String(error)
+	};
+}
+//#endregion
+//#region src/permissions.ts
+var PermissionGate = class {
+	#dotName;
+	#declared;
+	#ask;
+	#answers = /* @__PURE__ */ new Map();
+	constructor(dotName, declared, ask) {
+		this.#dotName = dotName;
+		this.#declared = declared;
+		this.#ask = ask;
+	}
+	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 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({
+				dotName: this.#dotName,
+				permission,
+				reason
+			}, signal);
+			this.#answers.set(permission, allowed);
+		}
+		if (!allowed) throw new HostError("denied", `The person didn't allow the "${permission}" permission`);
+	}
+};
+//#endregion
+//#region src/host.ts
+function startHost({ logic, ui, manifest, dashVersion, minRuntimeVersion, systemContext, handlers = {}, askPermission, observe, restorePages = [], onBarsChange }) {
+	checkCompatibility(manifest, {
+		dashVersion,
+		minRuntimeVersion
+	});
+	const stack = new NavigationStack();
+	let context = systemContext;
+	const calls = new HostCallRunner(handlers, new PermissionGate(manifest.name, manifest.permissions ?? {}, askPermission), (result) => {
+		const message = {
+			type: "hostResult",
+			payload: result
+		};
+		observe?.("fromHost", message);
+		logic.post(message);
+	});
+	const broadcast = (message) => {
+		observe?.("fromHost", message);
+		ui.post(message);
+		logic.post(message);
+	};
+	const barsByInstance = /* @__PURE__ */ new Map();
+	const showBars = () => {
+		const top = stack.top;
+		const bars = top && barsByInstance.get(top.instanceId);
+		onBarsChange?.({
+			title: bars?.navigationBar.title ?? manifest.name,
+			navigationBarHidden: bars?.navigationBar.hidden ?? false,
+			navigationBarColor: bars?.navigationBar.backgroundColor,
+			navigationBarTextColor: bars?.navigationBar.textColor,
+			tabBarHidden: bars?.tabBar.hidden ?? false
+		}, stack.pages);
+	};
+	const syncStack = () => {
+		const message = {
+			type: "syncStack",
+			payload: {
+				pages: stack.pages,
+				limit: stack.limit
+			}
+		};
+		broadcast(message);
+		const open = new Set(stack.pages.map((entry) => entry.instanceId));
+		for (const instanceId of barsByInstance.keys()) if (!open.has(instanceId)) barsByInstance.delete(instanceId);
+		showBars();
+	};
+	const syncSystemContext = () => {
+		broadcast({
+			type: "syncSystemContext",
+			payload: context
+		});
+	};
+	const navigate = (navigation) => {
+		if (navigation.action !== "back" && !manifest.pages.includes(navigation.page)) return false;
+		const previousTop = stack.top;
+		if (!stack.apply(navigation)) return false;
+		syncStack();
+		if (stack.top !== previousTop) calls.dismissUI();
+		return true;
+	};
+	const openFirstPages = () => {
+		const [first, ...rest] = restorePages.filter((entry) => manifest.pages.includes(entry.page));
+		if (!first) {
+			navigate({
+				action: "reset",
+				page: manifest.entry,
+				options: {}
+			});
+			return;
+		}
+		stack.apply({
+			action: "reset",
+			page: first.page,
+			options: first.options
+		});
+		for (const entry of rest) stack.apply({
+			action: "push",
+			page: entry.page,
+			options: entry.options
+		});
+		syncStack();
+	};
+	const navigateFromPage = ({ from, ...navigation }) => {
+		if (from === stack.top?.instanceId) navigate(navigation);
+	};
+	const hostMessageHandlers = /* @__PURE__ */ new Map([
+		["navigate", (payload) => navigateFromPage(payload)],
+		["hostCall", (payload) => calls.run(payload)],
+		["hostCancel", (payload) => calls.cancel(payload.id)],
+		["pageBars", (payload) => {
+			const { instanceId, ...bars } = payload;
+			barsByInstance.set(instanceId, bars);
+			showBars();
+		}]
+	]);
+	const stopService = logic.listen((raw) => {
+		const message = raw;
+		const handleHostMessage = hostMessageHandlers.get(message.type);
+		if (handleHostMessage) {
+			observe?.("toHost", message);
+			handleHostMessage(message.payload);
+			return;
+		}
+		observe?.("toWebview", message);
+		ui.post(message);
+	});
+	const stopWebview = ui.listen((raw) => {
+		const message = raw;
+		observe?.("toService", message);
+		logic.post(message);
+		if (message.type === "connect") {
+			syncSystemContext();
+			openFirstPages();
+		}
+	});
+	return {
+		get pages() {
+			return stack.pages;
+		},
+		back: () => navigate({
+			action: "back",
+			delta: 1
+		}),
+		setSystemContext: (next) => {
+			context = next;
+			syncSystemContext();
+		},
+		stop: () => {
+			stopService();
+			stopWebview();
+		}
+	};
+}
+//#endregion
+//#region src/versions.ts
+const SIMULATED_DASH_VERSION = "1.0.0";
+const MIN_RUNTIME_VERSION = "0.1.0-alpha.1";
+const SIMULATOR_VERSIONS = {
+	dashVersion: SIMULATED_DASH_VERSION,
+	minRuntimeVersion: MIN_RUNTIME_VERSION
+};
+//#endregion
+//#region src/paths.ts
+const CLIENT_PATH = "/__dot/";
+const EVENTS_PATH = `${CLIENT_PATH}events`;
+const HTTP_PATH = `${CLIENT_PATH}network/http/`;
+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
+const escapeHtml = (text) => text.replace(/[&<>"]/g, (char) => `&#${char.charCodeAt(0)};`);
+function simulatorPage(appName) {
+	return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${escapeHtml(appName)} · Dot simulator</title>
+    <style>${STYLES}</style>
+  </head>
+  <body>
+    <header>
+      <strong>${escapeHtml(appName)}</strong>
+      <span class="subtle">Dot simulator</span>
+      <select id="scheme" aria-label="Device appearance">
+        <option value="light">Light</option>
+        <option value="dark">Dark</option>
+      </select>
+      <button id="back" type="button" title="The system back button">◀ Back</button>
+      <button id="reload" type="button">Reload</button>
+    </header>
+    <main>
+      <section class="stage">
+        <pre id="error" hidden></pre>
+        <div class="phone" data-scheme="light">
+          <div class="status-bar">
+            <span class="clock"></span>
+            <span class="island"></span>
+            <span class="indicators">${STATUS_ICONS}</span>
+          </div>
+          <nav class="navigation-bar">
+            <button id="navigation-back" type="button" aria-label="Back" hidden>${BACK_ICON}</button>
+            <span id="navigation-title">${escapeHtml(appName)}</span>
+          </nav>
+          <iframe id="screen" title="${escapeHtml(appName)}"></iframe>
+          <nav class="tab-bar" aria-label="Dash's tabs">
+            <span>Home</span><span class="current">Dots</span><span>Me</span>
+          </nav>
+          <span class="home-indicator"></span>
+        </div>
+      </section>
+      <aside>
+        <div class="panel-head">
+          <span>Messages</span>
+          <button id="clear" type="button">Clear</button>
+        </div>
+        <ol id="log"></ol>
+      </aside>
+    </main>
+    <script src="${CLIENT_PATH}simulator.js"><\/script>
+  </body>
+</html>
+`;
+}
+const BACK_ICON = `<svg width="12" height="20" viewBox="0 0 12 20" aria-hidden="true"><path d="M10 2 2 10l8 8" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
+const STATUS_ICONS = `<svg class="torch" width="10" height="14" viewBox="0 0 10 14" aria-label="Torch on"><path d="M0 0h10v3L7.5 6v7a1 1 0 0 1-1 1h-3a1 1 0 0 1-1-1V6L0 3Z" fill="#ffd60a"/></svg><svg width="18" height="12" viewBox="0 0 18 12" fill="currentColor" aria-hidden="true"><rect x="0" y="8" width="3" height="4" rx="1"/><rect x="5" y="5.5" width="3" height="6.5" rx="1"/><rect x="10" y="3" width="3" height="9" rx="1"/><rect x="15" y="0" width="3" height="12" rx="1"/></svg><svg width="16" height="12" viewBox="0 0 16 12" fill="currentColor" aria-hidden="true"><path d="M8 2.2c2.3 0 4.4.9 6 2.4l1.2-1.3A10.4 10.4 0 0 0 8 .4 10.4 10.4 0 0 0 .8 3.3L2 4.6a8.6 8.6 0 0 1 6-2.4Zm0 3.6c1.3 0 2.5.5 3.5 1.3l1.2-1.3A6.9 6.9 0 0 0 8 4a6.9 6.9 0 0 0-4.7 1.8l1.2 1.3A5.1 5.1 0 0 1 8 5.8Zm0 3.6c-.5 0-1 .2-1.3.5L8 11.4l1.3-1.5c-.3-.3-.8-.5-1.3-.5Z"/></svg><svg width="27" height="13" viewBox="0 0 27 13" aria-hidden="true"><rect x="0.5" y="0.5" width="23" height="12" rx="3.5" fill="none" stroke="currentColor" opacity="0.4"/><rect x="2" y="2" width="20" height="9" rx="2" fill="currentColor"/><path d="M25 4.5v4c.8-.3 1.3-1.1 1.3-2s-.5-1.7-1.3-2Z" fill="currentColor" opacity="0.4"/></svg>`;
+const STYLES = `
+  :root {
+    color-scheme: light dark;
+    --bg: #eef0f3; --panel: #ffffff; --border: #d6d9de; --text: #1f2328; --subtle: #6b7280;
+    --to-service: #2563eb; --to-webview: #059669; --danger: #dc2626;
+    font: 13px/1.4 system-ui, sans-serif;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --bg: #0d1117; --panel: #161b22; --border: #30363d; --text: #e6edf3; --subtle: #8b949e;
+      --to-service: #58a6ff; --to-webview: #3fb950; --danger: #f85149;
+    }
+  }
+  * { 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); }
+  #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; --dialog: #f7f7f7; --dialog-line: #d1d1d6; }
+  .phone[data-scheme="dark"] { --screen: #121212; --screen-text: #fff; --dialog: #2c2c2e; --dialog-line: #48484a; }
+  .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); }
+  .dialog { width: 270px; border-radius: 14px; overflow: hidden; background: var(--dialog); color: var(--screen-text); text-align: center; font: 13px/1.35 system-ui, sans-serif; }
+  .dialog-body { display: flex; flex-direction: column; gap: 4px; padding: 18px 16px 16px; }
+  .dialog-title { font-size: 17px; font-weight: 600; }
+  .dialog-actions { display: flex; border-top: 1px solid var(--dialog-line); }
+  .dialog-actions.stacked { flex-direction: column; }
+  .dialog-actions button { flex: 1; margin: 0; padding: 11px; border: 0; border-radius: 0; background: transparent; color: #0a84ff; font-size: 17px; }
+  .dialog-actions button + button { border-left: 1px solid var(--dialog-line); }
+  .dialog-actions.stacked button + button { border-left: 0; border-top: 1px solid var(--dialog-line); }
+  .dialog-actions .cancel { font-weight: 600; }
+  .dialog-actions .destructive { color: #ff3b30; }
+  /* Stand-ins for Dash's own bars, which the dot's pages may set. */
+  .phone { --bar: var(--screen); --bar-text: var(--screen-text); }
+  .navigation-bar { flex: none; position: relative; height: 44px; display: flex; align-items: center; justify-content: center; padding: 0 48px; background: var(--bar); color: var(--bar-text); font: 600 17px/1 system-ui, sans-serif; }
+  #navigation-title { overflow: hidden; white-space: nowrap; text-overflow: ellipsis; }
+  #navigation-back { position: absolute; left: 8px; top: 0; bottom: 0; padding: 0 10px; border: 0; background: none; color: inherit; }
+  .tab-bar { flex: none; display: flex; justify-content: space-around; padding: 10px 0 30px; border-top: 1px solid rgb(128 128 128 / 0.3); background: var(--screen); color: var(--screen-text); opacity: 0.9; font: 500 11px/1 system-ui, sans-serif; }
+  .tab-bar .current { font-weight: 700; }
+  .navigation-bar[hidden], .tab-bar[hidden] { display: none; }
+  .phone:has(.navigation-bar[hidden]) .status-bar { background: var(--screen); color: var(--screen-text); }
+  .status-bar { flex: none; position: relative; height: 54px; display: flex; align-items: center; justify-content: space-between; padding: 0 30px 0 50px; background: var(--bar); color: var(--bar-text); font: 600 17px/1 system-ui, sans-serif; }
+  .island { position: absolute; top: 11px; left: 50%; width: 125px; height: 37px; margin-left: -62.5px; border-radius: 19px; background: #000; }
+  .indicators { display: flex; align-items: center; gap: 6px; }
+  #screen { flex: 1; display: block; width: 100%; border: 0; background: var(--screen); }
+  .home-indicator { position: absolute; bottom: 8px; left: 50%; width: 134px; height: 5px; margin-left: -67px; border-radius: 3px; background: var(--screen-text); pointer-events: none; }
+  #error { max-width: 640px; width: 100%; margin: 0; padding: 12px; white-space: pre-wrap; overflow-wrap: anywhere; color: #fff; background: var(--danger); border-radius: 8px; }
+  aside { width: 380px; display: flex; flex-direction: column; background: var(--panel); border-left: 1px solid var(--border); }
+  .panel-head { display: flex; align-items: center; justify-content: space-between; padding: 8px 12px; border-bottom: 1px solid var(--border); font-weight: 600; }
+  #log { flex: 1; overflow: auto; margin: 0; padding: 0; list-style: none; font: 12px/1.4 ui-monospace, monospace; }
+  #log li { border-bottom: 1px solid var(--border); padding: 4px 12px; }
+  #log summary { display: flex; gap: 8px; cursor: pointer; }
+  #log pre { margin: 4px 0; white-space: pre-wrap; word-break: break-all; color: var(--subtle); }
+  #log .time { color: var(--subtle); }
+  #log .toService .arrow { color: var(--to-service); }
+  #log .toWebview .arrow { color: var(--to-webview); }
+  #log .toHost .arrow, #log .fromHost .arrow { color: var(--subtle); }
+  #log .type { font-weight: 600; }
+  #log .note { padding: 2px 12px; text-align: center; color: var(--subtle); background: var(--bg); }
+  #log .failed .type { color: var(--danger); }
+  @media (max-width: 900px) { main { flex-direction: column; } aside { width: auto; height: 40vh; border-left: 0; border-top: 1px solid var(--border); } }
+`;
+//#endregion
+//#region src/bytes.ts
+const MEGABYTE = 1048576;
+function megabytes(bytes) {
+	return String(Math.ceil(bytes * 10 / MEGABYTE) / 10);
+}
+//#endregion
+//#region src/content-types.ts
+const CONTENT_TYPES = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".svg": "image/svg+xml",
+	".pdf": "application/pdf",
+	".json": "application/json",
+	".txt": "text/plain",
+	".csv": "text/csv",
+	".html": "text/html",
+	".zip": "application/zip"
+};
+function contentTypeFor(name) {
+	return CONTENT_TYPES[extname(name).toLowerCase()] ?? "application/octet-stream";
+}
+//#endregion
+//#region src/network.ts
+const MAX_RESPONSE_BYTES = 5 * MEGABYTE;
+const MAX_DOWNLOAD_BYTES = 100 * MEGABYTE;
+const MAX_REDIRECTS = 10;
+const METHODS = [
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"HEAD",
+	"OPTIONS"
+];
+const UPLOAD_METHODS = [
+	"POST",
+	"PUT",
+	"PATCH"
+];
+const BODILESS_METHODS = ["GET", "HEAD"];
+const REDIRECT_STATUSES = [
+	301,
+	302,
+	303,
+	307,
+	308
+];
+const HOST_HEADERS = [
+	"content-type",
+	"content-length",
+	"transfer-encoding",
+	"host",
+	"connection",
+	"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, readResponse);
+}
+async function downloadHttpFile(request, hosts, files, signal) {
+	return exchange(textRequest(request), hosts, signal, async (response) => {
+		if (!response.ok) return {
+			...await readResponse(response),
+			ok: false
+		};
+		const file = await save$1(response, request.name, files);
+		const { status, statusText, headers } = result(response, "");
+		return {
+			status,
+			statusText,
+			headers,
+			ok: true,
+			file
+		};
+	});
+}
+async function uploadHttpFiles(request, hosts, files, signal) {
+	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);
+		return {
+			field: upload.field,
+			file,
+			name: upload.name ? safeFileName(upload.name) : file.name
+		};
+	});
+	const makeForm = async () => {
+		const form = new FormData();
+		for (const [name, value] of Object.entries(request.fields ?? {})) form.append(name, value);
+		for (const part of parts) {
+			const contents = await readFile(part.file.path);
+			form.append(part.field, new File([contents], part.name, { type: part.file.contentType }));
+		}
+		return form;
+	};
+	return exchange({
+		method: parseMethod(request.method ?? "POST", UPLOAD_METHODS),
+		headers: checkedHeaders(request.headers ?? {}),
+		url: parseUrl(request.url),
+		body: {
+			kind: "form",
+			form: makeForm
+		}
+	}, hosts, signal, readResponse);
+}
+async function exchange(request, hosts, signal, read) {
+	let outgoing = request;
+	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 ${MAX_REDIRECTS} times`);
+}
+function textRequest(request) {
+	const method = parseMethod(request.method ?? "GET", METHODS);
+	const { contentType = "text/plain; charset=utf-8", others } = takeContentType(request.headers ?? {});
+	if (!CONTENT_TYPE.test(contentType)) throw invalid(`"${contentType}" is not a Content-Type`);
+	const headers = checkedHeaders(others);
+	let body;
+	if (request.body !== void 0) {
+		if (BODILESS_METHODS.includes(method)) throw invalid(`A ${method} request can't have a body`);
+		body = {
+			kind: "text",
+			text: request.body,
+			contentType
+		};
+	}
+	return {
+		url: parseUrl(request.url),
+		method,
+		headers,
+		body
+	};
+}
+function checkedHeaders(values) {
+	for (const name of Object.keys(values)) if (HOST_HEADERS.includes(name.toLowerCase())) throw invalid(`"${name}" is set by the host. Remove it from headers`);
+	return new Headers(values);
+}
+function takeContentType(values) {
+	let contentType;
+	const others = {};
+	for (const [name, value] of Object.entries(values)) if (name.toLowerCase() === "content-type") contentType = value;
+	else others[name] = value;
+	return {
+		contentType,
+		others
+	};
+}
+async function send$1(request, signal) {
+	const headers = new Headers(request.headers);
+	let body = null;
+	if (request.body?.kind === "text") {
+		body = request.body.text;
+		headers.set("content-type", request.body.contentType);
+	} else if (request.body?.kind === "form") body = await request.body.form();
+	try {
+		return await fetch(request.url, {
+			method: request.method,
+			headers,
+			body,
+			redirect: "manual",
+			signal
+		});
+	} catch (error) {
+		if (signal.aborted) throw error;
+		const cause = error.cause?.message;
+		throw new HostError("failed", `Could not reach ${request.url.hostname}: ${cause ?? error.message}`);
+	}
+}
+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 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");
+	return {
+		url,
+		method: becomesGet ? "GET" : request.method,
+		headers,
+		body: becomesGet ? void 0 : request.body
+	};
+}
+function result(response, body) {
+	return {
+		status: response.status,
+		statusText: response.statusText || (STATUS_CODES[response.status] ?? ""),
+		ok: response.ok,
+		headers: Object.fromEntries(response.headers),
+		body
+	};
+}
+async function readResponse(response) {
+	return result(response, await readBody(response));
+}
+async function readBody(response) {
+	const chunks = [];
+	await readChunks(response, MAX_RESPONSE_BYTES, (chunk) => {
+		chunks.push(chunk);
+		return Promise.resolve();
+	});
+	const charset = /charset=([^;\s]+)/i.exec(response.headers.get("content-type") ?? "")?.[1];
+	return decoderFor(charset).decode(Buffer.concat(chunks));
+}
+async function save$1(response, requestedName, files) {
+	const { id, path } = await files.newPath();
+	const handle = await open(path, "w");
+	try {
+		await readChunks(response, MAX_DOWNLOAD_BYTES, async (chunk) => {
+			await handle.write(chunk);
+		});
+	} catch (error) {
+		await handle.close();
+		await rm(path, { force: true });
+		throw error;
+	}
+	await handle.close();
+	const name = requestedName ? safeFileName(requestedName) : fileName(response);
+	return files.add(id, path, name, contentType(response, name));
+}
+async function readChunks(response, limit, take) {
+	if (Number(response.headers.get("content-length") ?? 0) > limit) {
+		await response.body?.cancel();
+		throw tooLarge(limit);
+	}
+	if (!response.body) return;
+	const reader = response.body.getReader();
+	let length = 0;
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) return;
+		length += value.length;
+		if (length > limit) {
+			await reader.cancel();
+			throw tooLarge(limit);
+		}
+		await take(value);
+	}
+}
+function fileName(response) {
+	const disposition = response.headers.get("content-disposition") ?? "";
+	const encoded = /filename\*\s*=\s*[^']*''([^;]+)/i.exec(disposition)?.[1];
+	const plain = /filename\s*=\s*"?([^";]+)"?/i.exec(disposition)?.[1];
+	const segment = new URL(response.url).pathname.split("/").at(-1);
+	return [
+		encoded && safeDecode(encoded),
+		plain,
+		segment && safeDecode(segment)
+	].map((name) => safeFileName(name ?? "")).find(Boolean) ?? "download";
+}
+function safeFileName(name) {
+	return (name.split(/[/\\]/).at(-1) ?? "").trim().slice(0, 255);
+}
+function safeDecode(text) {
+	try {
+		return decodeURIComponent(text);
+	} catch {
+		return text;
+	}
+}
+function contentType(response, name) {
+	const declared = response.headers.get("content-type")?.split(";")[0]?.trim();
+	if (declared && declared !== "application/octet-stream") return declared;
+	return contentTypeFor(name);
+}
+function decoderFor(charset) {
+	try {
+		return new TextDecoder(charset ?? "utf-8");
+	} catch {
+		return new TextDecoder("utf-8");
+	}
+}
+function parseUrl(text) {
+	const url = /^https?:\/\//i.test(text) ? URL.parse(text) : null;
+	if (!url?.hostname) throw invalid(`"${text}" is not an http:// or https:// URL`);
+	return url;
+}
+function parseMethod(name, methods) {
+	const method = name.toUpperCase();
+	if (!methods.includes(method)) throw invalid(`"${name}" is not an HTTP method. Use ${methods.join(", ")}`);
+	return method;
+}
+function invalid(message) {
+	return new HostError("invalid", message);
+}
+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. It uses ${megabytes(this.#used)} of ${megabytes(this.limit)} MB. Remove some entries first`);
+			}
+			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 = 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 });
+		if (problem) throw new HostError("invalid", problem);
+		const resolved = path === "" ? this.#root : join(this.#root, path);
+		await this.#checkInside(resolved);
+		return resolved;
+	}
+	async usage() {
+		return sizeOf(this.#root);
+	}
+	async ensureRoot() {
+		await mkdir(this.#root, { recursive: true });
+	}
+	async #checkInside(path) {
+		const realRoot = await realpath(this.#root).catch(() => null);
+		if (realRoot === null) return;
+		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 goes outside the dot's folder");
+	}
+};
+async function runFileCall(operation, params, storage, temporaryFiles) {
+	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}"`);
+		}
+	});
+}
+async function read({ path, as }, storage) {
+	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`);
+	return (await readFile(file)).toString(encoding);
+}
+async function write({ path, data, as, append = false }, storage) {
+	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);
+	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 storage.replace(file, (staged) => writeFile(staged, bytes));
+	return written(path, file);
+}
+async function list({ path, recursive = false }, storage) {
+	const folder = await storage.resolve(path, { allowRoot: true });
+	const info = await statOrNull(folder);
+	if (!info) {
+		if (path === "") return [];
+		throw failed(`There is no folder at "${path}"`);
+	}
+	if (!info.isDirectory()) throw failed(`"${path}" is a file`);
+	const entries = [];
+	await collect(path, folder, recursive, entries);
+	return entries.sort((first, second) => first.path < second.path ? -1 : 1);
+}
+async function createFolder(path, storage) {
+	const folder = await storage.resolve(path);
+	if ((await statOrNull(folder))?.isFile()) throw failed(`"${path}" is a file`);
+	await createParent(storage, folder, path);
+	await mkdir(folder, { recursive: true });
+	return written(path, folder);
+}
+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", `Can't put "${from}" inside itself, at "${to}"`);
+	await makeRoom(storage, target, to, overwrite, keepSource ? await sizeOf(source) : 0);
+	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. To remove them too, pass { recursive: true }`);
+	await rm(target, {
+		recursive: true,
+		force: true
+	});
+}
+async function save({ file: id, path, overwrite = false }, storage, temporaryFiles) {
+	const file = temporaryFiles.requireFile(id);
+	const target = await storage.resolve(path);
+	await makeRoom(storage, target, path, overwrite, file.size);
+	await storage.replace(target, (staged) => cp(file.path, staged));
+	return written(path, target);
+}
+async function open$1(path, storage, temporaryFiles) {
+	const file = await storage.resolve(path);
+	if (!(await statOrNull(file))?.isFile()) throw failed(`There is no file at "${path}"`);
+	const name = basename(path);
+	return temporaryFiles.reference(file, name, contentTypeFor(name));
+}
+async function collect(folderPath, folder, recursive, entries) {
+	for (const name of await readdir(folder)) {
+		const path = folderPath === "" ? name : `${folderPath}/${name}`;
+		const child = join(folder, name);
+		const found = await entry(path, child);
+		if (!found) continue;
+		entries.push(found);
+		if (recursive && found.kind === "folder") await collect(path, child, true, entries);
+	}
+}
+async function entry(path, file) {
+	const info = await statOrNull(file);
+	if (!info) return null;
+	const name = path === "" ? "" : basename(path);
+	const modifiedAt = Math.round(info.mtimeMs);
+	if (info.isDirectory()) return {
+		name,
+		path,
+		kind: "folder",
+		size: 0,
+		modifiedAt
+	};
+	return {
+		name,
+		path,
+		kind: "file",
+		size: info.size,
+		contentType: contentTypeFor(name),
+		modifiedAt
+	};
+}
+async function written(path, file) {
+	const found = await entry(path, file);
+	if (!found) throw failed(`"${path}" was removed while it was being written`);
+	return found;
+}
+async function makeRoom(storage, target, path, overwrite, addedBytes) {
+	if (await exists(target) && !overwrite) throw failed(`"${path}" already exists. To replace it, pass { overwrite: true }`);
+	await checkQuota(storage, addedBytes - await sizeOf(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 rename(from, target);
+}
+async function createParent(storage, file, path) {
+	await storage.ensureRoot();
+	const parent = dirname(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 folder is full. It uses ${megabytes(used)} of ${megabytes(storage.quota)} MB, and this needs ${megabytes(addedBytes)} MB more. Remove some files first`);
+}
+async function sizeOf(path) {
+	const info = await lstat(path).catch(() => null);
+	if (!info) return 0;
+	if (!info.isDirectory()) return info.size;
+	let total = 0;
+	for (const name of await readdir(path)) total += await sizeOf(join(path, name));
+	return total;
+}
+async function exists(path) {
+	return await lstat(path).catch(() => null) !== null;
+}
+async function statOrNull(path) {
+	return stat(path).catch(() => null);
+}
+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
+var TemporaryFiles = class {
+	#directory;
+	#files = /* @__PURE__ */ new Map();
+	constructor(directory) {
+		this.#directory = directory;
+	}
+	file(id) {
+		return this.#files.get(id);
+	}
+	requireFile(id) {
+		const file = this.#files.get(id);
+		if (!file) throw new HostError("invalid", `"${id}" isn't one of this dot's files`);
+		return file;
+	}
+	async clear() {
+		this.#files.clear();
+		await rm(this.#directory, {
+			recursive: true,
+			force: true
+		});
+	}
+	async newPath() {
+		await mkdir(this.#directory, { recursive: true });
+		const id = newId();
+		return {
+			id,
+			path: join(this.#directory, id)
+		};
+	}
+	async reference(path, name, contentType) {
+		return this.add(newId(), path, name, contentType);
+	}
+	async add(id, path, name, contentType) {
+		const { size } = await stat(path);
+		const url = `${TEMPORARY_FILES_PATH}${id}`;
+		this.#files.set(id, {
+			id,
+			name,
+			size,
+			contentType,
+			url,
+			path
+		});
+		return {
+			id,
+			name,
+			size,
+			contentType,
+			url
+		};
+	}
+};
+function newId() {
+	return `f_${randomBytes(12).toString("base64url")}`;
+}
+//#endregion
+//#region src/server.ts
+const DEFAULT_PORT = 3680;
+const PORT_ATTEMPTS = 5;
+const MIME_TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".map": "application/json; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".woff2": "font/woff2"
+};
+async function startSimulator({ dotDir, reactHostDir, name = "Dot", port = DEFAULT_PORT, host = "localhost", clientDir = defaultClientDir(), storageDir }) {
+	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));
+	};
+	const server = createServer((request, response) => {
+		const { pathname } = new URL(request.url ?? "/", "http://localhost");
+		if (pathname === "/") {
+			send(response, 200, simulatorPage(name), ".html");
+			return;
+		}
+		if (pathname === "/favicon.ico") {
+			send(response, 204, "");
+			return;
+		}
+		if (pathname === EVENTS_PATH) {
+			response.writeHead(200, {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-store",
+				Connection: "keep-alive"
+			});
+			response.write(": connected\n\n");
+			if (buildError !== null) response.write(serverEvent("build-error", buildError));
+			clients.add(response);
+			request.on("close", () => clients.delete(response));
+			return;
+		}
+		if (pathname.startsWith(HTTP_PATH) && request.method === "POST") {
+			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") {
+			const operation = pathname.slice(FILE_PATH.length);
+			answer(request, response, (params) => runFileCall(operation, params, storage, files));
+			return;
+		}
+		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) {
+			serveReact(response, reactHostDir, pathname.slice(REACT_HOST_PATH.length));
+			return;
+		}
+		if (pathname.startsWith("/__dot/")) {
+			serveFile(response, clientDir, pathname.slice(7));
+			return;
+		}
+		if (pathname.startsWith("/dot/")) {
+			const injectBridge = pathname === WEBVIEW_URL || `${pathname}index.html` === WEBVIEW_URL;
+			serveFile(response, dotDir, pathname.slice(5), injectBridge);
+			return;
+		}
+		notFound(response);
+	});
+	await listen(server, port, host);
+	return {
+		url: `http://${host}:${server.address().port}/`,
+		reload: () => {
+			buildError = null;
+			files.clear();
+			broadcast("reload");
+		},
+		hotReload: () => {
+			buildError = null;
+			broadcast("hot-reload");
+		},
+		error: (message) => {
+			buildError = message;
+			broadcast("build-error", message);
+		},
+		close: async () => {
+			for (const client of clients) client.end();
+			await new Promise((resolvePromise) => {
+				server.close(() => resolvePromise());
+			});
+			await files.clear();
+		}
+	};
+}
+async function answer(request, response, run) {
+	const controller = new AbortController();
+	response.on("close", () => controller.abort());
+	let reply;
+	try {
+		const chunks = [];
+		for await (const chunk of request) chunks.push(chunk);
+		reply = { result: await run(JSON.parse(Buffer.concat(chunks).toString("utf8")), controller.signal) ?? null };
+	} catch (error) {
+		if (controller.signal.aborted) return;
+		reply = { error: {
+			code: error instanceof HostError ? error.code : "failed",
+			message: error.message
+		} };
+	}
+	send(response, 200, JSON.stringify(reply), ".json");
+}
+async function serveTemporaryFile(response, files, id) {
+	const file = files.file(id);
+	if (!file) {
+		notFound(response);
+		return;
+	}
+	response.writeHead(200, {
+		"Content-Type": file.contentType,
+		"Cache-Control": "no-store"
+	});
+	response.end(await readFile(file.path));
+}
+async function networkHosts(dotDir) {
+	return JSON.parse(await readFile(join(dotDir, "manifest.json"), "utf8")).network?.hosts ?? [];
+}
+function serverEvent(event, data) {
+	return `event: ${event}\n${data.split("\n").map((line) => `data: ${line}`).join("\n")}\n\n`;
+}
+async function listen(server, port, host) {
+	for (let attempt = 0; attempt < PORT_ATTEMPTS; attempt++) if (!await new Promise((resolvePromise, reject) => {
+		const onError = (error) => {
+			if (error.code === "EADDRINUSE") resolvePromise(true);
+			else reject(error);
+		};
+		server.once("error", onError);
+		server.listen(port + attempt, host, () => {
+			server.off("error", onError);
+			resolvePromise(false);
+		});
+	})) return;
+	const last = port + PORT_ATTEMPTS - 1;
+	throw new Error(`Ports ${port} to ${last} are all in use. Pass another with --port.`);
+}
+async function serveReact(response, reactHostDir, path) {
+	const [major = "", ...file] = path.split("/");
+	const versions = await readdir(reactHostDir).catch(() => []);
+	const version = newestReactOfMajor(versions, Number(major));
+	if (version === void 0) {
+		notFound(response);
+		return;
+	}
+	await serveFile(response, join(reactHostDir, version), file.join("/"));
+}
+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)) {
+		notFound(response);
+		return;
+	}
+	try {
+		if ((await stat(file)).isDirectory()) file = join(file, "index.html");
+		const body = await readFile(file);
+		if (!injectBridge) {
+			send(response, 200, body, extname(file));
+			return;
+		}
+		const bridge = `<script src="${CLIENT_PATH}webview-bridge.js"><\/script>`;
+		send(response, 200, body.toString("utf8").replace("<head>", `<head>\n    ${bridge}`), ".html");
+	} catch {
+		notFound(response);
+	}
+}
+function send(response, status, body, extension = ".txt") {
+	response.writeHead(status, {
+		"Content-Type": MIME_TYPES[extension] ?? "text/plain; charset=utf-8",
+		"Cache-Control": "no-store"
+	});
+	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");
+}
+//#endregion
+export { DEFAULT_PORT, IncompatibleDotError, MIN_RUNTIME_VERSION, SIMULATED_DASH_VERSION, SIMULATOR_VERSIONS, checkCompatibility, startHost, startSimulator };
+
+//# sourceMappingURL=index.js.map