vite-devtools-svelte 0.5.0 → 0.6.1

package/dist/mcp/http.d.ts

@@ -0,0 +1,24 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Logger } from 'vite';
+import { Collector } from '../server/collector.js';
+/** Dev-server path of the MCP endpoint. */
+export declare const MCP_PATH = "/__svelte-devtools/mcp";
+/**
+ * Whether the request's `x-svelte-devtools-token` header is exactly `token`.
+ * Constant-time for equal lengths (the length itself is not secret: every
+ * token is a UUID). A repeated header (string array) is never accepted.
+ */
+export declare function isValidMcpToken(header: string | string[] | undefined, token: string): boolean;
+/**
+ * Connect middleware for the MCP endpoint: lets AI agents (Claude Code etc.)
+ * read metrics and run measurement sessions over the Streamable HTTP
+ * transport. Same-origin is *not* required because MCP clients are local
+ * processes that don't run inside a browser tab; the token is the gate.
+ */
+export declare function createMcpMiddleware(opts: {
+    token: string;
+    collector: Collector;
+    logger: Logger;
+    createServer: () => McpServer;
+}): (req: IncomingMessage, res: ServerResponse) => void;

package/dist/mcp/issues.d.ts

@@ -1,5 +1,5 @@
 import { RenderProfile, ReactiveGraph, LoadProfile, FpsSample } from '../types.js';
