@g9tm/app-pilot 0.0.0-stage → 0.1.0

package/src/stage.ts

@@ -0,0 +1,314 @@
+// Setting the scene from the controller (`stage` scope): the network the app's own fetch sees, the clock, randomness and
+// flags — so a flow can say «the network drops in the middle of a send», «the token is a day old», «the same random
+// order every time» instead of hoping for it.
+//
+//   installStage();                                                   // the commands below
+//   const shape = shapeRequest('POST', url);  // in the app's fetch wrapper: { delayMs, offline, status } or null
+//   pilotFlag('reduceMotion')                                         // what a test set with flags.set
+//
+//   net.shape {rules: [{match: '/api/Placement', mode: 'offline', times: 1}]}   the next matching request fails offline
+//   net.shape {rules: [{mode: 'delay', delayMs: 3000}]}                           every request 3 s slower
+//   net.shape {rules: [{match: '/api/', method: 'POST', mode: 'fail', status: 503}]}
+//   net.shape {rules: [{kind: 'socket', match: '/hub', mode: 'drop'}]}         the open hub connection drops NOW
+//   net.shape {rules: [{kind: 'socket', match: '/hub', mode: 'offline', times: 3}]}   open ones drop, the next 3 connects fail
+//   (socket rules reach a hub connection through the app's transport: shapeSocket(url) / onSocketDrop(listener))
+//   clock.set {offsetMs: 86400000} | {at: '2026-12-01T08:00:00Z'}  ·  clock.reset  ·  clock.status
+//   state.seed {seed: 42} | {off: true}     Math.random from a fixed seed (mulberry32)
+//   flags.set {name, value} · flags.get
+//
+// Everything is the PAGE's: requests the host makes natively (a sync hub's socket, map tiles) are not shaped — the
+// controller's `g9pilot os net` drops the device's whole network for those. Debug builds only, like every pilot module.
+import { optionalInt, optionalString, requireString } from './args.ts';
+import { emit } from './events.ts';
+import { PilotError } from './errors.ts';
+import { harAnswer, installHar, resetHarForTests } from './har.ts';
+import { registerCommand } from './registry.ts';
+
+// ---- the network ---------------------------------------------------------------------------------------------------
+
+export type ShapeMode = 'offline' | 'fail' | 'delay' | 'drop';
+
+export interface ShapeRule {
+  /** `request` (default): the page's fetch. `socket`: a hub connection (its socket and its own HTTP) — research R3. */
+  readonly kind?: 'request' | 'socket';
+  /** A part of the address (case-insensitive); none = every request. */
+  readonly match?: string;
+  readonly method?: string;
+  readonly mode: ShapeMode;
+  /** `fail`: the status the app gets (default 503). */
+  readonly status?: number;
+  /** `delay` (and before an offline/fail answer): how long the request waits first. */
+  readonly delayMs?: number;
+  /** How many requests it applies to (none = until cleared). */
+  times?: number;
+}
+
+export interface Shape {
+  readonly delayMs: number;
+  readonly offline: boolean;
+  readonly status: number | null;
+  /** A recorded answer to give instead of going to the network (net.har replay). */
+  readonly replay?: { readonly status: number; readonly mimeType: string; readonly text: string };
+}
+
+let rules: ShapeRule[] = [];
+let shaped = 0;
+const socketDroppers = new Set<(match: string | undefined) => number>();
+
+/**
+ * The app's transport registers how to drop its open connections (e.g. a hub client's `dropSockets(match)`); a
+ * `{kind: 'socket', mode: 'drop'}` rule calls it at once. Returns the unregister function.
+ */
+export function onSocketDrop(dropper: (match: string | undefined) => number): () => void {
+  socketDroppers.add(dropper);
+  return () => {
+    socketDroppers.delete(dropper);
+  };
+}
+
+/**
+ * What the app's transport asks before a hub connection (its socket, or its own HTTP: negotiate, long polling) goes out:
+ * `{offline: true}` = fail it as with no network. A rule with `times` counts connection attempts. null = untouched.
+ */
+export function shapeSocket(url: string): { readonly offline: boolean } | null {
+  const u = url.toLowerCase();
+  const i = rules.findIndex((r) => r.kind === 'socket' && r.mode === 'offline' && (!r.match || u.includes(r.match)));
+  if (i < 0) return null;
+  const rule = rules[i] as ShapeRule;
+  if (rule.times !== undefined) {
+    rule.times -= 1;
+    if (rule.times <= 0) rules.splice(i, 1);
+  }
+  shaped++;
+  emit('net.shaped', { kind: 'socket', url, mode: 'offline' });
+  return { offline: true };
+}
+
+function parseRules(value: unknown): ShapeRule[] {
+  if (!Array.isArray(value)) throw new PilotError('net.shape needs `rules`: a list, or `clear: true`.', { code: 'BAD_ARGS', fixExample: { command: 'net.shape', args: { rules: [{ match: '/api/', mode: 'offline', times: 1 }] } } });
+  return value.map((r, i) => {
+    const o = (r ?? {}) as Record<string, unknown>;
+    const mode = o.mode;
+    const kind = o.kind === 'socket' ? 'socket' : 'request';
+    if (o.kind !== undefined && o.kind !== 'socket' && o.kind !== 'request') throw new PilotError(`rules[${i}].kind must be request or socket.`, { code: 'BAD_ARGS' });
+    if (kind === 'socket' && mode !== 'offline' && mode !== 'drop') throw new PilotError(`rules[${i}]: a socket rule's mode is offline (connects fail) or drop (open connections drop now).`, { code: 'BAD_ARGS' });
+    if (kind === 'request' && mode !== 'offline' && mode !== 'fail' && mode !== 'delay') throw new PilotError(`rules[${i}].mode must be offline, fail or delay.`, { code: 'BAD_ARGS' });
+    const num = (v: unknown, lo: number, hi: number) => (typeof v === 'number' && Number.isFinite(v) ? Math.min(hi, Math.max(lo, Math.floor(v))) : undefined);
+    const delayMs = num(o.delayMs, 0, 120_000);
+    const times = num(o.times, 1, 10_000);
+    const rule: ShapeRule = {
+      ...(kind === 'socket' ? { kind } : {}),
+      mode: mode as ShapeMode,
+      ...(typeof o.match === 'string' && o.match ? { match: o.match.toLowerCase() } : {}),
+      ...(typeof o.method === 'string' && o.method ? { method: o.method.toUpperCase() } : {}),
+      ...(mode === 'fail' ? { status: num(o.status, 400, 599) ?? 503 } : {}),
+      ...(delayMs !== undefined ? { delayMs } : {}),
+      ...(times !== undefined ? { times } : {}),
+    };
+    if (mode === 'delay' && rule.delayMs === undefined) throw new PilotError(`rules[${i}]: a delay needs delayMs.`, { code: 'BAD_ARGS' });
+    return rule;
+  });
+}
+
+/**
+ * What the app's fetch wrapper does with one request: wait `delayMs`, then fail offline, answer `status`, or go on.
+ * The first matching rule wins; a rule with `times` is used up. null = untouched.
+ */
+export function shapeRequest(method: string, url: string): Shape | null {
+  const recordedAnswer = harAnswer(method, url);
+  if (recordedAnswer === 'abort') return { delayMs: 0, offline: true, status: null };
+  if (recordedAnswer) return { delayMs: 0, offline: false, status: null, replay: recordedAnswer };
+  if (rules.length === 0) return null;
+  const m = method.toUpperCase();
+  const u = url.toLowerCase();
+  const i = rules.findIndex((r) => r.kind !== 'socket' && (!r.match || u.includes(r.match)) && (!r.method || r.method === m));
+  if (i < 0) return null;
+  const rule = rules[i] as ShapeRule;
+  if (rule.times !== undefined) {
+    rule.times -= 1;
+    if (rule.times <= 0) rules.splice(i, 1);
+  }
+  shaped++;
+  emit('net.shaped', { method: m, url, mode: rule.mode });
+  return { delayMs: rule.delayMs ?? 0, offline: rule.mode === 'offline', status: rule.mode === 'fail' ? (rule.status ?? 503) : null };
+}
+
+// ---- the clock -----------------------------------------------------------------------------------------------------
+
+const RealDate = Date;
+const realNow = Date.now.bind(Date);
+let offsetMs = 0;
+let clockInstalled = false;
+
+function installClock(): void {
+  if (clockInstalled) return;
+  clockInstalled = true;
+  // `new Date()` and `Date.now()` see the shifted time; `new Date(x)` keeps meaning x. Timers are not affected.
+  const Shifted = function (this: unknown, ...args: unknown[]) {
+    if (!(this instanceof Shifted)) return new RealDate(realNow() + offsetMs).toString();
+    return args.length === 0 ? new RealDate(realNow() + offsetMs) : new (RealDate as unknown as new (...a: unknown[]) => Date)(...args);
+  } as unknown as DateConstructor;
+  Object.setPrototypeOf(Shifted, RealDate);
+  (Shifted as { prototype: Date }).prototype = RealDate.prototype;
+  (Shifted as { now: () => number }).now = () => realNow() + offsetMs;
+  (globalThis as { Date: DateConstructor }).Date = Shifted;
+}
+
+function resetClock(): void {
+  offsetMs = 0;
+  if (clockInstalled) (globalThis as { Date: DateConstructor }).Date = RealDate;
+  clockInstalled = false;
+}
+
+const clockStatus = () => ({ offsetMs, now: new RealDate(realNow() + offsetMs).toISOString(), real: new RealDate(realNow()).toISOString() });
+
+// ---- randomness ----------------------------------------------------------------------------------------------------
+
+const realRandom = Math.random;
+let seeded: number | null = null;
+
+function mulberry32(seed: number): () => number {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+// ---- flags ---------------------------------------------------------------------------------------------------------
+
+const flags = new Map<string, unknown>();
+const flagListeners = new Map<string, Set<(value: unknown) => void>>();
+
+/** A flag a test set (`flags.set {name, value}`), else `fallback`. */
+export function pilotFlag<T = unknown>(name: string, fallback: T | null = null): T | null {
+  return flags.has(name) ? (flags.get(name) as T) : fallback;
+}
+
+/** Called with the flag's value whenever a test sets or clears it. */
+export function onPilotFlag(name: string, listener: (value: unknown) => void): () => void {
+  const set = flagListeners.get(name) ?? new Set();
+  set.add(listener);
+  flagListeners.set(name, set);
+  return () => set.delete(listener);
+}
+
+function setFlag(name: string, value: unknown): void {
+  if (value === null || value === undefined) flags.delete(name);
+  else flags.set(name, value);
+  for (const l of Array.from(flagListeners.get(name) ?? [])) {
+    try {
+      l(value ?? null);
+    } catch {
+      // a listener's failure is its own
+    }
+  }
+}
+
+// ---- install -------------------------------------------------------------------------------------------------------
+
+/** The commands net.shape / net.status, clock.set / reset / status, state.seed, flags.set / get. */
+export function installStage(): () => void {
+  const offs = [
+    installHar(),
+    registerCommand(
+      'net.shape',
+      (args) => {
+        if (args.clear === true) {
+          rules = [];
+          return { rules, shaped };
+        }
+        const parsed = parseRules(args.rules);
+        // A drop happens now and is not kept: every open connection that matches is cut, as a lost network cuts it. Going
+        // offline cuts the open ones too (a hub client keeps its connection open between runs, so «the next connect
+        // fails» alone would never be reached) — and then its next connects fail.
+        let dropped = 0;
+        for (const r of parsed.filter((x) => x.kind === 'socket')) {
+          for (const d of Array.from(socketDroppers)) {
+            try {
+              dropped += d(r.match);
+            } catch {
+              // a transport's failure to drop is its own; the count says what happened
+            }
+          }
+          emit('net.shaped', { kind: 'socket', mode: r.mode, match: r.match ?? null, dropped: true });
+        }
+        rules = parsed.filter((x) => !(x.kind === 'socket' && x.mode === 'drop'));
+        const droppers = socketDroppers.size;
+        return { rules, shaped, ...(parsed.some((x) => x.kind === 'socket') ? { dropped, droppers } : {}) };
+      },
+      { scope: 'stage', description: 'Shapes the requests the page makes: offline, fail with a status, or delay — by address part and method, for `times` requests or until cleared. `kind: socket`: a hub connection — `drop` cuts the open ones now, `offline` fails the next connects.', example: { rules: [{ match: '/api/', mode: 'offline', times: 1 }] } },
+    ),
+    registerCommand('net.status', () => ({ rules, shaped }), { scope: 'observe', description: 'The shaping rules in force and how many requests they shaped.' }),
+    registerCommand(
+      'clock.set',
+      (args) => {
+        const at = optionalString(args, 'at');
+        if (at !== null) {
+          const t = RealDate.parse(at);
+          if (!Number.isFinite(t)) throw new PilotError(`"${at}" is not a date (an ISO time, e.g. 2026-12-01T08:00:00Z).`, { code: 'BAD_ARGS' });
+          offsetMs = t - realNow();
+        } else if (typeof args.offsetMs === 'number' && Number.isFinite(args.offsetMs)) {
+          offsetMs = Math.trunc(args.offsetMs);
+        } else {
+          throw new PilotError('clock.set needs `offsetMs` or `at`.', { code: 'BAD_ARGS', fixExample: { command: 'clock.set', args: { offsetMs: 86_400_000 } } });
+        }
+        installClock();
+        emit('clock', clockStatus());
+        return clockStatus();
+      },
+      { scope: 'stage', description: 'Moves the page’s clock (Date and Date.now; timers keep real time): by `offsetMs`, or to `at`. The server keeps its own time.', example: { offsetMs: 86_400_000 } },
+    ),
+    registerCommand(
+      'clock.reset',
+      () => {
+        resetClock();
+        return clockStatus();
+      },
+      { scope: 'stage', description: 'The real clock again.' },
+    ),
+    registerCommand('clock.status', () => clockStatus(), { scope: 'observe' }),
+    registerCommand(
+      'state.seed',
+      (args) => {
+        if (args.off === true) {
+          Math.random = realRandom;
+          seeded = null;
+        } else {
+          seeded = optionalInt(args, 'seed', 1);
+          Math.random = mulberry32(seeded);
+        }
+        return { seeded };
+      },
+      { scope: 'stage', description: 'Math.random from a fixed seed (the same sequence every run), or `off: true`.', example: { seed: 42 } },
+    ),
+    registerCommand(
+      'flags.set',
+      (args) => {
+        const name = requireString(args, 'name');
+        setFlag(name, args.value ?? null);
+        return { flags: Object.fromEntries(flags) };
+      },
+      { scope: 'stage', description: 'A named flag the app reads (pilotFlag); value null clears it.', example: { name: 'reduceMotion', value: true } },
+    ),
+    registerCommand('flags.get', () => ({ flags: Object.fromEntries(flags) }), { scope: 'observe', description: 'The flags a test set.' }),
+  ];
+  return () => {
+    for (const off of offs) off();
+    resetStageForTests();
+  };
+}
+
+/** For tests (and uninstall): no rules, the real clock and Math.random, no flags. */
+export function resetStageForTests(): void {
+  resetHarForTests();
+  rules = [];
+  shaped = 0;
+  resetClock();
+  Math.random = realRandom;
+  seeded = null;
+  flags.clear();
+}

package/src/vitals.ts

@@ -0,0 +1,196 @@
+// The page’s vital signs as oracles (plan v2 P1-07, research R7): a thread that stopped answering and memory that keeps
+// growing are wrong without anyone asking, like a JS error — a flow needs no step for them.
+//
+//   perf.longFrame    a thread did not answer for ≥ longFrameMs (700): `js` = the page’s own thread (a heartbeat here,
+//                     platform-free), `main` = the host’s UI thread (the adapter’s `read` reports its stalls: a native
+//                     heartbeat on the main looper / run loop, only while the app is in front, never under a debugger)
+//   perf.memoryGrowth the process’s memory stayed ≥ growthMb AND ≥ growthRatio above the session’s baseline for `sustain`
+//                     readings in a row (a map load’s spike is not a leak; a screen that leaks on every visit is)
+//
+//   perf.vitals       (observe) the recent stalls and the memory series, for the controller’s own judgement
+//
+// Measured by heartbeats, not by every frame: a frame callback on every vsync would keep an idle device awake and cost
+// the measurements it is meant to protect. What a heartbeat sees is what a person sees — the screen did not move.
+// Memory is the cheap reading (Android: resident set from /proc/self/statm; iOS: phys_footprint, what Xcode’s gauge shows):
+// PSS costs 100+ ms a reading (research R7), too much to take every few seconds.
+import { emit } from './events.ts';
+import { reportViolation } from './oracles.ts';
+import { registerCommand } from './registry.ts';
+
+/** The device's clock as it was at load: `clock.set` moves the page's Date.now for a test, never the vitals' readings. */
+const realNow = Date.now.bind(Date);
+
+export interface VitalsStall {
+  /** Wall-clock ms when the thread answered again. */
+  readonly at: number;
+  /** How long it did not answer. */
+  readonly ms: number;
+}
+
+/** What the host reports on each reading. */
+export interface VitalsReading {
+  /** The main thread’s stalls the host kept (the newest last); only those after the last reading are new. */
+  readonly stalls?: readonly VitalsStall[];
+  readonly memoryMb?: number | null;
+  /** What memoryMb is ('rss', 'phys_footprint'). */
+  readonly memoryKind?: string;
+  /**
+   * What the page's own runtime says it holds, in MB (Lynx `lynx.performance.getMemoryUsage`: the JS heap, the elements,
+   * the UI) — the split of `memoryMb` a leak hunt needs first. Kept as the newest reading only.
+   */
+  readonly page?: Readonly<Record<string, number>>;
+}
+
+export interface VitalsOptions {
+  /** How often the host is read (default 5 s). */
+  readonly intervalMs?: number;
+  /** A thread silent this long is a long frame (default 700 ms). */
+  readonly longFrameMs?: number;
+  /** The page’s heartbeat (default 250 ms). */
+  readonly heartbeatMs?: number;
+  /** Memory rules: growth over the baseline in MB and as a share of it, both needed (defaults 150 MB, 0.5). */
+  readonly growthMb?: number;
+  readonly growthRatio?: number;
+  /** Readings taken before this (from install) set no baseline: start-up fills caches (default 30 s). */
+  readonly warmupMs?: number;
+  /** Readings in a row over the line before it counts (default 3). */
+  readonly sustain?: number;
+}
+
+interface Sample {
+  readonly t: number;
+  readonly mb: number;
+}
+
+const KEEP_SAMPLES = 120;
+const KEEP_STALLS = 50;
+/** A gap this long is the app being suspended (a background, a frozen cached process), not a hang. */
+const SUSPENDED_MS = 30_000;
+
+/** The pure part (tests drive it with their own clock). */
+export function createVitalsWatch(options: VitalsOptions = {}, startedAt = realNow()) {
+  const longFrameMs = options.longFrameMs ?? 700;
+  const growthMb = options.growthMb ?? 150;
+  const growthRatio = options.growthRatio ?? 0.5;
+  const warmupMs = options.warmupMs ?? 30_000;
+  const sustain = Math.max(1, options.sustain ?? 3);
+  const samples: Sample[] = [];
+  const stalls: Array<VitalsStall & { thread: 'js' | 'main' }> = [];
+  let lastMainAt = 0;
+  let lastBeat = 0;
+  let baseline: number | null = null;
+  let peak: number | null = null;
+  let over = 0;
+  let kind: string | null = null;
+  let page: Readonly<Record<string, number>> | null = null;
+
+  const stall = (thread: 'js' | 'main', s: VitalsStall) => {
+    stalls.push({ thread, ...s });
+    if (stalls.length > KEEP_STALLS) stalls.shift();
+    const what = thread === 'js' ? 'the page thread' : 'the UI thread';
+    reportViolation('perf.longFrame', thread, `${what} did not answer for ${Math.round(s.ms)} ms (a person sees the screen stop).`, { thread, ms: Math.round(s.ms), at: s.at });
+  };
+
+  return {
+    /** The page’s heartbeat: call it every periodMs; a late beat is a stall of the page’s thread. */
+    beat(now: number, periodMs: number, wallNow: number = now): void {
+      if (lastBeat > 0) {
+        const silent = now - lastBeat - periodMs;
+        if (silent >= longFrameMs && silent < SUSPENDED_MS) stall('js', { at: wallNow, ms: silent });
+      }
+      lastBeat = now;
+    },
+    /** One reading of the host. */
+    read(r: VitalsReading | null, now: number): void {
+      if (!r) return;
+      if (r.page && typeof r.page === 'object') page = r.page;
+      for (const s of r.stalls ?? []) {
+        if (s.at <= lastMainAt) continue;
+        lastMainAt = s.at;
+        if (s.ms >= longFrameMs && s.ms < SUSPENDED_MS) stall('main', s);
+      }
+      if (typeof r.memoryMb !== 'number' || !Number.isFinite(r.memoryMb)) return;
+      kind = r.memoryKind ?? kind;
+      const mb = r.memoryMb;
+      samples.push({ t: now, mb });
+      if (samples.length > KEEP_SAMPLES) samples.shift();
+      peak = peak === null ? mb : Math.max(peak, mb);
+      if (now - startedAt < warmupMs) return;
+      // The baseline is the lowest reading after warm-up: the app at rest. It can only fall (a GC after warm-up).
+      if (baseline === null || mb < baseline) baseline = mb;
+      const grown = mb - baseline;
+      over = grown >= growthMb && grown >= baseline * growthRatio ? over + 1 : 0;
+      if (over === sustain) {
+        reportViolation(
+          'perf.memoryGrowth',
+          'session',
+          `Memory grew from ${Math.round(baseline)} MB to ${Math.round(mb)} MB during the session (+${Math.round(grown)} MB) and stayed there.`,
+          { baselineMb: Math.round(baseline), currentMb: Math.round(mb), peakMb: Math.round(peak), kind, samples: samples.slice(-20).map((s) => Math.round(s.mb)) },
+        );
+        emit('perf.memoryGrowth', { baselineMb: Math.round(baseline), currentMb: Math.round(mb) });
+      }
+    },
+    state() {
+      const current = samples.length ? samples[samples.length - 1]!.mb : null;
+      return {
+        stalls: stalls.slice(-20),
+        memory: { kind, baselineMb: baseline, currentMb: current, peakMb: peak, samples: samples.slice(-60).map((s) => ({ t: s.t, mb: Math.round(s.mb * 10) / 10 })), ...(page ? { page } : {}) },
+        rules: { longFrameMs, growthMb, growthRatio, warmupMs, sustain },
+      };
+    },
+  };
+}
+
+/**
+ * The heartbeat's clock: monotonic when the runtime has one (`performance.now`), else the device's wall clock as it was
+ * at load — never the page's Date.now, which a test's `clock.set` moves (a +5 s offset would read as a 5 s stall). The wall
+ * clock still jumps when the device's time is corrected (an emulator snapshot restored, NTP), and a jump forward looks
+ * exactly like a stall (2026-11-05: three «7 s» page-thread stalls after a snapshot load, none on a clean start; Lynx's
+ * background thread has no performance.now).
+ */
+export function heartbeatClock(): { readonly now: () => number; readonly kind: 'monotonic' | 'wall' } {
+  const perf = (globalThis as { performance?: { now?: () => number } }).performance;
+  if (perf && typeof perf.now === 'function') {
+    try {
+      const t = perf.now();
+      if (Number.isFinite(t)) return { now: () => perf.now!(), kind: 'monotonic' };
+    } catch {
+      // fall through
+    }
+  }
+  return { now: realNow, kind: 'wall' };
+}
+
+/**
+ * Starts the heartbeat and the host readings (`read` = the adapter’s native call; null = no host readings, the page’s
+ * heartbeat only) and registers `perf.vitals`. Returns the uninstaller.
+ */
+export function installVitals(read: (() => Promise<VitalsReading | null>) | null, options: VitalsOptions = {}): () => void {
+  const watch = createVitalsWatch(options);
+  const heartbeatMs = options.heartbeatMs ?? 250;
+  const clock = heartbeatClock();
+  // A stall is measured on the heartbeat's clock and reported at wall time (`at`): beat() takes both.
+  const beat = setInterval(() => watch.beat(clock.now(), heartbeatMs, realNow()), heartbeatMs);
+  let busy = false;
+  const poll = read
+    ? setInterval(() => {
+        if (busy) return;
+        busy = true;
+        read()
+          .then((r) => watch.read(r, realNow()))
+          .catch(() => undefined)
+          .finally(() => {
+            busy = false;
+          });
+      }, options.intervalMs ?? 5_000)
+    : null;
+  const off = registerCommand('perf.vitals', () => ({ ...watch.state(), heartbeatClock: clock.kind }), {
+    scope: 'observe',
+    description: 'The recent long frames (the page thread and the UI thread) and the memory series with its baseline: what the perf.longFrame and perf.memoryGrowth oracles judge.',
+  });
+  return () => {
+    clearInterval(beat);
+    if (poll) clearInterval(poll);
+    off();
+  };
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-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.