@ogygia/devtools 0.0.0-stage → 0.11.0

package/dist/profiler/site-fixes.js

@@ -0,0 +1,62 @@
+// src/profiler/site-fixes.ts
+/** keeping an answer, or the whole page, is a freshness decision per page, not one shared fix */
+const NOT_SHARED = /* @__PURE__ */ new Set([
+	"same-answer",
+	"almost-same-answer",
+	"same-document",
+	"almost-same-document"
+]);
+const bare = (t) => {
+	const i = t.lastIndexOf(" (");
+	return i !== -1 && (t.endsWith(" places)") || t.endsWith(" place)")) ? t.slice(0, i) : t;
+};
+function site_fixes(reports, limit = 8) {
+	const latest = /* @__PURE__ */ new Map();
+	for (const r of reports) {
+		const had = latest.get(r.page);
+		if (!had || r.created > had.created) latest.set(r.page, r);
+	}
+	const by = /* @__PURE__ */ new Map();
+	for (const r of latest.values()) {
+		const n = Math.max(1, r.runs);
+		for (const p of r.patterns ?? []) {
+			if (NOT_SHARED.has(p.kind) || p.kept_bytes || p.seed_bytes || !(p.save_ms > 0)) continue;
+			const per_render = p.wait ? p.save_ms : p.save_ms / n;
+			const cost = (s) => s.wait_ms ?? s.cpu_ms ?? 0;
+			const total = p.sites.reduce((t, s) => t + cost(s), 0);
+			for (const s of p.sites) {
+				const ms = per_render * (total > 0 ? cost(s) / total : 1 / p.sites.length);
+				if (ms <= 0) continue;
+				const where = s.module ?? s.file;
+				const key = `${p.kind}\0${where}\0${s.line}\0${(s.code ?? "").trim()}`;
+				const f = by.get(key) ?? by.set(key, {
+					kind: p.kind,
+					title: bare(p.title),
+					where,
+					line: s.line,
+					code: s.code,
+					pages: [],
+					total_ms: 0
+				}).get(key);
+				const on = f.pages.find((x) => x.page === r.page);
+				if (on) on.ms += ms;
+				else f.pages.push({
+					page: r.page,
+					ms,
+					report: r.id
+				});
+				f.total_ms += ms;
+			}
+		}
+	}
+	const r2 = (x) => Math.round(x * 100) / 100;
+	return [...by.values()].filter((f) => f.pages.length >= 2).map((f) => ({
+		...f,
+		total_ms: r2(f.total_ms),
+		pages: f.pages.map((x) => ({
+			...x,
+			ms: r2(x.ms)
+		})).sort((a, b) => b.ms - a.ms)
+	})).sort((a, b) => b.total_ms - a.total_ms).slice(0, limit);
+}
+export { site_fixes };

package/dist/profiler/source-scan.d.ts

