@ogygia/devtools 0.12.0 → 0.13.0

package/dist/profiler/net.d.ts

@@ -1,4 +1,5 @@
 import { register_profiler_file } from "./frames.js";
+import { Scope } from "@ogygia/machine";
 import { AsyncLocalStorage } from "node:async_hooks";
 export interface NetCall {
   /** performance.now() at call start */
@@ -71,7 +72,10 @@ export interface ServerTiming {
   desc?: string;
 }
 export declare function parse_server_timing(header: string | null | undefined): ServerTiming[] | undefined;
-export declare function set_stack_capture(on: boolean): void;
+/** Turns `owner`'s ask for call stacks on or off. They are captured while any recording asks, so
+ *  the first of two overlapping recordings to end (two profilers in one dev process) never turns
+ *  them off under the other. */
+export declare function set_stack_capture(owner: object, on: boolean): void;
 /** A caller location as the bundler sees it — resolved to source later, at
  * report time, through the sourcemap resolver (we have no maps here). */
 export interface CallerSite {
@@ -100,12 +104,15 @@ export interface NetContext {
   /** the profiler's what-if render: an answer kept from the timed renders, for a call this request
    *  makes (`GET <url>`), instead of making it — undefined = make the call */
   answer?(method: string, url: string): Response | undefined;
+  /** the request's owner: what the capture reads for a call this request makes (the copy of its
+   *  body it counts) is let go when the request ends */
+  owner?: Scope;
 }
 type Emit = (call: NetCall) => void;
-/** start (clearing what was kept) or stop keeping answers */
-export declare function keep_answers(on: boolean): void;
-/** drop every kept answer */
-export declare function drop_answers(): void;
+/** `owner` starts (the first recording to start clears what was kept) or stops keeping answers */
+export declare function keep_answers(owner: object, on: boolean): void;
+/** `owner` is done with the kept answers: dropped once no recording reads them */
+export declare function drop_answers(owner: object): void;
 /**
  * WHAT CHANGED IN AN ANSWER between the first render and the last: the one stretch that differs
  * (the bytes before it and after it are the same), and that stretch as text with a little around
@@ -121,7 +128,8 @@ export declare function kept_answer(key: string): Response | undefined;
 /**
  * Install the patches. `fallback` receives calls made outside any request
  * context (startup work, background jobs) so window recordings still see them.
- * Idempotent: a second call just re-asserts the fetch patch (see `ensure_fetch_patched`).
+ * A second call makes its own storage and fallback the live ones, and re-asserts the fetch patch
+ * (see `ensure_fetch_patched`).
  */
 export declare function install_net_capture(als: AsyncLocalStorage<NetContext>, fallback: Emit): Promise<void>;
 /**

package/dist/profiler/net.js

@@ -66,8 +66,14 @@ function parse_server_timing(header) {
 }
 const NET_STATE = Symbol.for("ogygia.profiler.net-state");
 const shared = globalThis[NET_STATE] ??= { stacks: false };
-function set_stack_capture(on) {
-	shared.stacks = on;
+/** Turns `owner`'s ask for call stacks on or off. They are captured while any recording asks, so
+*  the first of two overlapping recordings to end (two profilers in one dev process) never turns
+*  them off under the other. */
+function set_stack_capture(owner, on) {
+	const owners = shared.owners ??= /* @__PURE__ */ new Set();
+	if (on) owners.add(owner);
+	else owners.delete(owner);
+	shared.stacks = owners.size > 0;
 }
 register_profiler_file();
 /** The nearest first-party frame that issued an I/O call — skips node internals,
@@ -111,10 +117,10 @@ function nearest_app_frame() {
 	if (!s) return void 0;
 	return `${s.fn} (${base_name(s.file)}:${s.line})`;
 }
-let installed = false;
-let net_emit = null;
-/** the current request's kept-answer lookup (its context's `answer`), set by install */
-let net_answer = null;
+/** A call goes to the live profiler (nowhere before one installed). */
+function emit(call) {
+	shared.emit?.(call);
+}
 const KEEP_ONE = 1048576;
 const KEEP_ALL = 8388608;
 let keep_bodies = false;
@@ -122,21 +128,32 @@ let kept_bytes = 0;
 const kept = /* @__PURE__ */ new Map();
 /** each GET's FIRST answer in the recording too: against the last, what changed between renders */
 const kept_first = /* @__PURE__ */ new Map();
-/** start (clearing what was kept) or stop keeping answers */
-function keep_answers(on) {
-	keep_bodies = on;
-	if (on) {
-		kept.clear();
-		kept_first.clear();
-		kept_bytes = 0;
-	}
-}
-/** drop every kept answer */
-function drop_answers() {
+/** The recordings keeping answers now, and the ones still reading what was kept (a recording stops
+*  keeping after its timed renders, and reads them in its keep-the-answers renders after). Each
+*  recording turns only its own on and off: one that ends never stops or drops another's. */
+const keepers = /* @__PURE__ */ new Set();
+const readers = /* @__PURE__ */ new Set();
+function clear_kept() {
 	kept.clear();
 	kept_first.clear();
 	kept_bytes = 0;
 }
+/** `owner` starts (the first recording to start clears what was kept) or stops keeping answers */
+function keep_answers(owner, on) {
+	if (on) {
+		if (readers.size === 0) clear_kept();
+		keepers.add(owner);
+		readers.add(owner);
+	} else keepers.delete(owner);
+	keep_bodies = keepers.size > 0;
+}
+/** `owner` is done with the kept answers: dropped once no recording reads them */
+function drop_answers(owner) {
+	keepers.delete(owner);
+	readers.delete(owner);
+	keep_bodies = keepers.size > 0;
+	if (readers.size === 0) clear_kept();
+}
 /**
 * WHAT CHANGED IN AN ANSWER between the first render and the last: the one stretch that differs
 * (the bytes before it and after it are the same), and that stretch as text with a little around
@@ -176,11 +193,13 @@ const OG_FETCH_PATCH = Symbol.for("ogygia.profiler.net.fetch-patch");
 /**
 * Install the patches. `fallback` receives calls made outside any request
 * context (startup work, background jobs) so window recordings still see them.
-* Idempotent: a second call just re-asserts the fetch patch (see `ensure_fetch_patched`).
+* A second call makes its own storage and fallback the live ones, and re-asserts the fetch patch
+* (see `ensure_fetch_patched`).
 */
 async function install_net_capture(als, fallback) {
-	net_answer = (method, url) => als.getStore()?.answer?.(method, url);
-	net_emit = (call) => {
+	shared.answer = (method, url) => als.getStore()?.answer?.(method, url);
+	shared.owner = () => als.getStore()?.owner;
+	shared.emit = (call) => {
 		const ctx = als.getStore();
 		if (ctx) {
 			call.route = ctx.route;
@@ -188,13 +207,10 @@ async function install_net_capture(als, fallback) {
 			ctx.on_net(call);
 		} else fallback(call);
 	};
-	if (installed) {
-		ensure_fetch_patched();
-		return;
-	}
-	installed = true;
-	patch_fetch(net_emit);
-	await patch_http(net_emit);
+	patch_fetch();
+	if (shared.http_patched) return;
+	shared.http_patched = true;
+	await patch_http();
 }
 /**
 * Re-assert the `globalThis.fetch` patch. `globalThis.fetch` can be REPLACED out from under us after
@@ -205,10 +221,7 @@ async function install_net_capture(als, fallback) {
 * call every request/run.
 */
 function ensure_fetch_patched() {
-	if (!net_emit) return;
-	const cur = globalThis.fetch;
-	if (typeof cur === "function" && cur[OG_FETCH_PATCH]) return;
-	patch_fetch(net_emit);
+	if (shared.emit) patch_fetch();
 }
 const INTERNAL_HEADER = "x-og-profiler-internal";
 function is_internal(input, init) {
@@ -226,11 +239,11 @@ function host_of(url) {
 		return "";
 	}
 }
-function patch_fetch(emit) {
+function patch_fetch() {
 	const orig = globalThis.fetch;
 	if (typeof orig !== "function") return;
 	if (orig[OG_FETCH_PATCH]) return;
-	globalThis.fetch = wrap_fetch(orig, emit);
+	globalThis.fetch = wrap_fetch(orig);
 }
 /**
 * KIT'S OWN `event.fetch` never reaches the global one for a same-origin call: it dispatches the
@@ -239,8 +252,8 @@ function patch_fetch(emit) {
 * the same recorder. Idempotent (the brand), nothing when capture is not installed.
 */
 function wrap_event_fetch(f) {
-	if (!net_emit || typeof f !== "function" || f[OG_FETCH_PATCH]) return f;
-	return wrap_fetch(f, net_emit);
+	if (!shared.emit || typeof f !== "function" || f[OG_FETCH_PATCH]) return f;
+	return wrap_fetch(f);
 }
 /** the request header that asks, and the response header that answers */
 const TRACE_HEADER = "x-og-trace";
@@ -281,13 +294,13 @@ function decode_trace(h) {
 	}
 }
 /** The recording wrapper around a fetch-shaped function: one NetCall per call, timed to headers
-*  and body, the caller captured while a recording runs. */
-function wrap_fetch(orig, emit) {
+*  and body, the caller captured while a recording runs, handed to the live profiler. */
+function wrap_fetch(orig) {
 	const patched = async function fetch(input, init) {
 		if (is_internal(input, init)) return orig(input, init);
 		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input?.url ?? "";
 		const method = init?.method ?? (input?.method || "GET");
-		const canned = net_answer?.(method.toUpperCase(), url);
+		const canned = shared.answer?.(method.toUpperCase(), url);
 		if (canned) return canned;
 		const call = {
 			start: performance.now(),
@@ -335,7 +348,7 @@ function wrap_fetch(orig, emit) {
 			call.timings = parse_server_timing(res.headers.get("server-timing"));
 			const trace = decode_trace(res.headers.get(TRACE_HEADER));
 			if (trace) call.trace = trace;
-			count_decoded(res, call);
+			count_decoded(res, call, shared.owner?.());
 			wrap_body(res, call);
 			return res;
 		} catch (e) {
@@ -419,8 +432,10 @@ function capture_req_payload(init, call) {
 /** a body is fingerprinted over this many bytes at most (with its full length) */
 const BODY_HASH_MAX = 4194304;
 /** Count the DECODED response body size by draining a CLONE in the background (the original is left
-*  untouched). Sets `call.bytes` when done — the render finishes first, so it's ready by report time. */
-function count_decoded(res, call) {
+*  untouched). Sets `call.bytes` when done — the render finishes first, so it's ready by report time.
+*  The clone is the request's (`owner`): when the request ends it is let go, so a body that never
+*  ends is not read for good. */
+function count_decoded(res, call, owner) {
 	let clone;
 	try {
 		clone = res.clone();
@@ -434,6 +449,7 @@ function count_decoded(res, call) {
 	(async () => {
 		try {
 			const reader = stream.getReader();
+			owner?.defer(() => void reader.cancel().catch(() => {}));
 			let total = 0;
 			let parts = keep ? [] : null;
 			let h = 2166136261;
@@ -481,7 +497,7 @@ function count_decoded(res, call) {
 		} catch {}
 	})();
 }
-async function patch_http(emit) {
+async function patch_http() {
 	for (const proto of ["http", "https"]) {
 		let mod;
 		try {
@@ -498,18 +514,18 @@ async function patch_http(emit) {
 		try {
 			mod.request = function(...args) {
 				const req = orig_request.apply(this, args);
-				instrument_client_request(req, args, proto, emit);
+				instrument_client_request(req, args, proto);
 				return req;
 			};
 			if (typeof orig_get === "function") mod.get = function(...args) {
 				const req = orig_get.apply(this, args);
-				instrument_client_request(req, args, proto, emit);
+				instrument_client_request(req, args, proto);
 				return req;
 			};
 		} catch {}
 	}
 }
-function instrument_client_request(req, args, proto, emit) {
+function instrument_client_request(req, args, proto) {
 	const r = req;
 	if (typeof r?.on !== "function") return;
 	let url = "";

package/dist/profiler/patterns.js

@@ -1334,6 +1334,33 @@ const CHAIN_GAP_MS = 10;
 const CHAIN_MIN = 3;
 const CHAIN_MIN_MS = 20;
 /**
+* The calls that started together (under 1 ms apart) with another call from the same calling line:
+* one of a batch run in parallel (a `Promise.all`). Each calling line's calls are sorted by start
+* once, so the call that started nearest to one is beside it.
+*/
+function batched_calls(calls) {
+	const by_line = /* @__PURE__ */ new Map();
+	for (const c of calls) {
+		const line = c.outer?.line ?? c.at?.line;
+		if (Number.isNaN(line) || !Number.isFinite(c.start)) continue;
+		const path = c.outer?.path ?? c.at?.path;
+		let lines = by_line.get(path);
+		if (!lines) by_line.set(path, lines = /* @__PURE__ */ new Map());
+		let same = lines.get(line);
+		if (!same) lines.set(line, same = /* @__PURE__ */ new Set());
+		same.add(c);
+	}
+	const out = /* @__PURE__ */ new Set();
+	for (const lines of by_line.values()) for (const same of lines.values()) {
+		const sorted = [...same].sort((a, b) => a.start - b.start);
+		for (let i = 1; i < sorted.length; i++) if (Math.abs(sorted[i].start - sorted[i - 1].start) < 1) {
+			out.add(sorted[i]);
+			out.add(sorted[i - 1]);
+		}
+	}
+	return out;
+}
+/**
 * THE WAITS IN A ROW: calls made from ONE line whose waits did not overlap — each started after
 * the one before it ended — so the line waited for them one by one (`for (…) await fetch(…)`).
 * Measured, not guessed: the sum of the waits is what the line cost in wall time, the longest
@@ -1367,7 +1394,8 @@ function find_wait_patterns(input) {
 		if (g.length < 2) continue;
 		g.sort((a, b) => a.start - b.start);
 		const runs = [];
-		const batched = (c) => g.some((o) => o !== c && Math.abs(o.start - c.start) < 1 && (o.outer?.line ?? o.at?.line) === (c.outer?.line ?? c.at?.line) && (o.outer?.path ?? o.at?.path) === (c.outer?.path ?? c.at?.path));
+		const in_batch = batched_calls(g);
+		const batched = (c) => in_batch.has(c);
 		let run = batched(g[0]) ? [] : [g[0]];
 		for (let i = 1; i < g.length; i++) {
 			if (batched(g[i])) {

package/dist/profiler/source-scan.js

@@ -1049,6 +1049,7 @@ function constant_work(source, spans = false) {
 			});
 		}
 	}
+	const helper_names = new Set(helpers.map((h) => h.name));
 	const impure = (t) => {
 		for (let k = 0; k < t.length; k++) {
 			const x = t[k];
@@ -1056,21 +1057,31 @@ function constant_work(source, spans = false) {
 			if (per_call.has(x) || PER_CALL_GLOBALS.has(x)) return true;
 			if (x === "Math" && t[k + 2] === "random") return true;
 			if (x === "Date" && (t[k + 2] === "now" || t[k - 1] === "new" && t[k + 1] === "(" && t[k + 2] === ")")) return true;
-			if (helpers.some((h) => h.name === x) && !module_names.has(x)) return true;
+			if (helper_names.has(x) && !module_names.has(x)) return true;
 		}
 		return changed_names(t).some((n) => state.has(n));
 	};
-	for (let dropped = true; dropped;) {
-		dropped = false;
-		for (const h of helpers) {
-			if (!module_names.has(h.name)) continue;
-			for (let i = h.from; i <= h.to; i++) if (impure(T[i])) {
-				module_names.delete(h.name);
-				dropped = true;
-				break;
-			}
+	const named_by = /* @__PURE__ */ new Map();
+	for (const h of helpers) for (let i = h.from; i <= h.to; i++) {
+		const t = T[i];
+		for (let k = 0; k < t.length; k++) if (helper_names.has(t[k]) && t[k - 1] !== "." && t[k - 1] !== "?.") {
+			const by = named_by.get(t[k]);
+			if (by) by.push(h.name);
+			else named_by.set(t[k], [h.name]);
 		}
 	}
+	const dropped = [];
+	for (const h of helpers) {
+		if (!module_names.has(h.name)) continue;
+		for (let i = h.from; i <= h.to; i++) if (impure(T[i])) {
+			dropped.push(h.name);
+			break;
+		}
+	}
+	while (dropped.length) {
+		const name = dropped.pop();
+		if (module_names.delete(name)) for (const by of named_by.get(name) ?? []) dropped.push(by);
+	}
 	const changed = /* @__PURE__ */ new Set();
 	for (let i = body0 + 1; i < body1; i++) for (const n of changed_names(T[i])) changed.add(n);
 	const local = /* @__PURE__ */ new Set();
@@ -1163,8 +1174,9 @@ function constant_work(source, spans = false) {
 			});
 		}
 	}
-	const mine = stmt_lines;
-	for (const o of out) o.calls = o.calls.filter((c) => !T.some((t, i) => i > body0 && i < body1 && !mine.has(i) && t.includes(c)));
+	const elsewhere = /* @__PURE__ */ new Set();
+	for (let i = body0 + 1; i < body1; i++) if (!stmt_lines.has(i)) for (const x of T[i]) elsewhere.add(x);
+	for (const o of out) o.calls = o.calls.filter((c) => !elsewhere.has(c));
 	return out;
 }
 /**

package/dist/profiler/storage/index.d.ts

@@ -13,8 +13,8 @@
  *
  *   // src/hooks.server.ts
  *   import { setProfilerStore } from '@ogygia/devtools/profiler/storage';
- *   import { sqliteStore } from '@ogygia/devtools/profiler/storage/sqlite';
- *   setProfilerStore(sqliteStore('.ogygia/profiles.db'));
+ *   import { SqliteStore } from '@ogygia/devtools/profiler/storage/sqlite';
+ *   setProfilerStore(new SqliteStore('.ogygia/profiles.db'));
  *
  * A report is stored as its portable dump (the same JSON the `.ogp` export and the agent view are
  * built from): `meta` + `analysis` + `extras`, plus a few summary columns for the list. Nothing
@@ -79,7 +79,18 @@ export interface ProfilerStore {
 /** An in-memory store — a Map with an LRU cap. The profiler without a store keeps reports in its own
  *  memory already, so this adds nothing there; it is for tests and a model for a custom store.
  *  Nothing survives a restart. */
-export declare function memoryStore(cap?: number): ProfilerStore;
+export declare class MemoryStore implements ProfilerStore {
+  #private;
+  readonly kind: string;
+  constructor(cap?: number);
+  putReport(rec: ProfilerRecord): void;
+  getReport(id: string): string | null;
+  listReports(limit?: number): ProfilerSummary[];
+  deleteReport(id: string): void;
+  prune(keep: number): void;
+  putVisit(rec: ProfilerVisitRecord): void;
+  listVisits(page: string, limit?: number): ProfilerVisitRecord[];
+}
 /** Pull the summary columns off a record for storing them alongside the dump. */
 export declare function recordColumns(rec: ProfilerRecord): ProfilerSummary;
 export declare function setProfilerStore(store: ProfilerStore): void;

package/dist/profiler/storage/index.js

@@ -2,45 +2,45 @@
 /** An in-memory store — a Map with an LRU cap. The profiler without a store keeps reports in its own
 *  memory already, so this adds nothing there; it is for tests and a model for a custom store.
 *  Nothing survives a restart. */
-function memoryStore(cap = 50) {
-	const reports = /* @__PURE__ */ new Map();
-	const visits = [];
-	return {
-		kind: "memory",
-		putReport(rec) {
-			reports.delete(rec.id);
-			reports.set(rec.id, rec);
-			while (reports.size > cap) {
-				const oldest = reports.keys().next().value;
-				if (oldest === void 0) break;
-				reports.delete(oldest);
-			}
-		},
-		getReport(id) {
-			return reports.get(id)?.dump ?? null;
-		},
-		listReports(limit = 30) {
-			return [...reports.values()].sort((a, b) => b.created - a.created).slice(0, limit).map(({ dump: _dump, ...s }) => s);
-		},
-		deleteReport(id) {
-			reports.delete(id);
-		},
-		prune(keep) {
-			while (reports.size > keep) {
-				const oldest = reports.keys().next().value;
-				if (oldest === void 0) break;
-				reports.delete(oldest);
-			}
-		},
-		putVisit(rec) {
-			visits.push(rec);
-			if (visits.length > 2e3) visits.shift();
-		},
-		listVisits(page, limit = 10) {
-			return visits.filter((v) => v.page === page).sort((a, b) => b.at - a.at).slice(0, limit);
+var MemoryStore = class {
+	kind = "memory";
+	#cap;
+	#reports = /* @__PURE__ */ new Map();
+	#visits = [];
+	constructor(cap = 50) {
+		this.#cap = cap;
+	}
+	putReport(rec) {
+		this.#reports.delete(rec.id);
+		this.#reports.set(rec.id, rec);
+		this.prune(this.#cap);
+	}
+	getReport(id) {
+		return this.#reports.get(id)?.dump ?? null;
+	}
+	listReports(limit = 30) {
+		return [...this.#reports.values()].sort((a, b) => b.created - a.created).slice(0, limit).map(({ dump: _dump, ...s }) => s);
+	}
+	deleteReport(id) {
+		this.#reports.delete(id);
+	}
+	prune(keep) {
+		const reports = this.#reports;
+		while (reports.size > keep) {
+			const oldest = reports.keys().next().value;
+			if (oldest === void 0) break;
+			reports.delete(oldest);
 		}
-	};
-}
+	}
+	putVisit(rec) {
+		const visits = this.#visits;
+		visits.push(rec);
+		if (visits.length > 2e3) visits.shift();
+	}
+	listVisits(page, limit = 10) {
+		return this.#visits.filter((v) => v.page === page).sort((a, b) => b.at - a.at).slice(0, limit);
+	}
+};
 /** Pull the summary columns off a record for storing them alongside the dump. */
 function recordColumns(rec) {
 	return {
@@ -59,8 +59,8 @@ function recordColumns(rec) {
 *
 *   // src/hooks.server.ts
 *   import { setProfilerStore } from '@ogygia/devtools/profiler/storage';
-*   import { postgresStore } from '@ogygia/devtools/profiler/storage/postgres';
-*   setProfilerStore(postgresStore(process.env.DATABASE_URL!));
+*   import { PostgresStore } from '@ogygia/devtools/profiler/storage/postgres';
+*   setProfilerStore(new PostgresStore(process.env.DATABASE_URL!));
 *
 * The profiler reads this when it mounts and every finished report is written there. Call it before
 * the profiler handles its first request; a later call is ignored (the instance already mounted).
@@ -73,4 +73,4 @@ function setProfilerStore(store) {
 function getProfilerStore() {
 	return globalThis[STORE_SLOT];
 }
-export { getProfilerStore, memoryStore, recordColumns, setProfilerStore };
+export { MemoryStore, getProfilerStore, recordColumns, setProfilerStore };

package/dist/profiler/storage/postgres.d.ts

@@ -1,12 +1,25 @@
-import { ProfilerStore } from "./index.js";
+import { ProfilerRecord, ProfilerStore, ProfilerSummary, ProfilerVisitRecord } from "./index.js";
 interface PgLike {
   query(text: string, params?: unknown[]): Promise<{
     rows: Record<string, unknown>[];
   }>;
   end?(): Promise<void>;
 }
-export declare function postgresStore(client: PgLike | string, opts?: {
-  schema?: string;
-  table?: string;
-}): ProfilerStore;
+export declare class PostgresStore implements ProfilerStore {
+  #private;
+  readonly kind: string;
+  constructor(client: PgLike | string, opts?: {
+    schema?: string;
+    table?: string;
+  });
+  init(): Promise<void>;
+  putReport(rec: ProfilerRecord): Promise<void>;
+  getReport(id: string): Promise<string | null>;
+  listReports(limit?: number): Promise<ProfilerSummary[]>;
+  deleteReport(id: string): Promise<void>;
+  prune(keep: number): Promise<void>;
+  putVisit(rec: ProfilerVisitRecord): Promise<void>;
+  listVisits(page: string, limit?: number): Promise<ProfilerVisitRecord[]>;
+  close(): Promise<void>;
+}
 export {};