agent-yes 1.288.0 → 1.289.0

package/ts/serveSampler.spec.ts

@@ -0,0 +1,390 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// The sampler's only outside dependency is one `sampleTrees` call per sweep, so
+// mocking it here lets every branch below run against synthetic process trees —
+// no /proc, no live fleet, and identical behaviour on macOS and Linux CI.
+const sampleTrees = vi.fn();
+vi.mock("./procStats.ts", () => ({
+  sampleTrees: (...args: unknown[]) => sampleTrees(...args),
+}));
+
+import {
+  getBucketSecs,
+  getSnapshot,
+  resField,
+  resourcesField,
+  startSampler,
+  stopSampler,
+  sweep,
+  windowLen,
+} from "./serveSampler.ts";
+
+/** A TreeStats literal — the shape sampleTrees hands back per root pid. */
+function tree(pid: number, rss: number, cpuPercent: number, procs: number) {
+  return { pid, rss, cpuPercent, procs };
+}
+
+/** A whole sampleTrees result: the given trees plus an unattributed rollup. */
+function result(
+  trees: Array<ReturnType<typeof tree>>,
+  unattributed = tree(0, 0, 0, 0),
+) {
+  return {
+    trees: new Map(trees.map((t) => [t.pid, t])),
+    unattributed,
+    claimed: new Map(),
+  };
+}
+
+// The sampler keeps its window in module-level state (one sampler per daemon),
+// so each test starts from a known-empty snapshot rather than inheriting the
+// previous test's buckets.
+function resetState() {
+  stopSampler();
+  const snap = getSnapshot();
+  snap.agents.clear();
+  snap.unattributed = { cpu_seconds: 0, rss: 0, procs: 0 };
+  snap.bucketSecs = 0;
+  // getBucketSecs() reads the same private width `sweep` sets; drive it back to
+  // the unchosen state through the public path (an empty sweep re-primes it).
+}
+
+beforeEach(() => {
+  sampleTrees.mockReset();
+  resetState();
+});
+
+afterEach(() => {
+  stopSampler();
+  vi.useRealTimers();
+});
+
+describe("windowLen", () => {
+  it("tracks the adaptive bucket width", () => {
+    expect(windowLen(60)).toBe(60); // fast: 1m buckets, 1h window
+    expect(windowLen(300)).toBe(12); // slow: 5m buckets, 1h window
+    expect(windowLen(1)).toBe(60); // anything ≤60 counts as fast
+  });
+});
+
+describe("sweep", () => {
+  it("with no live roots still settles a bucket width without sampling", async () => {
+    const width = await sweep([]);
+    expect(width).toBeGreaterThan(0);
+    expect([60, 300]).toContain(width);
+    // No roots means there is nothing to snapshot — the expensive process walk
+    // must be skipped entirely, not called with an empty list.
+    expect(sampleTrees).not.toHaveBeenCalled();
+    expect(getSnapshot().bucketSecs).toBe(width);
+  });
+
+  it("keeps the already-chosen width when a later sweep finds no roots", async () => {
+    sampleTrees.mockResolvedValueOnce(result([tree(100, 1, 0, 1)]));
+    const chosen = await sweep([100]);
+
+    // The whole fleet exiting must not re-open the width decision: the console's
+    // axis label would jump under it mid-session.
+    expect(await sweep([])).toBe(chosen);
+    expect(getSnapshot().bucketSecs).toBe(chosen);
+  });
+
+  it("records one bucket per sampled agent and the unattributed rollup", async () => {
+    sampleTrees.mockResolvedValue(
+      result([tree(100, 2048, 50, 3), tree(200, 4096, 10, 1)], tree(0, 8192, 20, 9)),
+    );
+
+    await sweep([100, 200]);
+
+    const snap = getSnapshot();
+    expect([...snap.agents.keys()].sort()).toEqual([100, 200]);
+    expect(snap.agents.get(100)).toHaveLength(1);
+    expect(snap.agents.get(100)![0]![1].rss).toBe(2048);
+    expect(snap.agents.get(100)![0]![1].procs).toBe(3);
+    expect(snap.unattributed.rss).toBe(8192);
+    expect(snap.unattributed.procs).toBe(9);
+  });
+
+  it("walks roots deepest-first so a nested agent claims its subtree before its parent", async () => {
+    sampleTrees.mockResolvedValue(result([tree(100, 1, 0, 1)]));
+
+    await sweep([100, 200, 300]);
+
+    // `ay ps` semantics: sampleTrees attributes first-come, so the caller must
+    // hand it the reversed list. Getting this backwards silently credits a
+    // child's memory to its parent.
+    expect(sampleTrees.mock.calls[0]![0]).toEqual([300, 200, 100]);
+  });
+
+  it("converts cpuPercent into cpu-seconds of one core over the pass", async () => {
+    sampleTrees.mockResolvedValue(result([tree(100, 0, 100, 1)], tree(0, 0, 50, 1)));
+
+    await sweep([100]);
+
+    // 100% of one core is at most the pass duration in seconds, and the floor on
+    // elapsed (1ms) keeps a sub-millisecond pass from producing a huge number.
+    const cpu = getSnapshot().agents.get(100)![0]![1].cpu_seconds;
+    expect(cpu).toBeGreaterThan(0);
+    expect(cpu).toBeLessThan(1);
+    // The unattributed rollup goes through the same conversion, at half the rate.
+    expect(getSnapshot().unattributed.cpu_seconds).toBeCloseTo(cpu / 2, 10);
+  });
+
+  it("keeps the last good snapshot when a sweep throws", async () => {
+    sampleTrees.mockResolvedValueOnce(result([tree(100, 4096, 0, 2)]));
+    await sweep([100]);
+    const width = getBucketSecs();
+
+    sampleTrees.mockRejectedValueOnce(new Error("/proc vanished"));
+    const after = await sweep([100]);
+
+    // Best-effort: a failed snapshot degrades to "no new data", never to a
+    // cleared window (which the console would render as the agent dying).
+    expect(after).toBe(width);
+    expect(getSnapshot().agents.get(100)).toHaveLength(1);
+    expect(getSnapshot().agents.get(100)![0]![1].rss).toBe(4096);
+  });
+
+  it("falls back to the fast width when the very first sweep throws", async () => {
+    sampleTrees.mockRejectedValueOnce(new Error("boom"));
+    // Width was never chosen (state.bucketSecs === 0), so the catch path has no
+    // previous value to keep and must still return a usable cadence.
+    expect(await sweep([100])).toBe(60);
+  });
+
+  it("picks the slow bucket width when the first pass is slow", async () => {
+    // The width is chosen ONCE, on the first timed pass, and then sticks for the
+    // life of the daemon — so this needs a module instance no earlier test has
+    // already driven to the fast width.
+    vi.resetModules();
+    const fresh = await import("./serveSampler.ts");
+
+    // sweep() times its own pass with Date.now(), so stub the clock to report a
+    // pass over the 1s threshold rather than actually sleeping for one.
+    let now = Date.now();
+    const nowSpy = vi.spyOn(Date, "now").mockImplementation(() => now);
+    sampleTrees.mockImplementationOnce(async () => {
+      now += 1500; // pass >= 1s → 5m buckets
+      return result([tree(100, 1, 0, 1)]);
+    });
+
+    try {
+      expect(await fresh.sweep([100])).toBe(300);
+      expect(fresh.getBucketSecs()).toBe(300);
+      // 5m buckets ⇒ a 12-slot window, so an hour of history still fits.
+      expect(fresh.windowLen(300)).toBe(12);
+    } finally {
+      nowSpy.mockRestore();
+      fresh.stopSampler();
+    }
+  });
+
+  it("trims the rolling window to the bucket count and keeps the newest samples", async () => {
+    // Force the fast width (60 buckets) with a fast first pass, then overfill.
+    for (let i = 0; i < 63; i++) {
+      sampleTrees.mockResolvedValueOnce(result([tree(100, i, 0, 1)]));
+      await sweep([100]);
+    }
+
+    const series = getSnapshot().agents.get(100)!;
+    expect(series).toHaveLength(windowLen(60));
+    // Oldest-first ordering, with the three oldest dropped — the console draws
+    // left-to-right, so a reversed window would render the heatmap backwards.
+    expect(series[0]![1].rss).toBe(3);
+    expect(series[series.length - 1]![1].rss).toBe(62);
+  });
+});
+
+describe("resField", () => {
+  it("is null for an agent the sampler has not recorded", async () => {
+    sampleTrees.mockResolvedValue(result([tree(100, 1, 0, 1)]));
+    await sweep([100]);
+
+    expect(resField(999)).toBeNull();
+  });
+
+  it("transposes the window into the parallel arrays /api/ls expects", async () => {
+    sampleTrees.mockResolvedValueOnce(result([tree(100, 10, 0, 1)]));
+    await sweep([100]);
+    sampleTrees.mockResolvedValueOnce(result([tree(100, 20, 0, 2)]));
+    await sweep([100]);
+
+    const field = resField(100)!;
+    // Byte-compatible with the Rust /api/ls shape: one array per metric, all the
+    // same length, sharing the `t` index.
+    expect(field.bucket_secs).toBe(getSnapshot().bucketSecs);
+    expect(field.rss).toEqual([10, 20]);
+    expect(field.procs).toEqual([1, 2]);
+    expect(field.t).toHaveLength(2);
+    expect(field.cpu_seconds).toHaveLength(2);
+  });
+});
+
+describe("resourcesField", () => {
+  it("reports zeroes before the first sweep", () => {
+    const f = resourcesField();
+    expect(f.managed_rss).toBe(0);
+    expect(f.managed_procs).toBe(0);
+    expect(f.unattributed_rss).toBe(0);
+  });
+
+  it("skips an agent whose window is empty rather than counting a missing bucket", async () => {
+    sampleTrees.mockResolvedValueOnce(result([tree(100, 1000, 0, 2)]));
+    await sweep([100]);
+    // An agent registered with no samples yet (its series trimmed to nothing) must
+    // contribute zero, not throw on the absent last bucket.
+    getSnapshot().agents.set(777, []);
+
+    const f = resourcesField();
+    expect(f.managed_rss).toBe(1000);
+    expect(f.managed_procs).toBe(2);
+  });
+
+  it("sums only the LAST bucket of each agent against the unattributed rollup", async () => {
+    sampleTrees.mockResolvedValueOnce(
+      result([tree(100, 1000, 0, 1), tree(200, 2000, 0, 2)], tree(0, 500, 0, 5)),
+    );
+    await sweep([100, 200]);
+    // A second sweep must replace, not accumulate: summing every bucket in the
+    // window would report an hour of history as current memory use.
+    sampleTrees.mockResolvedValueOnce(
+      result([tree(100, 1500, 0, 3), tree(200, 2500, 0, 4)], tree(0, 700, 0, 6)),
+    );
+    await sweep([100, 200]);
+
+    const f = resourcesField();
+    expect(f.managed_rss).toBe(4000); // 1500 + 2500, not 1000+2000+1500+2500
+    expect(f.managed_procs).toBe(7); // 3 + 4
+    expect(f.unattributed_rss).toBe(700);
+    expect(f.unattributed_procs).toBe(6);
+  });
+});
+
+describe("startSampler", () => {
+  it("primes a sweep immediately and re-arms on the chosen width", async () => {
+    vi.useFakeTimers();
+    sampleTrees.mockResolvedValue(result([tree(100, 4096, 0, 1)]));
+
+    startSampler(async () => [100]);
+    await vi.advanceTimersByTimeAsync(0); // let the priming tick settle
+
+    // The first bucket must land before the console's first list poll, so the
+    // heatmap is never empty on a freshly started daemon.
+    expect(getSnapshot().agents.get(100)).toHaveLength(1);
+
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(getSnapshot().agents.get(100)!.length).toBeGreaterThan(1);
+  });
+
+  it("is idempotent — a second call does not start a second timer", async () => {
+    vi.useFakeTimers();
+    sampleTrees.mockResolvedValue(result([tree(100, 1, 0, 1)]));
+
+    startSampler(async () => [100]);
+    startSampler(async () => [100]);
+    await vi.advanceTimersByTimeAsync(0);
+
+    // Two timers would double every bucket and halve the effective window.
+    expect(getSnapshot().agents.get(100)).toHaveLength(1);
+  });
+
+  it("survives a getRoots that throws", async () => {
+    vi.useFakeTimers();
+    startSampler(async () => {
+      throw new Error("registry unreadable");
+    });
+    await vi.advanceTimersByTimeAsync(0);
+
+    // Best-effort: the serve path must not fall over because the pid store was
+    // momentarily unreadable — the loop keeps its cadence and tries again.
+    expect(sampleTrees).not.toHaveBeenCalled();
+    // The rejection is swallowed and the loop re-arms, so draining the next tick
+    // must not surface an unhandled rejection.
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(sampleTrees).not.toHaveBeenCalled();
+  });
+
+  it("does not re-arm when stopped during an in-flight sweep", async () => {
+    vi.useFakeTimers();
+    let release: (() => void) | undefined;
+    sampleTrees.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          release = () => resolve(result([tree(100, 1, 0, 1)]));
+        }),
+    );
+
+    startSampler(async () => [100]);
+    await vi.advanceTimersByTimeAsync(0);
+    // Stop lands while the sweep is still awaiting: the tick must notice on
+    // resume and NOT schedule another timer, else a stopped daemon keeps walking
+    // /proc forever.
+    stopSampler();
+    release!();
+    await vi.advanceTimersByTimeAsync(600_000);
+
+    expect(sampleTrees).toHaveBeenCalledTimes(1);
+  });
+
+  it("tolerates a timer handle with no unref (browser-shaped setTimeout)", async () => {
+    vi.useFakeTimers();
+    sampleTrees.mockResolvedValue(result([tree(100, 1, 0, 1)]));
+    // Node hands back a Timeout carrying .unref(); a bare numeric handle (jsdom,
+    // some bundlers) has none, and the optional call must simply skip it.
+    const raw = globalThis.setTimeout;
+    const stub = vi
+      .spyOn(globalThis, "setTimeout")
+      .mockImplementation(((fn: () => void, ms?: number) => {
+        const h = raw(fn, ms);
+        return { ...(h as object), unref: undefined } as unknown as ReturnType<typeof raw>;
+      }) as typeof raw);
+
+    try {
+      startSampler(async () => [100]);
+      await vi.advanceTimersByTimeAsync(0);
+      expect(getSnapshot().agents.get(100)).toHaveLength(1);
+    } finally {
+      stub.mockRestore();
+    }
+  });
+
+  it("uses the fast width for its first re-arm before any sweep has timed one", async () => {
+    // A fresh instance has no chosen width yet, so the tick's own
+    // `state.bucketSecs || BUCKET_FAST_SECS` fallback is what schedules the
+    // second pass. Exercised here because the shared instance is always warm.
+    vi.resetModules();
+    const fresh = await import("./serveSampler.ts");
+    vi.useFakeTimers();
+    sampleTrees.mockResolvedValue(result([tree(100, 1, 0, 1)]));
+
+    try {
+      fresh.startSampler(async () => [100]);
+      await vi.advanceTimersByTimeAsync(0);
+      expect(sampleTrees).toHaveBeenCalledTimes(1);
+
+      // 60s is the fast cadence; re-arming any slower would leave the console
+      // without a second data point for five minutes.
+      await vi.advanceTimersByTimeAsync(60_000);
+      expect(sampleTrees).toHaveBeenCalledTimes(2);
+    } finally {
+      fresh.stopSampler();
+    }
+  });
+
+  it("stopSampler halts the loop and allows a later restart", async () => {
+    vi.useFakeTimers();
+    sampleTrees.mockResolvedValue(result([tree(100, 1, 0, 1)]));
+
+    startSampler(async () => [100]);
+    await vi.advanceTimersByTimeAsync(0);
+    const afterPrime = getSnapshot().agents.get(100)!.length;
+
+    stopSampler();
+    await vi.advanceTimersByTimeAsync(300_000);
+    expect(getSnapshot().agents.get(100)!.length).toBe(afterPrime);
+
+    // `started` is cleared, so a restart primes again rather than no-opping.
+    startSampler(async () => [100]);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(getSnapshot().agents.get(100)!.length).toBeGreaterThan(afterPrime);
+  });
+});