@@ -0,0 +1,210 @@
+/**
+ * SOURCE SCAN — reading app code at report time, without regular expressions: a tokenizer, the
+ * extent of a function's body, a module's import aliases, the lines that call a name, and the
+ * names a wrapped function goes by. The line ledger (ledger.ts) and the pattern finder
+ * (patterns.ts) both read code through these, only for the handful of lines a report names.
+ */
+/** lines `from`..`to` of a source (1-based, inclusive), untrimmed */
+export type SourceReader = (path: string, from: number, to: number) => {
+  start: number;
+  lines: string[];
+} | undefined;
+/** One line of JS/TS as tokens: identifiers and keywords as they are, every string literal as
+ *  `""`, every number as `0`, punctuation one token each (`...`, `=>`, `+=`, `?.` kept whole).
+ *  Comments are dropped. A template literal is one string token followed by each `${…}` part's
+ *  own tokens in parentheses (`\`t${i + k}\`` → `""`, `(`, `i`, `+`, `k`, `)`), so the code inside
+ *  it is seen. */
+export declare function tokens(line: string): string[];
+/** The lines of a function from its first line to its closing brace (brace-balanced over tokens,
+ *  so braces in strings and comments do not count); a braceless arrow is its one line. Capped. */
+export declare function function_body(source: SourceReader, path: string, start: number, max?: number): {
+  start: number;
+  lines: string[];
+} | undefined;
+/** A module's import aliases: `import { renderToString as render } from 'x'` → renderToString → [render]. */
+export declare function import_aliases(source: SourceReader, path: string): Map<string, string[]>;
+/** The names a function also goes by in its module when it is WRAPPED:
+ *  `const renderToString = instrument(render, 'ds.render')` → render → [renderToString].
+ *  The shape is `const|let|var X = <call chain>(name` — the function is the wrapper's first argument. */
+export declare function wrapper_aliases(source: SourceReader, path: string): Map<string, string[]>;
+/** how V8 names a compiled regular expression's code in a CPU profile: `RegExp: ^(\w+\s?)*$` */
+export declare const REGEXP_FRAME = "RegExp: ";
+/**
+ * CAN THIS PATTERN BACKTRACK HARD? A repeated group that itself repeats something (`(\w+\s?)*`,
+ * `(a+)+`, `(?:x*y?)+`): the engine can split the same text many ways and tries them all before a
+ * match fails. (A repeated choice, `(a|aa)+`, can too, but `(foo|bar)+` is the usual one and
+ * harmless: not claimed.) A character scan, not a parse: escapes and classes are skipped over.
+ */
+export declare function backtracks(source: string | undefined): boolean;
+/**
+ * THE REGEX LITERALS WRITTEN ON A LINE (their source, without the slashes and flags): a `/` where
+ * an expression starts (after `(`, `,`, `=`, `:`, `[`, `!`, `&`, `|`, `?`, `{`, `;`, `return`, or
+ * at the start) opens one. Strings, template text and comments are skipped; a division is not a
+ * literal (it follows a value).
+ */
+export declare function regex_literals(code: string): string[];
+/** does this line call `name(` (plain or as a method), outside strings and comments? */
+export declare function calls_name(line: string, names: readonly string[]): boolean;
+/** The functions a hooks file's `handle` is made of, when they live in OTHER app modules:
+ *  `export const handle = sequence(ds_ssr, auth)` with `import { ds_ssr } from '$lib/ds-ssr'` →
+ *  ds_ssr → `ds-ssr`. The value is the module's file stem, so a CPU frame counts as that handle
+ *  only when it is named so AND sits in that file. A handle written in the hooks file itself is
+ *  not listed (its frames are in the hooks file already), and neither is one from a package (a
+ *  library's frames say what they are) or one made by a call (`auth()`: what it returns has its
+ *  own name). */
+export declare function handle_parts(source: SourceReader, path: string): Map<string, string>;
+/**
+ * WHERE EACH RETURNED KEY COMES FROM: the lines of a `load` whose values end up in each key of its
+ * `return { … }` — a key's expression, the variables it reads, the lines that declare or fill those
+ * (`const live = await fetch(…)`, `stock.push(await stockOf(…))`), and so on back through what they
+ * read. 1-based line numbers of `source`. A wait made on one of a key's lines is a wait for that
+ * key. Tokens only (no regex); null when there is no `load` or its return is not an object literal.
+ */
+/**
+ * WHERE A FILE'S `load` IS: its `export` line, and the lines its block body opens and closes on
+ * (0-based). `export async function load(…): Promise<{ a: string }> {` — the return type's braces
+ * are skipped; `export const load = async (…) => {` — the block after its arrow (a `satisfies`
+ * wrapper around it too). An expression body (`=> ({ … })`) has no block: null, never the next
+ * function in the file.
+ */
+export declare function load_span(T: readonly (readonly string[])[]): {
+  head: number;
+  body0: number;
+  body1: number;
+} | null;
+export declare function key_sources(source: string): Map<string, number[]> | null;
+/** One line's reads and writes: the names it declares or assigns (`const a =`, `a =`, `a += `,
+ *  `a[k] =`), the receivers it fills (`list.push(…)`), and the variables it reads (not a property,
+ *  not a callback's own parameter, not a name it only writes). `declared`: written by a
+ *  declaration (fresh each time the line runs: never carried from one loop turn to the next). */
+export declare function line_rw(line: string): {
+  reads: string[];
+  writes: string[];
+  declared: string[];
+  accum: string[];
+};
+/**
+ * DOES THE LATER CALL NEED THE EARLIER ONE'S ANSWER? Two lines of one file: true when `to` reads a
+ * name `from` wrote, directly or through the lines between (`const a = await x()` → `const id =
+ * a.id` → `await y(id)`). One line (a loop making the calls): true when a turn feeds the next — a
+ * name assigned (not declared) on it or the few lines after it, that it reads (`cursor = (await
+ * get(cursor)).next`). Then the calls cannot run together, and "waits in a row" is not a fix.
+ */
+export declare function needs_previous(source: SourceReader, path: string, from: number, to: number): boolean;
+/**
+ * WHAT THE PAGE WAITED ON THE LAYOUT FOR: in a load that does `await parent()`, the line doing it,
+ * the names it sets (`const { session } = await parent()` → session), and the first line after it
+ * that reads one of them (null: none does). The `await`s in between waited on the layout's loads
+ * for data they never used. 1-based lines; null when there is no `await parent()`.
+ */
+export declare function parent_use(source: string): {
+  line: number;
+  names: string[];
+  first_use: number | null;
+  awaits_before_use: number;
+} | null;
+/**
+ * THE SAME WORK EVERY REQUEST: the `const` lines of a `load` whose value depends on nothing the
+ * request brings — only on the module's own imports and top-level values, pure globals, and other
+ * such lines (`const valid = validateAll(PRODUCTS)`, then `const joined = attachBrands(valid)`).
+ * Each request computes the same thing again; computed once at module load, it costs nothing.
+ * Not a line that awaits (I/O is `same-answer`'s), nor one that reads the load's arguments
+ * (`url`, `params`, `locals`, …), a `let`, or anything the file does not declare. `calls`: the
+ * functions it runs (whose time is the line's cost). 1-based lines.
+ */
+export declare function constant_work(source: string): {
+  line: number;
+  names: string[];
+  calls: string[];
+}[];
+/** with `spans`: EVERY constant `const` statement (a cheap alias too, `work: false`), each with its
+ *  last line — what moves to module scope together, since one can read another */
+export declare function constant_work(source: string, spans: true): {
+  line: number;
+  end: number;
+  names: string[];
+  calls: string[];
+  work: boolean;
+}[];
+/**
+ * THE MOVE, CHECKED: which of the load's constant statements go to the file's top level (the costly
+ * ones and what they read, nothing else) and the line they go above (the load's `export`, 1-based).
+ * Null when moving them could change what the file does:
+ * - the file declares a top-level `const` / `let` / `var` / `class` AFTER the load. A moved call can
+ *   run a helper that reads it before it is set (its temporal dead zone), so no line is safe to move
+ *   above it;
+ * - a moved name is already a top-level name of the file (an import, a const, a function).
+ */
+export declare function hoist_plan(source: string): {
+  above: number;
+  stmts: {
+    line: number;
+    end: number;
+    names: string[];
+  }[];
+} | null;
+/**
+ * THE LOOPS IN A COMPONENT'S MARKUP: each `{#each … as …}` block, the page-data key it walks
+ * (`data.results`, `page.data.results` → results), and the components rendered inside it
+ * (`<ResultCard …>`, nested blocks included). What decides how many times a child renders.
+ * 1-based lines.
+ */
+export declare function each_blocks(svelte: string): {
+  line: number;
+  key?: string;
+  components: string[];
+}[];
+/**
+ * DATA ONLY A LATE ISLAND NEEDS: in a page's markup, the page-data keys used ONLY as props of
+ * islands imported to wake late (`import Reviews from './Reviews.svelte' with { wake: 'visible' }`
+ * — or `idle`, `interaction`), never in the page's own markup or an eager island. The page waits
+ * for that data on every request for something seen later, if at all. An island already
+ * `render: 'deferred'` fetches later by itself and is not one. 1-based lines of each use.
+ */
+export declare function late_island_keys(svelte: string): {
+  key: string;
+  island: string;
+  wake: string;
+  line: number;
+}[];
+/** What a `load` takes from the request: the names in its parameter list (`async ({ url, cookies })`
+ *  → url, cookies). Empty when it takes nothing; null when there is no load. */
+export declare function load_inputs(source: string): string[] | null;
+/**
+ * THE CHANGE, WRITTEN: awaits in a row as one `Promise.all` — when they are plain one-line
+ * statements (`const user = await get('user');`), next to each other (blank and comment lines
+ * between are fine; any other statement between could feed a later call, so none is), the rewrite
+ * only moves the later calls up to start with the first. The caller has already proved no call
+ * reads what an earlier one produced. `lines`: the source from the first line to the last (1-based
+ * `start`); `at`: the chain's lines. Undefined when the shape is anything else.
+ */
+export declare function promise_all_rewrite(lines: readonly string[], start: number, at: readonly number[]): {
+  before: string;
+  after: string;
+} | undefined;
+/**
+ * THE CHANGE, WRITTEN, for a formatter built on every call: `new Intl.NumberFormat(locale, {…})` on
+ * a line. Arguments that read nothing (literals only) → one formatter at the top of the file, used
+ * on the line. Arguments that read variables → a cached factory at the top (one formatter per
+ * locale + options, built once) called on the line in place of `new Intl.X(`. A `.localeCompare(y,
+ * 'de', {…})` with literal arguments → one `Intl.Collator`'s `compare`. `ts`: the file is TypeScript
+ * (the factory is typed). Undefined when the line is anything else.
+ */
+export declare function formatter_rewrite(line: string, opts: FormatterRewriteOptions): {
+  before: string;
+  after: string;
+} | undefined;
+export interface FormatterRewriteOptions {
+  /** the file is TypeScript: the factory is typed */
+  ts: boolean;
+  /** a component: the addition goes in `<script module>` (its instance script runs per render) */
+  svelte?: boolean;
+  /** every name the file already uses; the names this adds join it */
+  taken?: Set<string>;
+  /** what earlier rewrites in the same file added (what → name): the same formatter is reused */
+  made?: Map<string, string>;
+}
+/** The functions a set of lines names — called (`newestReview(x)`) or handed over (`.sort(byName)`):
+ *  every bare identifier on them (not a property, not a keyword). What a CPU row by that name, run
+ *  from a helper file with no line of the load on its samples, was working for. */
+export declare function names_on(source: string, lines: readonly number[]): string[];