-export type IssueKind = 'slow-component-render' | 'over-rendered-component' | 'slow-load' | 'fps-drop' | 'effect-overconnected';
+type IssueKind = 'slow-component-render' | 'over-rendered-component' | 'slow-load' | 'fps-drop' | 'effect-overconnected';
 export interface PerformanceIssue {
     id: string;
     kind: IssueKind;
@@ -12,15 +12,18 @@ export interface PerformanceIssue {
     suggestedTool: string;
 }
 export interface IssueThresholds {
-    /** Per-render time (ms) above which a component render is considered slow. */
+    /** Per-render time (ms) at or above which a component render is considered slow. */
     avgRenderTimeMs?: number;
-    /** Render count above which a component is considered over-rendered. */
+    /** Render count at or above which a component is considered over-rendered. */
     renderCount?: number;
-    /** Load duration (ms) above which a SvelteKit load is slow. */
+    /** Load duration (ms) at or above which a SvelteKit load is slow. */
     loadDurationMs?: number;
-    /** FPS below which we record a drop. */
+    /** FPS strictly below which we record a drop. */
     fpsDropThreshold?: number;
-    /** Outgoing edge count from an effect above which it is over-connected. */
+    /**
+     * Dependency count (incoming edges: what the effect reads) at or above
+     * which an effect is over-connected.
+     */
     effectMaxDeps?: number;
 }
 export interface IssueInputs {
@@ -59,3 +62,4 @@ export interface ReactiveProblems {
     }>;
 }
 export declare function summarizeReactiveProblems(graph: ReactiveGraph, t?: IssueThresholds): ReactiveProblems;
+export {};

package/dist/mcp/server.d.ts

@@ -1,16 +1,11 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { RenderProfile, ReactiveGraph, LoadProfile, FpsSample, ComponentInstance, ProjectInfo, RouteInfo, ComponentRelation, CaptureInfoMap, ReactiveGraphRequest, ReactiveGraphResult, ReactiveSummary, ReactiveSummaryRequest, StateTimelineDelta } from '../types.js';
 import { SessionStore } from './sessions.js';
 export interface McpDeps {
     getProject: () => ProjectInfo;
     getRoutes: () => RouteInfo[];
-    getLiveComponents: () => ComponentInstance[];
-    /**
-     * The served page load's components with its epoch, read together
-     * (`get_live_components` with `includeMeta`).
-     */
-    getLiveSnapshot?: () => {
+    /** The served page load's components with its epoch, read together. */
+    getLiveSnapshot: () => {
         epoch: string | null;
         total: number;
         components: ComponentInstance[];
@@ -22,17 +17,11 @@ export interface McpDeps {
     getLoadProfiles: () => LoadProfile[];
     getFpsSamples: () => FpsSample[];
     sessions: SessionStore;
-    getReactiveSummary?: (req: ReactiveSummaryRequest) => Promise<ReactiveSummary>;
-    getReactiveScope?: (req: ReactiveGraphRequest) => Promise<ReactiveGraphResult>;
-    getStateTimelineDelta?: (since?: number) => StateTimelineDelta;
-    getCaptureInfo?: () => CaptureInfoMap;
+    getReactiveSummary: (req: ReactiveSummaryRequest) => Promise<ReactiveSummary>;
+    getReactiveScope: (req: ReactiveGraphRequest) => Promise<ReactiveGraphResult>;
+    getStateTimelineDelta: (since?: number) => StateTimelineDelta;
+    getCaptureInfo: () => CaptureInfoMap;
 }
 /** Most timeline entries one `get_state_timeline` call returns. */
 export declare const MCP_TIMELINE_LIMIT = 500;
-/** Default / largest JSON size of one old/new value in `get_state_timeline` output. */
-export declare const MCP_VALUE_CHARS: {
-    readonly default: 2048;
-    readonly max: 32768;
-};
 export declare function buildMcpServer(deps: McpDeps): McpServer;
-export { StreamableHTTPServerTransport };

package/dist/mcp/sessions.d.ts

@@ -1,5 +1,5 @@
 import { RenderProfile, LoadProfile, FpsSample } from '../types.js';
-export interface SessionSnapshot {
+interface SessionSnapshot {
     /** componentId -> { renderCount, totalRenderTime } at snapshot moment */
     renderProfiles: Array<{
         componentId: number;
@@ -47,6 +47,7 @@ export interface SessionDelta {
         drops: number;
     };
 }
+type Verdict = 'improved' | 'regressed' | 'unchanged';
 export interface SessionDiff {
     a: {
         id: string;
@@ -60,33 +61,40 @@ export interface SessionDiff {
         totalRenderTimeDeltaA: number;
         totalRenderTimeDeltaB: number;
         diff: number;
-        verdict: 'improved' | 'regressed' | 'unchanged';
+        verdict: Verdict;
     };
     load: {
         avgA: number;
         avgB: number;
         diff: number;
-        verdict: 'improved' | 'regressed' | 'unchanged';
+        verdict: Verdict;
     };
     fps: {
         avgA: number;
         avgB: number;
         diff: number;
-        verdict: 'improved' | 'regressed' | 'unchanged';
+        verdict: Verdict;
     };
 }
+interface SessionSummary {
+    id: string;
+    label: string;
+    startedAt: number;
+    endedAt?: number;
+    persisted: boolean;
+    active: boolean;
+}
 export interface MetricGetters {
     getRenderProfiles: () => RenderProfile[];
     getLoadProfiles: () => LoadProfile[];
     getFpsSamples: () => FpsSample[];
 }
 /**
- * The only id shape `start()` issues: `s_<Date.now() base36>_<6 hex>`. Ids
- * reach the store from MCP clients and become file names, so anything else
- * (path separators, `..`, absolute paths) is rejected before touching disk
- * (review C-7).
+ * Whether `id` has the only shape `start()` issues: `s_<Date.now() base36>_<6
+ * hex>`. Ids reach the store from MCP clients and become file names, so
+ * anything else (path separators, `..`, absolute paths) is rejected before
+ * touching disk (review C-7).
  */
-export declare const SESSION_ID_PATTERN: RegExp;
 export declare function isSessionId(id: unknown): id is string;
 export interface SessionStoreOptions {
     persistDir: string;
@@ -99,25 +107,27 @@ export declare class SessionStore {
     private readonly getters;
     constructor(opts: SessionStoreOptions);
     start(label: string, persist: boolean): SessionRecord;
+    private get activeRecord();
     /** Called by the plugin whenever a new load profile arrives. */
     recordLoadProfile(p: LoadProfile): void;
     /** Called by the plugin whenever a new fps sample arrives. */
     recordFpsSample(s: FpsSample): void;
     end(keep: 'memory' | 'disk' | 'discard'): SessionRecord;
     get(id: string): SessionRecord | undefined;
-    list(): Array<{
-        id: string;
-        label: string;
-        startedAt: number;
-        endedAt?: number;
-        persisted: boolean;
-        active: boolean;
-    }>;
+    list(): SessionSummary[];
     delete(id: string): boolean;
+    /**
+     * The delta of a record in hand. `end('discard')` removes the record from
+     * the store, so end_session must not look it up again by id (it used to,
+     * and failed with "Session not found" for every discarded session).
+     */
+    deltaOf(rec: SessionRecord): SessionDelta;
     delta(id: string): SessionDelta;
+    private found;
     compare(idA: string, idB: string): SessionDiff;
     /** The session's file, guaranteed to be a direct child of `persistDir`. */
     private pathFor;
     private persistToDisk;
     private loadFromDisk;
 }
+export {};

package/dist/mcp/stats.d.ts

@@ -0,0 +1,13 @@
+/** Arithmetic mean, 0 for no values. */
+export declare function avg(xs: number[]): number;
+/** Smallest value, `fallback` for no values (reduce, not `Math.min(...)`: long lists overflow the stack). */
+export declare function min<T>(xs: number[], fallback: T): number | T;
+/** Largest value, `fallback` for no values. */
+export declare function max<T>(xs: number[], fallback: T): number | T;
+/** Rounded to 2 decimals. */
+export declare function round(n: number): number;
+/** Average render time of a profile, 0 when it never rendered. */
+export declare function avgRenderTime(p: {
+    renderCount: number;
+    totalRenderTime: number;
+}): number;

package/dist/plugin.d.ts

@@ -5,27 +5,19 @@ export interface SvelteDevtoolsOptions {
      * @default true
      */
     componentTracking?: boolean;
+    /**
+     * Require the one-time code before a browser can use the standalone
+     * DevTools (`/.svelte-devtools/`). Set `false` to skip it on a trusted,
+     * single-user machine.
+     *
+     * Beware: without it, any page or device that can reach the dev server
+     * can read files in your project through the DevTools (including other
+     * devices when the dev server listens on a LAN address, `--host`).
+     * Inside the Vite DevTools dock this option has no effect: use
+     * `DevTools({ clientAuth: false })` from `@vitejs/devtools` instead.
+     * The MCP endpoint keeps its own token either way.
+     * @default true
+     */
+    clientAuth?: boolean;
 }
-/**
- * Component-tracking transform for one compiled client `.svelte` module:
- * imports the runtime and names the file for the wrapper's next `push()`.
- * `null` when the module has no component (`$.push(`) to track.
- *
- * Nothing is inserted as a new line, so every original line keeps its
- * number (`map: null` = mappings unchanged; stack traces and the
- * compiler's sourcemap stay aligned).
- */
-export declare function injectComponentTracking(code: string, id: string): string | null;
-/** A Svelte module (`.svelte.js` / `.svelte.ts`, runes outside components). */
-export declare const SVELTE_MODULE_RE: RegExp;
-/**
- * Module-scope transform for one client Svelte module: signals created while
- * its body runs (shared state, `export const cart = $state(...)`) are tracked
- * under a scope named after the file. The body is bracketed by enter/leave
- * calls; nothing is inserted as a new line. The bracket is plain JS, so it
- * works before or after vite-plugin-svelte compiles the module (with
- * `svelteDevtools()` listed before `sveltekit()`, a `.svelte.ts` module is
- * compiled after this transform). `null` for a server-compiled module.
- */
-export declare function injectModuleTracking(code: string, id: string): string | null;
 export declare function svelteDevtools(options?: SvelteDevtoolsOptions): Plugin[];

package/dist/runtime/ids.d.ts

@@ -0,0 +1,3 @@
+export declare const RUNTIME_MODULE_ID = "virtual:svelte-devtools-runtime";
+export declare const RESOLVED_RUNTIME_ID: string;
+export declare const WRAPPER_MODULE_ID = "\0svelte-devtools:wrapped-client";

package/dist/runtime/index.d.ts

@@ -0,0 +1,18 @@
+export { RESOLVED_RUNTIME_ID, RUNTIME_MODULE_ID, WRAPPER_MODULE_ID } from './ids.js';
+/**
+ * Wrapper code for svelte/internal/client (`./wrapper.js`).
+ *
+ * Re-exports everything from the real module, then overrides:
+ * - push/pop: component lifecycle tracking
+ * - tag/tag_proxy: named signal/proxy tracking (Svelte dev mode)
+ * - state/derived/proxy: type markers consumed by tag/tag_proxy
+ * - user_effect/user_pre_effect: effect tracking
+ * - template_effect/deferred_template_effect: render count/time profiling
+ * - each/if/key/await/component/boundary: block-callback owner attribution
+ *
+ * This single module replaces all post-compilation regex transforms
+ * for reactive tracking, making the approach Svelte-compiler-output agnostic.
+ */
+export declare const wrapperCode: string;
+/** The devtools runtime (`./client.js`), installed once as `window.__SVELTE_DEVTOOLS__`. */
+export declare const runtimeCode: string;

package/dist/runtime/transform.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Component-tracking transform for one compiled client `.svelte` module:
+ * imports the runtime and names the file for the wrapper's next `push()`.
+ * `null` when the module has no component (`$.push($$props`) to track.
+ *
+ * Nothing is inserted as a new line, so every original line keeps its
+ * number (`map: null` = mappings unchanged; stack traces and the
+ * compiler's sourcemap stay aligned).
+ */
+export declare function injectComponentTracking(code: string, id: string): string | null;
+/** A Svelte module (`.svelte.js` / `.svelte.ts`, runes outside components); `file` has no query. */
+export declare function isSvelteModule(file: string): boolean;
+/**
+ * Module-scope transform for one client Svelte module: signals created while
+ * its body runs (shared state, `export const cart = $state(...)`) are tracked
+ * under a scope named after the file. The body is bracketed by enter/leave
+ * calls; nothing is inserted as a new line. The bracket is plain JS, so it
+ * works before or after vite-plugin-svelte compiles the module (with
+ * `svelteDevtools()` listed before `sveltekit()`, a `.svelte.ts` module is
+ * compiled after this transform). `null` for a server-compiled module.
+ */
+export declare function injectModuleTracking(code: string, id: string): string | null;

package/dist/{collector.d.ts → server/collector.d.ts}

@@ -1,4 +1,7 @@
-import { CaptureInfoMap, CompilerWarning, ComponentInstance, FpsSample, LoadProfile, ReactiveGraph, ReactiveGraphRequest, ReactiveGraphResult, ReactiveSummary, ReactiveSummaryRequest, RenderProfile, RuntimeError, StateChange, StateTimelineDelta, StateTimelineEntry, DatasetVersions } from './types.js';
+import { CaptureInfoMap, CompilerWarning, ComponentInstance, FpsSample, LoadProfile, ReactiveGraphRequest, ReactiveGraphResult, ReactiveSummary, ReactiveSummaryRequest, RenderProfile, RuntimeError, StateChange, StateTimelineDelta, StateTimelineEntry, DatasetVersions } from '../types.js';
+import { Payload } from './payload.js';
+import { TimelinePush } from './state-timeline.js';
+export { STATE_TIMELINE_BYTES } from './state-timeline.js';
 export declare const LIMITS: {
     readonly liveComponents: 50000;
     readonly renderProfiles: 5000;
@@ -14,9 +17,8 @@ export declare const LIMITS: {
 export declare const RUNTIME_REQUEST_TIMEOUT = 1000;
 /** A pull answered within this window is reused instead of asking the runtime again. */
 export declare const PULL_FRESHNESS = 1000;
-/** Byte budget (JSON length, measured once at ingest) for the server-side state timeline. */
-export declare const STATE_TIMELINE_BYTES: number;
-export type DatasetKey = keyof DatasetVersions;
+/** A consumer (DevTools UI tab, MCP agent) counts as watching until its lease expires. */
+export declare const LEASE_TTL = 15000;
 /** App page loads (tabs / reloads) whose component tree + profiles are kept, LRU. */
 export declare const MAX_EPOCHS = 4;
 /** Hot-channel event names shared with `runtime.ts` (stable contract, see docs/devframe-migration.md §6). */
@@ -38,23 +40,13 @@ export declare const HOT_EVENTS: {
     /** server → runtime(s): `{ active: boolean }` — whether any consumer is watching. */
     readonly subscription: "svelte-devtools:subscription";
 };
-/** Defaults and bounds for `get-reactive-summary` (§6.7 I). */
-export declare const SUMMARY_DEFAULTS: {
-    readonly topK: 50;
-    readonly maxTopK: 200;
-    readonly windowMs: 10000;
-    readonly minWindowMs: 1000;
-    readonly maxWindowMs: 60000;
-};
-/** A consumer (DevTools UI tab, MCP agent) counts as watching until its lease expires. */
-export declare const LEASE_TTL = 15000;
 export interface HotClient {
     send(event: string, payload: unknown): void;
 }
 export interface HotChannel {
     send(event: string, payload: unknown): void;
-    on(event: string, listener: (payload: any, client: HotClient) => void): void;
-    off?(event: string, listener: (payload: any, client: HotClient) => void): void;
+    on(event: string, listener: (payload: unknown, client: HotClient) => void): void;
+    off?(event: string, listener: (payload: unknown, client: HotClient) => void): void;
 }
 export interface CollectorHooks {
     onFpsSample?: (sample: FpsSample) => void;
@@ -66,49 +58,35 @@ export interface CollectorHooks {
  * feeds it, the devframe RPC layer and the MCP server read from it.
  */
 export declare class Collector {
-    private readonly hooks;
     private epochs;
     private servedEpoch;
     private liveCache;
-    loadProfiles: LoadProfile[];
-    reactiveGraph: ReactiveGraph;
-    compilerWarnings: CompilerWarning[];
-    runtimeErrors: RuntimeError[];
-    fpsSamples: FpsSample[];
+    /** Epochs we asked for a full snapshot (delta without a base); answered once per epoch. */
+    private resyncRequested;
+    private readonly fps;
+    private readonly errors;
+    private readonly loads;
+    private readonly warnings;
+    private readonly timeline;
     readonly versions: DatasetVersions;
-    private bump;
-    private timeline;
-    /** Parallel to `timeline`: JSON size and source epoch (app page load) of each entry. */
-    private timelineSizes;
-    private timelineEpochs;
-    private timelineBytes;
-    /** Newest seq issued by this collector (= the current cursor). */
-    private timelineSeq;
-    /** Cursor value at the last removal; older cursors must start over. */
-    private timelineResetAt;
-    /** Seq of the newest entry trimmed by the caps; cursors below it missed entries. */
-    private timelineTrimmedAt;
-    private lastPull;
-    private inflight;
     private pulls;
     private pullCache;
     private pullInflight;
     private requestSeq;
     /** The most recent graph reply, for capture info. */
     private lastGraph;
-    private timelineDrops;
-    /** Per epoch: whether the runtime has a first sample of every tracked $state yet. */
-    private timelineBaseline;
-    private timelineTooLarge;
-    private received;
+    private lastTimelinePull;
+    private timelineInflight;
+    private timelineResolvers;
     private hot;
     private detachHot;
     private leases;
     private snapshotWaiters;
     private active;
     private sweepTimer;
-    private stateTimelineResolvers;
+    private readonly hooks;
     constructor(hooks?: CollectorHooks);
+    private bump;
     /**
      * Subscribe to the runtime's hot-channel events. Re-attaching (dev server
      * restart) detaches the previous channel first so listeners never pile up.
@@ -120,8 +98,12 @@ export declare class Collector {
         active: boolean;
         componentDeltas: true;
     };
-    /** Epochs we asked for a full snapshot (delta without a base); answered once per epoch. */
-    private resyncRequested;
+    get fpsSamples(): FpsSample[];
+    get runtimeErrors(): RuntimeError[];
+    get loadProfiles(): LoadProfile[];
+    get compilerWarnings(): CompilerWarning[];
+    /** The server-side timeline (all tracked epochs, oldest first). */
+    get stateTimeline(): StateTimelineEntry[];
     /** Components of the served epoch, parents first, capped at {@link LIMITS.liveComponents}. */
     get liveComponents(): ComponentInstance[];
     /**
@@ -155,9 +137,10 @@ export declare class Collector {
     /**
      * Mark `id` as watching for `ttl` ms (renewed by heartbeats). The first
      * lease activates the runtime's polling/FPS sampling, the last expiry or
-     * release pauses it.
+     * release pauses it. Returns whether this call activated it.
      */
     lease(id: string, ttl?: number): boolean;
+    release(id: string): void;
     /**
      * Resolve once the runtime has sent its activation snapshot (components,
      * profiles, then a `reset: true` timeline — the last part) or after
@@ -165,7 +148,6 @@ export declare class Collector {
      * the stale pre-activation state.
      */
     waitForSnapshot(timeout: number): Promise<void>;
-    release(id: string): void;
     private updateSubscription;
     /**
      * Full form `{ epoch?, reset?, components }` replaces the epoch's tree;
@@ -175,56 +157,30 @@ export declare class Collector {
      * resync. Entries stay in registration order (parents first); an instance
      * is stored only while its parent is and the cap allows, otherwise only its
      * id is tracked, so the stored part is always a rooted, orphan-free tree.
+     * Entries that are not objects with a numeric `id` are ignored.
      */
-    ingestComponents(data: {
-        components?: unknown;
-        epoch?: unknown;
-        added?: unknown;
-        removed?: unknown;
-    } | undefined, client?: HotClient): void;
-    ingestProfiles(data: {
-        profiles?: unknown;
-        epoch?: unknown;
-        total?: unknown;
-    } | undefined): void;
+    ingestComponents(data: Payload | undefined, client?: HotClient): void;
+    ingestProfiles(data?: Payload): void;
+    ingestStateTimeline(data: TimelinePush | undefined): void;
+    ingestFps(sample: FpsSample): void;
+    ingestRuntimeError(error: RuntimeError): void;
+    recordLoadProfile(profile: LoadProfile): void;
+    /**
+     * A warning identical to one held is not recorded again: a component is
+     * compiled once per environment (client and SSR), each time warning anew.
+     */
+    recordCompilerWarning(warning: CompilerWarning): void;
+    clearLoadProfiles(): void;
+    clearErrors(): void;
+    clearFps(): void;
+    clearStateTimeline(): void;
+    /** Changes after `since` (a previous `cursor`), or the whole buffer when the cursor is stale. */
+    getStateTimelineDelta(since?: number): StateTimelineDelta;
     /**
      * What the server holds versus what was reported, per dataset (§6.7 B).
      * `total: null` means unknown; nothing is estimated.
      */
     getCaptureInfo(): CaptureInfoMap;
-    /** The server-side timeline (all tracked epochs, oldest first). */
-    get stateTimeline(): StateTimelineEntry[];
-    /**
-     * Two payload shapes (docs/devframe-migration.md §6.4):
-     * - delta: `{ epoch, changes, reset? }` — `changes` are new since the
-     *   previous push from that page load (`epoch`); `reset` replaces that
-     *   epoch's entries. Entries are kept per epoch, so several app tabs (or a
-     *   reload) interleave instead of wiping each other.
-     * - legacy full snapshot: `{ changes }` — we append only the entries after
-     *   the newest one we already hold, so clients still get deltas.
-     */
-    ingestStateTimeline(data: {
-        changes?: unknown;
-        epoch?: unknown;
-        reset?: unknown;
-        dropped?: unknown;
-        valueTooLarge?: unknown;
-        baseline?: unknown;
-    } | undefined): void;
-    /**
-     * Add the runtime's own losses (unsent entries it evicted, §6.7 C) and
-     * too-large values to the epoch's counters. Only runtime reasons are
-     * accepted from the runtime; server reasons are counted here.
-     */
-    private countRuntimeLosses;
-    private addDrop;
-    /** Changes after `since` (a previous `cursor`), or the whole buffer when the cursor is stale. */
-    getStateTimelineDelta(since?: number): StateTimelineDelta;
-    /** Invalidate every cursor issued so far (entries were removed, not just appended). */
-    private markTimelineReset;
-    private dropEpoch;
-    private appendTimeline;
-    private resolveSnapshotWaiters;
     /**
      * A graph reply. With a `requestId` (§6.7 A) it resolves only that request,
      * and only if its epoch matches the one asked for; a reply nobody waits for
@@ -232,27 +188,11 @@ export declare class Collector {
      * is a whole-app graph and answers every pending graph pull, scoped ones by
      * filtering here.
      */
-    ingestReactiveGraph(data: Record<string, any> | undefined): void;
-    /**
-     * Shape a runtime reply into a {@link ReactiveGraphResult}: apply the
-     * collector caps (nodes, then only edges between kept nodes, then the edge
-     * cap) and report what was left out. Totals come from the runtime; an older
-     * runtime's are the counts it sent (`nodesKind: 'sent'`), or unknown when
-     * the server had to scope its whole-app graph.
-     */
-    private normalizeGraph;
-    private storeGraph;
+    ingestReactiveGraph(data: Payload | undefined): void;
     /** A summary reply (§6.7 I): resolves only the matching request. */
-    ingestReactiveSummary(data: Record<string, any> | undefined): void;
-    private normalizeSummary;
-    ingestFps(sample: FpsSample): void;
-    ingestRuntimeError(error: RuntimeError): void;
-    recordLoadProfile(profile: LoadProfile): void;
-    recordCompilerWarning(warning: CompilerWarning): void;
-    clearLoadProfiles(): void;
-    clearErrors(): void;
-    clearFps(): void;
-    clearStateTimeline(): void;
+    ingestReactiveSummary(data: Payload | undefined): void;
+    /** The pending pull `requestId` names, if the reply is of its kind and from its epoch. */
+    private matchingPull;
     /**
      * Ask the browser runtime for the graph of one component instance (or the
      * whole app), built by the runtime within the caps (§6.7 A). Falls back to
@@ -268,17 +208,17 @@ export declare class Collector {
      * last result for the same key is returned with `stale: true`.
      */
     private keyedPull;
-    /** Resolve a pending pull with a fresh result and cache it under its key. */
+    /**
+     * Resolve a pending pull: with a fresh result (cached under its key), or
+     * with its fallback when the runtime did not answer.
+     */
     private settle;
-    /** Answer every pending keyed pull from its cache (or empty), marked stale. */
-    private flushPulls;
-    /** Ask the browser runtime for a fresh state timeline; falls back to the last one. */
-    requestStateTimeline(): Promise<StateChange[]>;
     /**
-     * Concurrent callers share one in-flight pull, and a result younger than
-     * {@link PULL_FRESHNESS} is reused, so several polling clients never make
-     * the user's app rebuild the same data more than once a second.
+     * Ask the browser runtime for a fresh state timeline; falls back to the
+     * last one. Concurrent callers share one in-flight pull, and a result
+     * younger than {@link PULL_FRESHNESS} is reused, so several polling clients
+     * never make the user's app rebuild the same data more than once a second.
      */
-    private pull;
+    requestStateTimeline(): Promise<StateChange[]>;
     private flushStateTimeline;
 }

package/dist/server/compiler-warnings.d.ts

@@ -0,0 +1,13 @@
+import { Plugin } from 'vite';
+import { CompilerWarning } from '../types.js';
+/**
+ * Report every Svelte compiler warning of the app to `record`, as the
+ * compiler's structured warning (vite-plugin-svelte prints dev warnings with
+ * `console.log`, past Vite's logger). The user's `onwarn` (or the default
+ * handler) still runs, so console output is unchanged. Dependencies'
+ * warnings are skipped, as vite-plugin-svelte does in dev.
+ *
+ * Must run after vite-plugin-svelte's own `configResolved`, which creates
+ * the options (a restart creates new ones, so wrappers never stack).
+ */
+export declare function captureCompilerWarnings(plugins: readonly Plugin[], record: (warning: CompilerWarning) => void): void;