package/ts/serveSampler.ts

@@ -0,0 +1,218 @@
+/**
+ * Periodic per-agent resource sampler for the console heatmaps — the TS twin of
+ * `rs/src/serve/sampler.rs` (see there for the shared design). The Rust daemon
+ * ships this already; this port lets the TS `ay serve` daemon — which is what
+ * actually serves the browser console — expose the SAME `res` / `resources`
+ * fields, so the console renders identically whichever host backs it.
+ *
+ * Reuses `ts/procStats.ts` (the `ay ps` machinery) for one full process-tree
+ * snapshot + rollup per sweep, bucketed into a per-agent rolling window.
+ * Best-effort throughout — a failed snapshot, an agent exited mid-sweep, or a
+ * non-/proc platform all degrade to "no data" (transparent) rather than breaking
+ * the serve path.
+ *
+ * Adaptive granularity (same rule as Rust):
+ *   pass time <  1s  →  bucket =  60s, window = 60 buckets  (1h)
+ *   pass time >= 1s  →  bucket = 300s, window = 12 buckets  (1h)
+ */
+
+import { sampleTrees, type TreeStats } from "./procStats.ts";
+
+const BUCKET_FAST_SECS = 60;
+const BUCKET_SLOW_SECS = 300;
+const WINDOW_FAST = 60; // 1h @ 1m buckets
+const WINDOW_SLOW = 12; // 1h @ 5m buckets
+const PASS_THRESHOLD_MS = 1000;
+// CPU is a live delta; a short window keeps each sweep's sample "instantaneous"
+// so we're not averaging a whole minute's CPU into one number.
+const SWEEP_WINDOW_MS = 120;
+
+/** One bucketed per-agent sample (one point on the heatmap). */
+export interface Bucket {
+  /** CPU seconds of ONE core consumed over the sweep window (≈ instantaneous). */
+  cpu_seconds: number;
+  /** RSS (bytes) snapshot at bucket close. */
+  rss: number;
+  /** Live process count at bucket close. */
+  procs: number;
+}
+
+/** Snapshot handed to /api/ls (`res`) and /api/host (`resources`). */
+export interface ResSnapshot {
+  /** wrapper pid → resource window (oldest first), each (unix_ms, bucket). */
+  agents: Map<number, Array<[number, Bucket]>>;
+  /** The unattributed (non-agent-yes) rollup at the last sweep. */
+  unattributed: Bucket;
+  /** Bucket width actually in use (60 or 300), for the console's axis label. */
+  bucketSecs: number;
+}
+
+interface State {
+  snap: ResSnapshot;
+  bucketSecs: number;
+}
+
+function windowLen(bucketSecs: number): number {
+  return bucketSecs <= BUCKET_FAST_SECS ? WINDOW_FAST : WINDOW_SLOW;
+}
+
+function bucketOf(t: TreeStats, elapsedSeconds: number): Bucket {
+  return {
+    // cpuPercent is percent of ONE core over the sample window → convert to
+    // seconds-of-one-core by ×(elapsed/100). (matches Rust's cpu_delta semantics)
+    cpu_seconds: (t.cpuPercent / 100) * elapsedSeconds,
+    rss: t.rss,
+    procs: t.procs,
+  };
+}
+
+const state: State = {
+  snap: { agents: new Map(), unattributed: { cpu_seconds: 0, rss: 0, procs: 0 }, bucketSecs: 0 },
+  bucketSecs: 0,
+};
+
+function getSnapshot(): ResSnapshot {
+  return state.snap;
+}
+
+/**
+ * The per-agent resource window as the console's `entry.res` field (matching the
+ * Rust `/api/ls` `res` shape exactly): { bucket_secs, t[], cpu_seconds[], rss[],
+ * procs[] }. Null when the sampler has not yet recorded this agent.
+ */
+function resField(pid: number): {
+  bucket_secs: number;
+  t: number[];
+  cpu_seconds: number[];
+  rss: number[];
+  procs: number[];
+} | null {
+  const series = state.snap.agents.get(pid);
+  if (!series || series.length === 0) return null;
+  return {
+    bucket_secs: state.snap.bucketSecs,
+    t: series.map(([t]) => t),
+    cpu_seconds: series.map(([, b]) => b.cpu_seconds),
+    rss: series.map(([, b]) => b.rss),
+    procs: series.map(([, b]) => b.procs),
+  };
+}
+
+/** The managed/unattributed split for the room line, matching the Rust shape. */
+function resourcesField(): {
+  bucket_secs: number;
+  managed_rss: number;
+  managed_procs: number;
+  unattributed_rss: number;
+  unattributed_procs: number;
+} {
+  let managedRss = 0;
+  let managedProcs = 0;
+  for (const series of state.snap.agents.values()) {
+    const last = series[series.length - 1];
+    if (last) {
+      managedRss += last[1].rss;
+      managedProcs += last[1].procs;
+    }
+  }
+  return {
+    bucket_secs: state.snap.bucketSecs,
+    managed_rss: managedRss,
+    managed_procs: managedProcs,
+    unattributed_rss: state.snap.unattributed.rss,
+    unattributed_procs: state.snap.unattributed.procs,
+  };
+}
+
+function getBucketSecs(): number {
+  return state.bucketSecs;
+}
+
+/**
+ * Run one sweep against the given live root pids and bucket the result. Exposed so
+ * `serve.ts` drives it with its own notion of the live fleet (it already has
+ * `listRecords`). Returns the chosen bucket width (after the adaptive first pass).
+ */
+async function sweep(roots: number[]): Promise<number> {
+  if (roots.length === 0) {
+    // Nothing to sample — still mark the width as chosen so the timer uses a
+    // sane cadence, and refresh the empty snapshot.
+    if (state.bucketSecs === 0) state.bucketSecs = BUCKET_FAST_SECS;
+    state.snap.bucketSecs = state.bucketSecs;
+    return state.bucketSecs;
+  }
+
+  const start = Date.now();
+  let result: Awaited<ReturnType<typeof sampleTrees>>;
+  try {
+    // Deepest-first, like `ay ps`: a nested agent must claim its subtree before
+    // its parent walks through it (sampleTrees attributes first-come).
+    result = await sampleTrees([...roots].reverse(), { windowMs: SWEEP_WINDOW_MS });
+  } catch {
+    return state.bucketSecs || BUCKET_FAST_SECS; // keep last snapshot
+  }
+  const pass = Date.now() - start;
+
+  if (state.bucketSecs === 0) {
+    // First pass timed → pick the bucket width.
+    state.bucketSecs = pass < PASS_THRESHOLD_MS ? BUCKET_FAST_SECS : BUCKET_SLOW_SECS;
+  }
+
+  const now = Date.now();
+  const max = windowLen(state.bucketSecs);
+  const elapsedSeconds = Math.max(0.001, pass / 1000);
+
+  for (const [pid, stats] of result.trees) {
+    const series = state.snap.agents.get(pid) ?? [];
+    series.push([now, bucketOf(stats, elapsedSeconds)]);
+    if (series.length > max) series.splice(0, series.length - max);
+    state.snap.agents.set(pid, series);
+  }
+  const un = result.unattributed;
+  state.snap.unattributed = {
+    cpu_seconds: (un.cpuPercent / 100) * elapsedSeconds,
+    rss: un.rss,
+    procs: un.procs,
+  };
+  state.snap.bucketSecs = state.bucketSecs;
+
+  return state.bucketSecs;
+}
+
+let started = false;
+let timer: ReturnType<typeof setTimeout> | null = null;
+
+/**
+ * Start the background sampler. Idempotent. `serve.ts` calls this once on startup;
+ * `getRoots` returns the live wrapper pids (it already reads them via listRecords).
+ * Self-schedules with setTimeout so the adaptive bucket width takes effect on the
+ * very next tick without interval re-arm gymnastics.
+ */
+function startSampler(getRoots: () => Promise<number[]>): void {
+  if (started) return;
+  started = true;
+
+  const tick = async () => {
+    let width = state.bucketSecs || BUCKET_FAST_SECS;
+    try {
+      const roots = await getRoots();
+      width = (await sweep(roots)) || width;
+    } catch {
+      /* best-effort */
+    }
+    if (!started) return;
+    timer = setTimeout(tick, width * 1000);
+    (timer as unknown as { unref?: () => void }).unref?.();
+  };
+
+  // Prime immediately (first bucket lands before the first list poll), then loop.
+  void tick();
+}
+
+function stopSampler(): void {
+  started = false;
+  if (timer) clearTimeout(timer);
+  timer = null;
+}
+
+export { getSnapshot, getBucketSecs, resField, resourcesField, startSampler, stopSampler, sweep, windowLen };

package/dist/trayApp-BrAMlCY7.js

@@ -1,5 +0,0 @@
-import "./versionChecker-CkO7wYyV.js";
-import "./rustBinary-BmXzqj5z.js";
-import { a as trayHiddenMarker, i as launchTray, n as hasDesktop, r as isTrayHidden, t as cmdTray } from "./trayApp-DvL9qW6V.js";
-
-export { cmdTray };