@electron-stagewright/plugin-budget 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Electron Stagewright contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,215 @@
-# Temporary Holding Version
+# @electron-stagewright/plugin-budget
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Performance budgets for Electron apps: write the limits in one JSON file, measure a build, and fail
+the change that goes over. An agent asks `budget_check` whether its change broke a budget; CI runs the
+`electron-stagewright-budget` CLI. Both read the same budget file and the same run format.
+
+It measures startup to first window, memory per process type in the platform's own metric,
+main-thread blocking, IPC round-trip latency, and bundle size. The app needs no code change: the
+plugin samples through the session Stagewright already holds.
+
+## Load it
+
+```sh
+electron-stagewright --plugin budget --allow-eval
+```
+
+```js
+import { createServer } from '@electron-stagewright/core'
+import budgetPlugin from '@electron-stagewright/plugin-budget'
+
+const server = await createServer({
+  plugins: [budgetPlugin],
+  allowEval: true,
+  pluginConfigs: { budget: { budgetFile: '/abs/path/perf-budget.json' } },
+})
+```
+
+Config (`pluginConfigs.budget`): `budgetFile` (default budget for `budget_check`), `root` (where
+bundle paths resolve; defaults to the budget file's directory), `windowMs` (idle window, default 2000).
+
+| Metric                       | Needs                                              |
+| ---------------------------- | -------------------------------------------------- |
+| Memory, main-thread blocking | A session and main eval (`--allow-eval=main`)      |
+| IPC latency, startup         | The above plus renderer eval (bare `--allow-eval`) |
+| Bundle size                  | Nothing: no session, no eval                       |
+
+The bodies evaluated in the app are fixed. The one caller-supplied expression is the IPC probe (from
+`ipcProbe` or the budget file): it needs the renderer grant, passes the same blocklist as
+`electron_eval_renderer`, and leaves the same audit line. Bundle entries must resolve inside `root`,
+and with `--app-root` set the budget file and its entries must sit inside it.
+
+## Tools
+
+- **`budget_check`** `{ budgetPath?, sessionId?, windowMs?, strict?, requireMeasurement? }` — measure
+  the running app and the bundle entries and compare them to the budget. Returns
+  `{ passed, reason?, summary, results }`; each result is `pass`, `fail`, or `unmeasured` with the
+  reason. `passed` is false when a limit is exceeded and when nothing could be measured. Visible
+  without eval; then only the bundle is checked.
+- **`budget_start`** `{ budgetPath?, ipcProbe?, ipcIntervalMs?, sessionId? }` — open a measurement
+  window, then drive the app with the other tools. The next `budget_measure` or `budget_check` closes
+  it, so blocking and IPC latency cover the interaction instead of an idle app. A window nobody
+  reads stops itself after 10 minutes. Budget calls on one session run one at a time.
+- **`budget_measure`** `{ budgetPath?, ipcProbe?, windowMs?, sessionId? }` — the numbers without a
+  verdict: `{ measured: [{ id, value, unit, metric? }], unavailable? }`.
+
+Main-thread blocking is the lateness of a 10 ms timer in the main process: `blockedPercent` is the
+share of the window it ran 10 ms or more late, `maxStallMs` the worst single stall. The IPC probe
+times one round trip of the budget's `ipc.probe` expression every `intervalMs` (default 25).
+Startup is process creation to the end of the load event of the first window still open, whichever
+window is selected; it is `unmeasured` once that window reloaded or navigated. Memory is read on
+this host only when the host's process with the app's main pid started with the app, so an app in
+another pid namespace reports memory `unmeasured` instead of a stranger's numbers.
+
+## Budget file
+
+```jsonc
+{
+  "thresholdPercent": 10,
+  "startup": { "maxFirstWindowMs": 3000 },
+  "memory": {
+    "darwin": {
+      "metric": "footprint",
+      "phase": "warm",
+      "perTypeMb": { "main": 100, "renderer": 80, "utility": 10 },
+      "totalWithoutGpuMb": 160,
+    },
+    "win32": { "metric": "privateBytes", "perTypeMb": { "main": 90 } },
+    "linux": { "metric": "pss", "perTypeMb": { "main": 90 } },
+  },
+  "mainThread": { "windowMs": 5000, "maxBlockedPercent": 5, "maxStallMs": 100 },
+  "ipc": { "probe": "window.api.getVersion()", "maxP99Ms": 15 },
+  "bundle": {
+    "entries": [{ "path": "dist/renderer", "extensions": [".js"], "gzip": true, "maxKb": 500 }],
+  },
+}
+```
+
+- **Memory has one block per platform.** `footprint` (macOS), `pss` (Linux), `privateBytes`
+  (Windows) and `workingSet` count different things, so megabytes are only ever compared within the
+  metric the budget names. Every table prints the metric next to the value.
+- **Processes are summed per type** (`main`, `renderer`, `gpu`, `utility`, `other`). A type the
+  budget does not name is reported and never gates; GPU memory swings widely between machines, so
+  leave it out unless you mean to gate it.
+- **`thresholdPercent`** is the tolerance over each limit; a section may override it.
+- **`aggregate`** in a memory block is `end` (default) or `peak`; see Peak memory below.
+- **`memoryProbe`** (top level) is a renderer expression that resolves to `app.getAppMetrics()`,
+  for builds whose main process cannot be inspected.
+- **Phase.** `startup` reads `cold` unless it names a phase. A `memory` block that names none reads
+  the run's `warm` rounds, else `live`, else `cold`: a run of fresh-profile launches
+  (`--phases cold`) is gated on its cold rounds.
+- **Startup is not launch-to-ready.** `maxFirstWindowMs` is process creation to the end of the
+  first window's load event. Work the app does after that (opening a database, fetching data,
+  starting a server) is not in it, so a wall-clock launch budget converted to it gets looser
+  without saying so. Time that work in a workload, or keep it in its own gate.
+- **`$comment`** is allowed in every object. Unknown keys are rejected, so a typo cannot silently
+  disable a limit.
+
+## CLI
+
+```sh
+electron-stagewright-budget measure --main dist/main.js --budget perf-budget.json \
+  --rounds 5 --out run.json --check
+electron-stagewright-budget check run.json --budget perf-budget.json [--no-tolerance] [--require-measurement]
+electron-stagewright-budget compare before.json after.json
+electron-stagewright-budget bundle --budget perf-budget.json [--root <dir>] [--out run.json]
+```
+
+- `measure` launches the app (`--main <main.js>`, or `--executable <path>` for a packaged build;
+  repeat `--arg` and `--env K=V` to pass them through) on an empty throwaway profile. Each round is
+  a `cold` launch and a `warm` relaunch on the same profile (`--phases` picks one). It waits for
+  the window to load, settles (`--settle-ms`, default 3000), measures a window (`--window-ms`), and
+  writes the run. `--check` gates it in the same command; `--phase` reads every metric from one
+  measured phase, and a metric whose phase was not measured is `unmeasured`. On Linux CI run it
+  under `xvfb-run`.
+- `--workload <script.mjs>` replaces the idle window with your interaction. The module
+  default-exports `async ({ dispatch, sessionId, phase }) => { ... }`, where `dispatch(tool, args)`
+  calls any core Stagewright tool (plugin tools are not loaded) on the launched app. The workload
+  runs with your privileges and eval enabled, so pass only a script you trust. One that has not
+  finished after `--workload-timeout-ms` (default 120000) fails the command:
+
+  ```js
+  export default async ({ dispatch, sessionId }) => {
+    await dispatch('electron_click', { sessionId, selector: '#new-sale' })
+  }
+  ```
+
+- `--before-round <script.mjs>` prepares each round before its first launch. The module
+  default-exports `async ({ round, profile }) => ({ env, args })` (string values only); the
+  returned `env` and `args` are added to that round's launches. Use it to hand every launch its own copy of a fixture, so
+  rounds that share state do not skew the median.
+- `--skip-failed-rounds` reports a round whose launch or measurement failed and goes on. Pair it
+  with `--min-samples N` on the check: a metric with fewer than `N` measured launches is left
+  unmeasured instead of gated, and `--require-measurement` turns that into a failure. If every
+  round fails, the command fails with the first round's error (exit `2`):
+
+  ```sh
+  electron-stagewright-budget measure --main dist/main.js --budget perf-budget.json \
+    --rounds 3 --phases cold --before-round fresh-fixture.mjs --skip-failed-rounds \
+    --check --min-samples 2
+  ```
+
+- `bundle` measures the `bundle` entries (paths resolve from `--root`, default the budget file's
+  directory) and gates them. It needs no Electron and no display.
+- `check` compares run files to the budget. Several files (`check a.json b.json c.json`) are merged
+  into one run first, and values are the median over the rounds of a phase. `--min-samples N`
+  leaves a runtime metric with fewer than `N` measured rounds `unmeasured`. In code,
+  `mergeRuns(runs)` and `checkRun(run, budget, { minSamples })` do the same, and `measureApp` takes
+  `beforeRound` and `failedRounds: 'skip'`.
+- `compare` prints a before/after table of two runs.
+- `--no-tolerance` ignores `thresholdPercent`, so the limit itself gates. It does not turn warnings
+  into failures: every verdict already fails the command. `--strict` is a deprecated alias that
+  prints a warning. `--require-measurement` fails a budgeted metric the run did not measure;
+  without it that metric is listed as `unmeasured`.
+- `--json` prints the machine report instead of the table.
+
+To run the CLI from a script, resolve it instead of guessing a path inside `dist/`:
+
+```js
+const cli = fileURLToPath(import.meta.resolve('@electron-stagewright/plugin-budget/cli'))
+// or, from CommonJS: require.resolve('@electron-stagewright/plugin-budget/cli')
+spawn(process.execPath, [cli, 'measure', '--main', 'dist/main.js', '--out', 'run.json'])
+```
+
+Exit codes: `0` within budget, `1` over budget **or nothing measured**, `2` usage error, unreadable
+input, or any other error. A bundle entry that matches no file is `unmeasured`, never zero bytes,
+and fails `bundle`. `measure` writes no run when no round produced a measurement.
+
+The inspector Stagewright attaches is part of what `measure` measures, so calibrate budgets with
+this tool.
+
+### Packaged builds with the inspect fuse off
+
+A release build with the `EnableNodeCliInspectArguments` fuse off has no main-process inspector.
+`measure --executable` still launches it (over CDP, through the renderer), and then:
+
+- **Memory** comes from the app itself. Expose `app.getAppMetrics()` to the renderer (for example
+  `ipcMain.handle('app-metrics', () => app.getAppMetrics())` plus a preload bridge), and name the
+  expression in the budget as `"memoryProbe": "window.api.appMetrics()"`. The host still reads
+  each pid in the platform metric. Keep the bridge out of builds users get if you do not want it
+  there.
+- **IPC latency** works as usual.
+- **Main-thread blocking and startup** are `unmeasured`, with the reason.
+
+### Peak memory
+
+`"aggregate": "peak"` in a memory block gates the heaviest moment of the window instead of its
+end: `measure` samples memory every second (`--memory-sample-ms` to change it, or to sample
+without the budget asking) and keeps the sample with the most memory outside the GPU as
+`memoryPeak`. Check rows are then `memoryPeak.main`, `memoryPeak.totalWithoutGpu`, and so on, and
+the median is taken over the rounds' peaks. Sampling through main adds a little main-thread work
+of its own, and a `memoryProbe` adds IPC round trips, so calibrate blocking and IPC budgets with
+the same setting. A round where no sample succeeded leaves `memoryPeak` unmeasured.
+
+## Library
+
+`@electron-stagewright/plugin-budget/check` holds the budget and run formats, `checkRun`, and the
+report renderers. It loads neither core nor the plugin, so a gate that only checks runs without the
+MCP SDK. The root export adds `measureApp`, `measureSession` and the plugin.
+
+```ts
+import { checkRun, loadBudget, loadRun } from '@electron-stagewright/plugin-budget/check'
+
+const report = checkRun(await loadRun('run.json'), await loadBudget('perf-budget.json'))
+if (!report.passed) console.error(report.results.filter((r) => r.status === 'fail'))
+```

