@ogygia/devtools 0.0.0 → 0.11.0

package/dist/profiler/river.d.ts

@@ -0,0 +1,65 @@
+/**
+ * THE DATA RIVER — where the page's data comes from and where it goes: upstream calls (ms) feed
+ * load functions, load functions produce `page.data` keys (bytes in the seed), keys are read by
+ * islands. A wide band is a lot; a band that ends at a key nothing reads is data fetched and
+ * shipped for no one. Pure: the host gathers the inputs (the timeline's calls per load lane, the
+ * keys each load returns from its source, the keys each island reads from the build, the seed's
+ * bytes per key from the rendered document) and this builds the four-column flow.
+ */
+export interface RiverNode {
+  id: string;
+  /** 0 calls · 1 loads · 2 keys · 3 islands */
+  col: 0 | 1 | 2 | 3;
+  label: string;
+  /** the column's unit: ms for calls and loads, bytes for keys and islands */
+  value: number;
+  kind: "call" | "load" | "key" | "island" | "unknown";
+  detail?: string;
+}
+export interface RiverLink {
+  from: string;
+  to: string;
+  value: number;
+  unit: "ms" | "bytes";
+}
+export interface River {
+  nodes: RiverNode[];
+  links: RiverLink[];
+  /** keys in the seed no island reads (only when at least one island names its keys) */
+  waste: {
+    key: string;
+    bytes: number;
+  }[];
+  notes: string[];
+}
+export interface RiverInput {
+  /** the timeline's outbound calls, each on the load lane (file) that made it */
+  calls: {
+    lane: string | null;
+    label: string;
+    ms: number;
+  }[];
+  /** each load lane and the keys its source returns (null: could not tell) */
+  lanes: {
+    file: string;
+    keys: string[] | null;
+    ms?: number;
+  }[];
+  /** each island and the page.data keys it reads (null: reads everything) */
+  islands: {
+    name: string;
+    keys: string[] | null;
+  }[];
+  /** the seed's bytes per top-level page.data key */
+  seed: Record<string, number>;
+}
+export declare function build_river(input: RiverInput): River;
+/** The top-level keys a `load` function's `return { … }` object literals name — the union over
+ *  every return; null when a return spreads something or returns a non-literal (the keys are then
+ *  whatever that value has, which the source alone cannot say). */
+export declare function load_return_keys(source: string): string[] | null;
+/** The seed's bytes per top-level `page.data` key, from the seed script's text — plain JSON
+ *  (`{ data: {…} }` or the keys themselves), or devalue's flat node array (`[{root…}, node, …]`,
+ *  where an object's values and an array's items are node indices): a key's bytes are then the
+ *  nodes reachable from it, so a node two keys share counts for both. */
+export declare function seed_key_bytes(seed_json: string): Record<string, number>;

package/dist/profiler/river.js

