@ogygia/devtools 0.12.0 → 0.13.0

package/dist/profiler/index.d.ts

@@ -18,6 +18,7 @@ import { Forecast } from "./forecast.js";
 import { HeapGrowth, Pattern } from "./patterns.js";
 import { SpanRecord } from "./span.js";
 import { PageAssets } from "@ogygia/core/insights";
+import { Flights } from "@ogygia/machine";
 import { Handle } from "@ogygia/core/plugin";
 export interface ProfilerOptions {
   /**
@@ -114,7 +115,7 @@ export interface ProfilerOptions {
    * own copies). Not a `devtools({ profiler })` option: a store is a live object the build-time
    * options cannot carry, so the app sets it at runtime with `setProfilerStore(store)` from
    * `@ogygia/devtools/profiler/storage`, in hooks.server.ts, and the server half passes it in here
-   * when the profiler mounts. A store is `sqliteStore(...)`, `redisStore(...)` or `postgresStore(...)`
+   * when the profiler mounts. A store is `new SqliteStore(…)`, `new RedisStore(…)` or `new PostgresStore(…)`
    * from `@ogygia/devtools/profiler/storage/{sqlite,redis,postgres}`, or your own; every finished
    * report is written there and read back from there, so it survives the instance that made it and
    * a whole team shares one list. The store is dual-written: memory stays the hot cache, the store
@@ -147,7 +148,9 @@ export interface TrapStatus {
   window_ms: number;
   caught: number;
   keep: number;
-  armed: boolean;
+  /** `armed`: it waits for or takes its next window; `stopped`: a window failed (the dashboard's
+   *  note says why); `done`: it kept all it was asked to, or is not armed yet */
+  state: "armed" | "done" | "stopped";
 }
 interface UserTiming {
   name: string;
@@ -262,6 +265,24 @@ export interface StoredReport {
  * stacks); `null` for anything not shaped like a trace. Exported for the tests.
  */
 export declare function self_profile_to_cpuprofile(trace: unknown): CpuProfile | null;
+/** A report's fetch of one of the app's files, through the app (`signal`: the weigh gave up). */
+type FetchUrl = (url: string, signal?: AbortSignal) => Promise<Response>;
+/** What one weigh is handed: the URL (its key), and the fetch of the report that asked. */
+type WeighAsk = {
+  url: string;
+  fetch_url: FetchUrl;
+};
+/** Bytes per asset URL (`null`: the file is not there), measured once per process: a hashed
+ *  asset never changes. */
+type UrlWeights = Flights<WeighAsk, number | null, Pick<WeighAsk, "url">>;
+/** The process's URL weights: an answer (bytes, or a file that is not there) is kept; a failure
+ *  (a 5xx, a timeout, the network) is not, so the next report asks again. Reports weighing the
+ *  same file at once share one fetch. */
+export declare const url_weights: () => UrlWeights;
+/** GET each URL through the app's own fetch and count its bytes — the JS weight of an island's
+ *  closure. Kept per process (`url_weights`), a handful at a time, capped in time so a slow static
+ *  host can never hold a report hostage: a URL not weighed within the budget is left out. */
+export declare function weigh_urls(urls: Iterable<string>, fetch_url: FetchUrl, weights: UrlWeights, budget_ms?: number): Promise<Record<string, number>>;
 /**
  * Build a profiler handle. INTERNAL — the profiler is configured in vite.config.ts
  * (`ogygia({ profiler: true })`) and `ogygia.handle()` constructs + mounts this itself.