package/dist/budget.d.ts

@@ -0,0 +1,143 @@
+/**
+ * The budget file: one JSON document naming the limits a build must stay under.
+ *
+ * @module
+ */
+import { z } from 'zod';
+/** OS memory metrics. They are not interchangeable, so a budget names exactly one per platform. */
+export declare const MEMORY_METRICS: readonly ["footprint", "pss", "privateBytes", "workingSet"];
+export type MemoryMetric = (typeof MEMORY_METRICS)[number];
+/** Process buckets, normalised from Electron's `app.getAppMetrics()` types. */
+export declare const PROCESS_TYPES: readonly ["main", "renderer", "gpu", "utility", "other"];
+export type ProcessType = (typeof PROCESS_TYPES)[number];
+/** `cold` is a first launch on an empty profile, `warm` a relaunch on it, `live` an agent session. */
+export declare const PHASES: readonly ["cold", "warm", "live"];
+export type Phase = (typeof PHASES)[number];
+export declare const BUDGET_PLATFORMS: readonly ["darwin", "win32", "linux"];
+export type BudgetPlatform = (typeof BUDGET_PLATFORMS)[number];
+declare const memoryPlatformSchema: z.ZodObject<{
+    metric: z.ZodEnum<{
+        footprint: "footprint";
+        pss: "pss";
+        privateBytes: "privateBytes";
+        workingSet: "workingSet";
+    }>;
+    phase: z.ZodOptional<z.ZodEnum<{
+        cold: "cold";
+        warm: "warm";
+        live: "live";
+    }>>;
+    aggregate: z.ZodOptional<z.ZodEnum<{
+        end: "end";
+        peak: "peak";
+    }>>;
+    thresholdPercent: z.ZodOptional<z.ZodNumber>;
+    perTypeMb: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        main: "main";
+        renderer: "renderer";
+        gpu: "gpu";
+        utility: "utility";
+        other: "other";
+    }> & z.core.$partial, z.ZodNumber>>;
+    totalWithoutGpuMb: z.ZodOptional<z.ZodNumber>;
+    totalMb: z.ZodOptional<z.ZodNumber>;
+    $comment: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const bundleEntrySchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    path: z.ZodString;
+    extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    gzip: z.ZodOptional<z.ZodBoolean>;
+    maxKb: z.ZodNumber;
+    $comment: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const budgetSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    thresholdPercent: z.ZodOptional<z.ZodNumber>;
+    memoryProbe: z.ZodOptional<z.ZodString>;
+    startup: z.ZodOptional<z.ZodObject<{
+        phase: z.ZodOptional<z.ZodEnum<{
+            cold: "cold";
+            warm: "warm";
+            live: "live";
+        }>>;
+        thresholdPercent: z.ZodOptional<z.ZodNumber>;
+        maxFirstWindowMs: z.ZodNumber;
+        $comment: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    memory: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        darwin: "darwin";
+        win32: "win32";
+        linux: "linux";
+    }> & z.core.$partial, z.ZodObject<{
+        metric: z.ZodEnum<{
+            footprint: "footprint";
+            pss: "pss";
+            privateBytes: "privateBytes";
+            workingSet: "workingSet";
+        }>;
+        phase: z.ZodOptional<z.ZodEnum<{
+            cold: "cold";
+            warm: "warm";
+            live: "live";
+        }>>;
+        aggregate: z.ZodOptional<z.ZodEnum<{
+            end: "end";
+            peak: "peak";
+        }>>;
+        thresholdPercent: z.ZodOptional<z.ZodNumber>;
+        perTypeMb: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+            main: "main";
+            renderer: "renderer";
+            gpu: "gpu";
+            utility: "utility";
+            other: "other";
+        }> & z.core.$partial, z.ZodNumber>>;
+        totalWithoutGpuMb: z.ZodOptional<z.ZodNumber>;
+        totalMb: z.ZodOptional<z.ZodNumber>;
+        $comment: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    mainThread: z.ZodOptional<z.ZodObject<{
+        thresholdPercent: z.ZodOptional<z.ZodNumber>;
+        windowMs: z.ZodOptional<z.ZodNumber>;
+        maxBlockedPercent: z.ZodOptional<z.ZodNumber>;
+        maxStallMs: z.ZodOptional<z.ZodNumber>;
+        $comment: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    ipc: z.ZodOptional<z.ZodObject<{
+        thresholdPercent: z.ZodOptional<z.ZodNumber>;
+        probe: z.ZodString;
+        intervalMs: z.ZodOptional<z.ZodNumber>;
+        maxP99Ms: z.ZodOptional<z.ZodNumber>;
+        maxP95Ms: z.ZodOptional<z.ZodNumber>;
+        $comment: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    bundle: z.ZodOptional<z.ZodObject<{
+        thresholdPercent: z.ZodOptional<z.ZodNumber>;
+        entries: z.ZodArray<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            path: z.ZodString;
+            extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            gzip: z.ZodOptional<z.ZodBoolean>;
+            maxKb: z.ZodNumber;
+            $comment: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        $comment: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    $comment: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type Budget = z.infer<typeof budgetSchema>;
+export type MemoryPlatformBudget = z.infer<typeof memoryPlatformSchema>;
+export type BundleEntryBudget = z.infer<typeof bundleEntrySchema>;
+/** A budget file that is missing, not JSON, or does not match {@link budgetSchema}. */
+export declare class BudgetFileError extends Error {
+    readonly code: 'BUDGET_NOT_FOUND' | 'BUDGET_INVALID';
+    readonly budgetPath?: string | undefined;
+    constructor(code: 'BUDGET_NOT_FOUND' | 'BUDGET_INVALID', message: string, budgetPath?: string | undefined);
+}
+/** Validate an already-parsed budget document. */
+export declare function parseBudget(raw: unknown, budgetPath?: string): Budget;
+/** Read and validate a budget file. */
+export declare function loadBudget(budgetPath: string): Promise<Budget>;
+export {};
+//# sourceMappingURL=budget.d.ts.map

package/dist/budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.d.ts","sourceRoot":"","sources":["../src/budget.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,mGAAmG;AACnG,eAAO,MAAM,cAAc,6DAA8D,CAAA;AACzF,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAA;AAE1D,+EAA+E;AAC/E,eAAO,MAAM,aAAa,0DAA2D,CAAA;AACrF,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAA;AAExD,sGAAsG;AACtG,eAAO,MAAM,MAAM,mCAAoC,CAAA;AACvD,MAAM,MAAM,KAAK,GAAG,CAAC,OAAO,MAAM,CAAC,CAAC,MAAM,CAAC,CAAA;AAE3C,eAAO,MAAM,gBAAgB,uCAAwC,CAAA;AACrE,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAA;AAM9D,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAWxB,CAAA;AAEF,QAAA,MAAM,iBAAiB;;;;;;;kBAQrB,CAAA;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsDvB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACjD,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACvE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEjE,uFAAuF;AACvF,qBAAa,eAAgB,SAAQ,KAAK;IAEtC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,GAAG,gBAAgB;IAEpD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM;gBAFnB,IAAI,EAAE,kBAAkB,GAAG,gBAAgB,EACpD,OAAO,EAAE,MAAM,EACN,UAAU,CAAC,EAAE,MAAM,YAAA;CAK/B;AAED,kDAAkD;AAClD,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAOrE;AAED,uCAAuC;AACvC,wBAAsB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAuBpE"}

package/dist/budget.js

@@ -0,0 +1,134 @@
+/**
+ * The budget file: one JSON document naming the limits a build must stay under.
+ *
+ * @module
+ */
+import { readFile } from 'node:fs/promises';
+import { z } from 'zod';
+/** OS memory metrics. They are not interchangeable, so a budget names exactly one per platform. */
+export const MEMORY_METRICS = ['footprint', 'pss', 'privateBytes', 'workingSet'];
+/** Process buckets, normalised from Electron's `app.getAppMetrics()` types. */
+export const PROCESS_TYPES = ['main', 'renderer', 'gpu', 'utility', 'other'];
+/** `cold` is a first launch on an empty profile, `warm` a relaunch on it, `live` an agent session. */
+export const PHASES = ['cold', 'warm', 'live'];
+export const BUDGET_PLATFORMS = ['darwin', 'win32', 'linux'];
+const comment = { $comment: z.string().optional() };
+const limit = z.number().positive();
+const thresholdPercent = z.number().min(0).max(1000).optional();
+const memoryPlatformSchema = z.strictObject({
+    ...comment,
+    metric: z.enum(MEMORY_METRICS),
+    phase: z.enum(PHASES).optional(),
+    // `end`: the sample taken when the window closes. `peak`: the window's highest sample outside GPU.
+    aggregate: z.enum(['end', 'peak']).optional(),
+    thresholdPercent,
+    // Summed per type. A type that is not named (GPU, typically) is reported but never gates.
+    perTypeMb: z.partialRecord(z.enum(PROCESS_TYPES), limit).optional(),
+    totalWithoutGpuMb: limit.optional(),
+    totalMb: limit.optional(),
+});
+const bundleEntrySchema = z.strictObject({
+    ...comment,
+    name: z.string().min(1).optional(),
+    // A file or a directory (summed recursively), relative to the budget file unless absolute.
+    path: z.string().min(1),
+    extensions: z.array(z.string().regex(/^\./, 'extensions start with a dot')).min(1).optional(),
+    gzip: z.boolean().optional(),
+    maxKb: limit,
+});
+export const budgetSchema = z.strictObject({
+    ...comment,
+    $schema: z.string().optional(),
+    thresholdPercent,
+    // Renderer expression resolving to `app.getAppMetrics()`, for a build whose main process cannot
+    // be inspected (the EnableNodeCliInspectArguments fuse off).
+    memoryProbe: z.string().min(1).optional(),
+    startup: z
+        .strictObject({
+        ...comment,
+        phase: z.enum(PHASES).optional(),
+        thresholdPercent,
+        maxFirstWindowMs: limit,
+    })
+        .optional(),
+    memory: z.partialRecord(z.enum(BUDGET_PLATFORMS), memoryPlatformSchema).optional(),
+    mainThread: z
+        .strictObject({
+        ...comment,
+        thresholdPercent,
+        windowMs: z.number().int().min(250).max(120_000).optional(),
+        maxBlockedPercent: z.number().min(0).max(100).optional(),
+        maxStallMs: limit.optional(),
+    })
+        .optional(),
+    ipc: z
+        .strictObject({
+        ...comment,
+        thresholdPercent,
+        // Renderer expression that performs one round trip, e.g. `window.api.getVersion()`.
+        probe: z.string().min(1),
+        intervalMs: z.number().int().min(1).max(1000).optional(),
+        maxP99Ms: limit.optional(),
+        maxP95Ms: limit.optional(),
+    })
+        .optional(),
+    bundle: z
+        .strictObject({ ...comment, thresholdPercent, entries: z.array(bundleEntrySchema).min(1) })
+        .superRefine((bundle, ctx) => {
+        // Entries are matched to their measurement by `name ?? path`, so that id must be unique.
+        const seen = new Set();
+        bundle.entries.forEach((entry, index) => {
+            const id = entry.name ?? entry.path;
+            if (seen.has(id)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path: ['entries', index],
+                    message: `duplicate bundle entry "${id}"; give each entry a unique name`,
+                });
+            }
+            seen.add(id);
+        });
+    })
+        .optional(),
+});
+/** A budget file that is missing, not JSON, or does not match {@link budgetSchema}. */
+export class BudgetFileError extends Error {
+    code;
+    budgetPath;
+    constructor(code, message, budgetPath) {
+        super(message);
+        this.code = code;
+        this.budgetPath = budgetPath;
+        this.name = 'BudgetFileError';
+    }
+}
+/** Validate an already-parsed budget document. */
+export function parseBudget(raw, budgetPath) {
+    const parsed = budgetSchema.safeParse(raw);
+    if (parsed.success)
+        return parsed.data;
+    const issues = parsed.error.issues
+        .map((issue) => `${issue.path.join('.') || '(root)'}: ${issue.message}`)
+        .join('; ');
+    throw new BudgetFileError('BUDGET_INVALID', `Invalid budget: ${issues}`, budgetPath);
+}
+/** Read and validate a budget file. */
+export async function loadBudget(budgetPath) {
+    let text;
+    try {
+        text = await readFile(budgetPath, 'utf8');
+    }
+    catch (error) {
+        throw new BudgetFileError('BUDGET_NOT_FOUND', `Cannot read budget file ${budgetPath}: ${error instanceof Error ? error.message : String(error)}`, budgetPath);
+    }
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        // The parser's message quotes the file, and this path can be agent-supplied.
+        throw new BudgetFileError('BUDGET_INVALID', `Budget file ${budgetPath} is not valid JSON`, budgetPath);
+    }
+    return parseBudget(raw, budgetPath);
+}
+//# sourceMappingURL=budget.js.map