@@ -0,0 +1,298 @@
+// src/profiler/river.ts
+const short_call = (label) => {
+	const m = /^([A-Z]+) (?:https?:\/\/)?([^/?#]+)?(\/[^?#\s]*)?/.exec(label);
+	if (!m) return label.slice(0, 60);
+	const path = m[3] ?? "/";
+	return `${m[1]} ${path.length > 40 ? "…" + path.slice(-38) : path}`;
+};
+function build_river(input) {
+	const nodes = [];
+	const links = [];
+	const notes = [];
+	const node = (n) => {
+		nodes.push(n);
+		return n.id;
+	};
+	const lane_ids = /* @__PURE__ */ new Map();
+	for (const l of input.lanes) lane_ids.set(l.file, node({
+		id: `load:${l.file}`,
+		col: 1,
+		label: l.file,
+		value: 0,
+		kind: "load",
+		detail: l.keys ? `returns ${l.keys.join(", ")}` : "returns keys the profiler could not read from its source"
+	}));
+	const grouped = /* @__PURE__ */ new Map();
+	for (const c of input.calls) {
+		const k = `${c.lane ?? ""}|${short_call(c.label)}`;
+		const g = grouped.get(k);
+		if (g) {
+			g.ms += c.ms;
+			g.n++;
+		} else grouped.set(k, {
+			lane: c.lane,
+			label: short_call(c.label),
+			ms: c.ms,
+			n: 1
+		});
+	}
+	let other_lane = null;
+	for (const [k, g] of grouped) {
+		const id = node({
+			id: `call:${k}`,
+			col: 0,
+			label: g.n > 1 ? `${g.label} ×${g.n}` : g.label,
+			value: g.ms,
+			kind: "call",
+			detail: `${Math.round(g.ms)} ms waiting${g.n > 1 ? ` over ${g.n} calls` : ""}`
+		});
+		let to = g.lane ? lane_ids.get(g.lane) : void 0;
+		if (!to) {
+			other_lane ??= node({
+				id: "load:?",
+				col: 1,
+				label: "outside a load",
+				value: 0,
+				kind: "unknown",
+				detail: "a call made outside any load function (a hook, a component)"
+			});
+			to = other_lane;
+		}
+		links.push({
+			from: id,
+			to,
+			value: g.ms,
+			unit: "ms"
+		});
+		nodes.find((n) => n.id === to).value += g.ms;
+	}
+	const key_ids = /* @__PURE__ */ new Map();
+	const key_node = (key) => {
+		let id = key_ids.get(key);
+		if (!id) key_ids.set(key, id = node({
+			id: `key:${key}`,
+			col: 2,
+			label: key,
+			value: input.seed[key] ?? 0,
+			kind: "key",
+			detail: input.seed[key] !== void 0 ? `${Math.round(input.seed[key] / 1024 * 10) / 10} KB in the seed` : "not in the seed (no island reads it, or it never shipped)"
+		}));
+		return id;
+	};
+	const claimed = /* @__PURE__ */ new Set();
+	for (const l of input.lanes) {
+		const from = lane_ids.get(l.file);
+		if (l.keys) for (const k of l.keys) {
+			claimed.add(k);
+			links.push({
+				from,
+				to: key_node(k),
+				value: Math.max(input.seed[k] ?? 0, 1),
+				unit: "bytes"
+			});
+		}
+	}
+	const unclaimed = Object.keys(input.seed).filter((k) => !claimed.has(k));
+	if (unclaimed.length) {
+		const from = input.lanes.find((l) => l.keys === null) ? lane_ids.get(input.lanes.find((l) => l.keys === null).file) : node({
+			id: "load:above",
+			col: 1,
+			label: "a load outside the window",
+			value: 0,
+			kind: "unknown",
+			detail: "a layout load that ran earlier, or one whose source the profiler could not read"
+		});
+		for (const k of unclaimed) links.push({
+			from,
+			to: key_node(k),
+			value: Math.max(input.seed[k] ?? 0, 1),
+			unit: "bytes"
+		});
+	}
+	const named = input.islands.some((i) => i.keys && i.keys.length);
+	const read = /* @__PURE__ */ new Set();
+	for (const i of input.islands) {
+		const id = node({
+			id: `island:${i.name}`,
+			col: 3,
+			label: i.name,
+			value: 0,
+			kind: "island",
+			detail: i.keys ? `reads ${i.keys.length ? i.keys.join(", ") : "nothing from page.data"}` : "reads page.data through a helper the build could not follow: the whole seed ships for it"
+		});
+		const keys = i.keys ?? Object.keys(input.seed);
+		for (const k of keys) {
+			if (input.seed[k] === void 0 && !key_ids.has(k)) continue;
+			read.add(k);
+			const bytes = Math.max(input.seed[k] ?? 0, 1);
+			links.push({
+				from: key_node(k),
+				to: id,
+				value: bytes,
+				unit: "bytes"
+			});
+			nodes.find((n) => n.id === id).value += bytes;
+		}
+	}
+	const waste = named ? Object.entries(input.seed).filter(([k]) => !read.has(k)).map(([key, bytes]) => ({
+		key,
+		bytes
+	})).sort((a, b) => b.bytes - a.bytes) : [];
+	if (waste.length) notes.push(`${waste.length} key${waste.length === 1 ? "" : "s"} in the seed that no island reads: ${waste.slice(0, 4).map((w) => `${w.key} (${Math.round(w.bytes / 1024 * 10) / 10} KB)`).join(", ")}.`);
+	if (!named && input.islands.length) notes.push("No island names the keys it reads, so every key ships to every island. Read page.data keys directly in the island (or pass them as props) and the seed shrinks to what is used.");
+	return {
+		nodes,
+		links,
+		waste,
+		notes
+	};
+}
+const LOAD_HEAD_RE = /export\s+(?:async\s+)?(?:function\s+load\s*\(|const\s+load\s*(?::[^=]+)?=)/;
+const KEY_RE = /^(?:(?:"([^"]*)")|(?:'([^']*)')|([A-Za-z_$][\w$]*))\s*(?::|,|$|\})/;
+/** The top-level keys a `load` function's `return { … }` object literals name — the union over
+*  every return; null when a return spreads something or returns a non-literal (the keys are then
+*  whatever that value has, which the source alone cannot say). */
+function load_return_keys(source) {
+	const head = LOAD_HEAD_RE.exec(source);
+	if (!head) return null;
+	const body = source.slice(head.index);
+	const keys = /* @__PURE__ */ new Set();
+	let found = false;
+	let unknown = false;
+	const RETURN_RE = /\breturn\s*(\{|\(|[^\s;{(])/g;
+	let m;
+	while (m = RETURN_RE.exec(body)) {
+		found = true;
+		let at = m.index + m[0].length - 1;
+		if (body[at] === "(") {
+			let j = at + 1;
+			while (j < body.length && /\s/.test(body[j])) j++;
+			if (body[j] !== "{") {
+				unknown = true;
+				continue;
+			}
+			at = j;
+		}
+		if (body[at] !== "{") {
+			unknown = true;
+			continue;
+		}
+		let depth = 0;
+		let i = at;
+		let expect_key = true;
+		while (i < body.length) {
+			const ch = body[i];
+			if (depth === 1 && expect_key && !/\s/.test(ch) && !(ch === "/" && (body[i + 1] === "/" || body[i + 1] === "*"))) {
+				if (body.startsWith("...", i)) {
+					unknown = true;
+					expect_key = false;
+					i += 3;
+					continue;
+				}
+				const km = KEY_RE.exec(body.slice(i, i + 200));
+				if (km) {
+					keys.add(km[1] ?? km[2] ?? km[3]);
+					expect_key = false;
+					i += km[0].length - (km[0].endsWith("}") || km[0].endsWith(",") ? 1 : 0);
+					continue;
+				}
+				expect_key = false;
+			}
+			if (ch === "\"" || ch === "'" || ch === "`") {
+				const q = ch;
+				i++;
+				while (i < body.length && body[i] !== q) i += body[i] === "\\" ? 2 : 1;
+				i++;
+				continue;
+			}
+			if (ch === "/" && body[i + 1] === "/") {
+				while (i < body.length && body[i] !== "\n") i++;
+				continue;
+			}
+			if (ch === "/" && body[i + 1] === "*") {
+				i = body.indexOf("*/", i + 2);
+				if (i === -1) i = body.length;
+				i += 2;
+				continue;
+			}
+			if (ch === "{" || ch === "(" || ch === "[") {
+				depth++;
+				if (depth === 1) expect_key = true;
+				i++;
+				continue;
+			}
+			if (ch === "}" || ch === ")" || ch === "]") {
+				depth--;
+				if (depth === 0) break;
+				i++;
+				continue;
+			}
+			if (depth === 1 && ch === ",") expect_key = true;
+			i++;
+		}
+	}
+	if (!found || unknown) return null;
+	return [...keys];
+}
+/** The seed's bytes per top-level `page.data` key, from the seed script's text — plain JSON
+*  (`{ data: {…} }` or the keys themselves), or devalue's flat node array (`[{root…}, node, …]`,
+*  where an object's values and an array's items are node indices): a key's bytes are then the
+*  nodes reachable from it, so a node two keys share counts for both. */
+function seed_key_bytes(seed_json) {
+	try {
+		const data = JSON.parse(seed_json);
+		if (Array.isArray(data) && data.length && data[0] && typeof data[0] === "object" && !Array.isArray(data[0])) return devalue_key_bytes(data);
+		const obj = (data && typeof data === "object" && !Array.isArray(data) ? data : null) ?? null;
+		if (!obj) return {};
+		const inner = (obj.data && typeof obj.data === "object" ? obj.data : null) ?? obj.page?.data ?? obj;
+		const out = {};
+		for (const [k, v] of Object.entries(inner)) out[k] = JSON.stringify(v)?.length ?? 0;
+		return out;
+	} catch {
+		return {};
+	}
+}
+/** devalue's typed arrays: `["Date", "…"]`, `["Map", i, j…]`, `["Set", i…]`, `["Object", i]`,
+*  `["RegExp", …]`, `["BigInt", …]`, `["null"]` — the first element names the type, the rest are
+*  indices for the container kinds and plain values for the others */
+const DEVALUE_CONTAINERS = /* @__PURE__ */ new Set([
+	"Map",
+	"Set",
+	"Object",
+	"Array"
+]);
+function devalue_key_bytes(nodes) {
+	const root = nodes[0];
+	const data_ix = typeof root.data === "number" ? root.data : void 0;
+	const data = data_ix !== void 0 && data_ix >= 0 ? nodes[data_ix] : root;
+	if (!data || typeof data !== "object" || Array.isArray(data)) return {};
+	const size = nodes.map((n) => JSON.stringify(n)?.length ?? 0);
+	const refs = (n) => {
+		if (Array.isArray(n)) {
+			if (typeof n[0] === "string" && !DEVALUE_CONTAINERS.has(n[0])) return [];
+			return (typeof n[0] === "string" ? n.slice(1) : n).filter((x) => typeof x === "number" && x >= 0 && Number.isInteger(x));
+		}
+		if (n && typeof n === "object") return Object.values(n).filter((x) => typeof x === "number" && x >= 0 && Number.isInteger(x));
+		return [];
+	};
+	const out = {};
+	for (const [key, ix] of Object.entries(data)) {
+		if (typeof ix !== "number" || ix < 0 || !Number.isInteger(ix)) {
+			out[key] = 0;
+			continue;
+		}
+		const seen = /* @__PURE__ */ new Set();
+		const stack = [ix];
+		let bytes = 0;
+		while (stack.length) {
+			const i = stack.pop();
+			if (seen.has(i) || i >= nodes.length) continue;
+			seen.add(i);
+			bytes += size[i];
+			for (const r of refs(nodes[i])) if (!seen.has(r)) stack.push(r);
+		}
+		out[key] = bytes;
+	}
+	return out;
+}
+export { build_river, load_return_keys, seed_key_bytes };

package/dist/profiler/route-files.d.ts

@@ -0,0 +1,22 @@
+/**
+ * WHICH ROUTE A FILE BELONGS TO — a page or layout file under `src/routes` (or its built chunk under
+ * `entries/pages`), and whether it is ANOTHER route's than the one profiled: a visitor of another
+ * page whose work landed in the same window. Pure and import-free: the CPU analysis, the report and
+ * the report's browser side all ask it.
+ */
+/** a route's page or layout file, by its folder under `src/routes` (`form: 'src'`) or its built
+ *  chunk under `entries/pages` (`'built'`: `[id]` written `_id_`); undefined for any other file */
+export declare function route_file_of(path: string): {
+  dir: string;
+  page: boolean;
+  form: "src" | "built";
+} | undefined;
+/** a route id's own folder and the folders above it (whose layouts it renders in), per form */
+export declare function route_dirs(route: string): {
+  own: (form: "src" | "built") => string;
+  above: (form: "src" | "built") => string[];
+};
+/** A file that is ANOTHER route's page or layout (not `route`'s own page, nor a layout above it):
+ *  another visitor's request. `path` absolute, `file://`, or src-relative (`routes/x/+page.server.ts`).
+ *  Endpoints and shared code are never another route's by this. */
+export declare function another_routes_file(route: string, path: string): boolean;

package/dist/profiler/route-files.js

@@ -0,0 +1,55 @@
+// src/profiler/route-files.ts
+/**
+* WHICH ROUTE A FILE BELONGS TO — a page or layout file under `src/routes` (or its built chunk under
+* `entries/pages`), and whether it is ANOTHER route's than the one profiled: a visitor of another
+* page whose work landed in the same window. Pure and import-free: the CPU analysis, the report and
+* the report's browser side all ask it.
+*/
+/** a route's page or layout file, by its folder under `src/routes` (`form: 'src'`) or its built
+*  chunk under `entries/pages` (`'built'`: `[id]` written `_id_`); undefined for any other file */
+function route_file_of(path) {
+	const read = (marker, form, page, layout) => {
+		const at = path.lastIndexOf(marker);
+		if (at === -1) return void 0;
+		const rel = path.slice(at + marker.length);
+		const slash = rel.lastIndexOf("/");
+		const base = rel.slice(slash + 1);
+		const dir = slash === -1 ? "" : rel.slice(0, slash);
+		if (base.startsWith(page)) return {
+			dir,
+			page: true,
+			form
+		};
+		if (layout.some((l) => base.startsWith(l))) return {
+			dir,
+			page: false,
+			form
+		};
+	};
+	return read("/src/routes/", "src", "+page", ["+layout", "+error"]) ?? read("/entries/pages/", "built", "_page", ["_layout", "_error"]);
+}
+/** a route id's own folder and the folders above it (whose layouts it renders in), per form */
+function route_dirs(route) {
+	const segs = route.split("/").filter(Boolean);
+	const built = segs.map((s) => s.split("[").join("_").split("]").join("_"));
+	const prefixes = (list) => list.map((_, i) => list.slice(0, i + 1).join("/"));
+	const src_above = ["", ...prefixes(segs)];
+	const built_above = ["", ...prefixes(built)];
+	return {
+		own: (form) => (form === "src" ? segs : built).join("/"),
+		above: (form) => form === "src" ? src_above : built_above
+	};
+}
+/** A file that is ANOTHER route's page or layout (not `route`'s own page, nor a layout above it):
+*  another visitor's request. `path` absolute, `file://`, or src-relative (`routes/x/+page.server.ts`).
+*  Endpoints and shared code are never another route's by this. */
+function another_routes_file(route, path) {
+	let p = path.startsWith("file://") ? path.slice(7) : path;
+	if (p.startsWith("routes/")) p = "/src/" + p;
+	else if (p.startsWith("src/routes/")) p = "/" + p;
+	const f = route_file_of(p);
+	if (!f) return false;
+	const mine = route_dirs(route);
+	return f.page ? f.dir !== mine.own(f.form) : !mine.above(f.form).includes(f.dir);
+}
+export { another_routes_file, route_dirs, route_file_of };

package/dist/profiler/route-imports.d.ts

@@ -0,0 +1,14 @@
+/**
+ * THE `<Name>.svelte` A ROUTE IMPORTS: from its `+page.svelte` / `+layout.svelte` files (src-relative
+ * paths), each import of a file with that name, resolved: `$lib/hell/X.svelte` → `lib/hell/X.svelte`,
+ * `./X.svelte` beside the route file. What tells two same-named components apart (a component is
+ * named after its file, and a `Button.svelte` can live in several folders).
+ */
+export declare function route_imports(files: Iterable<string>, read: (file: string) => string | undefined, name: string): Set<string>;
+/**
+ * THE APP MODULES A SERVER FILE IMPORTS: each `$lib/…` or relative import of a script module
+ * (`.svelte` files and packages left out), src-relative and resolved against the file's folder —
+ * the candidates to read, each as written (no extension) and with `.ts` / `.js` / `/index.ts` /
+ * `/index.js`. One file's `import … from '…'` and `export … from '…'` lines; no regex.
+ */
+export declare function module_imports(file: string, src: string): string[];

package/dist/profiler/route-imports.js

@@ -0,0 +1,83 @@
+// src/profiler/route-imports.ts
+/**
+* THE `<Name>.svelte` A ROUTE IMPORTS: from its `+page.svelte` / `+layout.svelte` files (src-relative
+* paths), each import of a file with that name, resolved: `$lib/hell/X.svelte` → `lib/hell/X.svelte`,
+* `./X.svelte` beside the route file. What tells two same-named components apart (a component is
+* named after its file, and a `Button.svelte` can live in several folders).
+*/
+function route_imports(files, read, name) {
+	const out = /* @__PURE__ */ new Set();
+	const leaf = `/${name}.svelte`;
+	for (const file of files) {
+		if (!file.endsWith("/+page.svelte") && !file.endsWith("/+layout.svelte")) continue;
+		const src = read(file);
+		if (!src) continue;
+		const dir = file.slice(0, file.lastIndexOf("/"));
+		let after_from = false;
+		for (const line of src.split("\n")) {
+			const t = line.trim();
+			const was_after = after_from;
+			if (t) after_from = t.endsWith("from") || t === "import";
+			if (!line.includes(leaf)) continue;
+			if (!was_after && !line.includes("import") && !line.includes("from")) continue;
+			for (const q of ["'", "\""]) {
+				const end = line.indexOf(`${leaf}${q}`);
+				if (end === -1) continue;
+				const start = line.lastIndexOf(q, end) + 1;
+				const spec = line.slice(start, end + leaf.length);
+				if (spec.startsWith("$lib/")) out.add("lib/" + spec.slice(5));
+				else if (spec.startsWith(".")) {
+					const parts = dir.split("/");
+					for (const seg of spec.split("/")) if (seg === "..") parts.pop();
+					else if (seg !== ".") parts.push(seg);
+					out.add(parts.join("/"));
+				}
+			}
+		}
+	}
+	return out;
+}
+/**
+* THE APP MODULES A SERVER FILE IMPORTS: each `$lib/…` or relative import of a script module
+* (`.svelte` files and packages left out), src-relative and resolved against the file's folder —
+* the candidates to read, each as written (no extension) and with `.ts` / `.js` / `/index.ts` /
+* `/index.js`. One file's `import … from '…'` and `export … from '…'` lines; no regex.
+*/
+function module_imports(file, src) {
+	const dir = file.slice(0, file.lastIndexOf("/"));
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const line of src.split("\n")) {
+		const t = line.trim();
+		if (!(t.startsWith("import") || t.startsWith("export") || t.startsWith("}") || t.startsWith("'") || t.startsWith("\""))) continue;
+		for (const q of ["'", "\""]) {
+			const a = line.indexOf(q);
+			const b = a === -1 ? -1 : line.indexOf(q, a + 1);
+			if (b === -1) continue;
+			const spec = line.slice(a + 1, b);
+			if (spec.endsWith(".svelte") || !(spec.startsWith("$lib/") || spec.startsWith("./") || spec.startsWith("../"))) continue;
+			let base;
+			if (spec.startsWith("$lib/")) base = "lib/" + spec.slice(5);
+			else {
+				const parts = dir ? dir.split("/") : [];
+				for (const seg of spec.split("/")) if (seg === "..") parts.pop();
+				else if (seg !== ".") parts.push(seg);
+				base = parts.join("/");
+			}
+			const stem = base.endsWith(".js") ? base.slice(0, -3) : base;
+			for (const c of base.endsWith(".ts") ? [base] : [
+				stem + ".ts",
+				stem + ".js",
+				base,
+				stem + "/index.ts",
+				stem + "/index.js"
+			]) if (!seen.has(c)) {
+				seen.add(c);
+				out.push(c);
+			}
+			break;
+		}
+	}
+	return out;
+}
+export { module_imports, route_imports };

package/dist/profiler/saving.d.ts

@@ -0,0 +1,22 @@
+/**
+ * What a set of savings (each already one per group: no two share a line) takes off one render of
+ * `now` ms together. EACH RESOURCE CAPPED BY WHAT THE RENDER USED: every saving on the clock (the
+ * wait fixes and the waits deleted) takes off at most the render's waiting; every CPU saving at most
+ * its CPU. Past that they overlap in a way the lines do not show.
+ */
+export declare function saving_of(set: readonly {
+  ms: number;
+  wait: boolean;
+  kind: string;
+}[], caps: {
+  wait?: number;
+  cpu?: number;
+}, now: number): {
+  cpu: number;
+  wait: number;
+  del: number;
+  /** of `del`, the CPU part (deleted work that ran, not waited) */
+  del_cpu: number;
+  after: number;
+  clamped: boolean;
+};

package/dist/profiler/saving.js

@@ -0,0 +1,42 @@
+// src/profiler/saving.ts
+/**
+* What a set of savings (each already one per group: no two share a line) takes off one render of
+* `now` ms together. EACH RESOURCE CAPPED BY WHAT THE RENDER USED: every saving on the clock (the
+* wait fixes and the waits deleted) takes off at most the render's waiting; every CPU saving at most
+* its CPU. Past that they overlap in a way the lines do not show.
+*/
+function saving_of(set, caps, now) {
+	let cpu = 0;
+	let wait = 0;
+	let del_cpu = 0;
+	let del_wait = 0;
+	for (const s of set) if (s.kind === "unread-work") {
+		if (s.wait) del_wait += s.ms;
+		else del_cpu += s.ms;
+	} else if (s.wait) wait += s.ms;
+	else cpu += s.ms;
+	let clamped = false;
+	const cap = (a, b, limit) => {
+		if (limit === void 0 || !(limit >= 0) || a + b <= limit) return [a, b];
+		clamped = true;
+		const k = limit / (a + b);
+		return [a * k, b * k];
+	};
+	[wait, del_wait] = cap(wait, del_wait, caps.wait);
+	[cpu, del_cpu] = cap(cpu, del_cpu, caps.cpu);
+	const del = del_cpu + del_wait;
+	let total = cpu + wait + del;
+	if (total > now * .97) {
+		total = now * .97;
+		clamped = true;
+	}
+	return {
+		cpu,
+		wait,
+		del,
+		del_cpu,
+		after: now - total,
+		clamped
+	};
+}
+export { saving_of };