package/dist/budget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.js","sourceRoot":"","sources":["../src/budget.ts"],"names":[],"mappings":"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"}

package/dist/bundle.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Bundle-size measurement: bytes on disk for the files a budget names. Needs no Electron.
+ *
+ * @module
+ */
+import type { BundleEntryBudget } from './budget.js';
+import type { BundleEntryMeasurement } from './run.js';
+/**
+ * Measure each entry under `root`. A missing path, or one with no matching file, is reported as
+ * `unavailable` instead of zero bytes: an empty measurement must never read as "within budget".
+ */
+export declare function measureBundle(root: string, entries: readonly BundleEntryBudget[]): Promise<{
+    entries: BundleEntryMeasurement[];
+}>;
+//# sourceMappingURL=bundle.d.ts.map

package/dist/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAatD;;;GAGG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,iBAAiB,EAAE,GACpC,OAAO,CAAC;IAAE,OAAO,EAAE,sBAAsB,EAAE,CAAA;CAAE,CAAC,CAqChD"}

package/dist/bundle.js

@@ -0,0 +1,64 @@
+/**
+ * Bundle-size measurement: bytes on disk for the files a budget names. Needs no Electron.
+ *
+ * @module
+ */
+import { readFile, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { gzipSync } from 'node:zlib';
+async function listFiles(target) {
+    const info = await stat(target);
+    if (info.isFile())
+        return [target];
+    if (!info.isDirectory())
+        return [];
+    const entries = await readdir(target, { recursive: true, withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => path.join(entry.parentPath, entry.name))
+        .sort();
+}
+/**
+ * Measure each entry under `root`. A missing path, or one with no matching file, is reported as
+ * `unavailable` instead of zero bytes: an empty measurement must never read as "within budget".
+ */
+export async function measureBundle(root, entries) {
+    const measured = [];
+    for (const entry of entries) {
+        const target = path.resolve(root, entry.path);
+        const gzip = entry.gzip === true;
+        const base = { id: entry.name ?? entry.path, path: target, gzip };
+        let files;
+        try {
+            files = await listFiles(target);
+        }
+        catch (error) {
+            const unavailable = error.code === 'ENOENT'
+                ? `${target} does not exist`
+                : `cannot read ${target}: ${error instanceof Error ? error.message : String(error)}`;
+            measured.push({ ...base, files: 0, bytes: 0, unavailable });
+            continue;
+        }
+        const extensions = entry.extensions;
+        const matching = extensions === undefined
+            ? files
+            : files.filter((file) => extensions.includes(path.extname(file)));
+        if (matching.length === 0) {
+            measured.push({ ...base, files: 0, bytes: 0, unavailable: `no file matched under ${target}` });
+            continue;
+        }
+        let bytes = 0;
+        if (gzip) {
+            // Sequential: holding every file buffer (and fd) at once does not scale to large trees.
+            for (const file of matching)
+                bytes += gzipSync(await readFile(file)).byteLength;
+        }
+        else {
+            const sizes = await Promise.all(matching.map(async (file) => (await stat(file)).size));
+            bytes = sizes.reduce((sum, size) => sum + size, 0);
+        }
+        measured.push({ ...base, files: matching.length, bytes });
+    }
+    return { entries: measured };
+}
+//# sourceMappingURL=bundle.js.map

package/dist/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.js","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"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"}

package/dist/check-api.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `@electron-stagewright/plugin-budget/check`: the budget and run formats and the check, without
+ * core, the plugin, or anything that launches Electron.
+ *
+ * @module
+ */
+export { BUDGET_PLATFORMS, BudgetFileError, MEMORY_METRICS, PHASES, PROCESS_TYPES, budgetSchema, loadBudget, parseBudget, } from './budget.js';
+export type { Budget, BudgetPlatform, BundleEntryBudget, MemoryMetric, MemoryPlatformBudget, Phase, ProcessType, } from './budget.js';
+export { checkRun } from './check.js';
+export type { CheckOptions, CheckReport, CheckResult, CheckStatus } from './check.js';
+export { compareRuns, renderCheckReport, renderComparison } from './render.js';
+export type { ComparisonRow } from './render.js';
+export { RUN_FORMAT, RUN_SCHEMA_VERSION, RunFileError, createRun, loadRun, memoryByType, mergeRuns, runSchema, summarizeLatencies, summarizeRun, } from './run.js';
+export type { BudgetRun, BundleEntryMeasurement, LatencySummary, Measurement, MemoryMeasurement, ProcessMemory, StallSummary, SummaryRow, } from './run.js';
+//# sourceMappingURL=check-api.d.ts.map

package/dist/check-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-api.d.ts","sourceRoot":"","sources":["../src/check-api.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,MAAM,EACN,aAAa,EACb,YAAY,EACZ,UAAU,EACV,WAAW,GACZ,MAAM,aAAa,CAAA;AACpB,YAAY,EACV,MAAM,EACN,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,oBAAoB,EACpB,KAAK,EACL,WAAW,GACZ,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACrC,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACrF,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9E,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,YAAY,EACZ,SAAS,EACT,OAAO,EACP,YAAY,EACZ,SAAS,EACT,SAAS,EACT,kBAAkB,EAClB,YAAY,GACb,MAAM,UAAU,CAAA;AACjB,YAAY,EACV,SAAS,EACT,sBAAsB,EACtB,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,aAAa,EACb,YAAY,EACZ,UAAU,GACX,MAAM,UAAU,CAAA"}