@g9tm/app-pilot 0.0.0-stage → 0.1.0

package/src/recorder.ts

@@ -0,0 +1,382 @@
+// `flow.record.*`: what a person (or an agent through the bridge) did on the device, as steps a flow can replay.
+//
+// Recorder v2 (plan §9.2) records everything a flow can say, not only taps:
+//   tap        the target the finger touched — its testId IS the id a flow taps — from a capture-phase listener on every
+//              registered target (test builds only). One tap across nested targets records the INNERMOST.
+//   type       a field whose value changed between the tap that focused it and the next step (the adapter's `fieldValue`
+//              reads it — no keyboard hook); a secret field records a parameter placeholder, never the text
+//   setValue   a picker / switch / date set through the bridge (`ui.setValue`)
+//   swipe, longPress, selectItem, popupButton, dismiss
+//              the bridge's gestures and actions (`ui.swipe`, `ui.longPress`, …) as their flow steps
+//   bridge     any other command that changes something (stage, design, an app's own drive command) — a setup step
+// and, from the app's own events, SUGGESTED CHECKS: an announcement right after a step («saved», a navigation) becomes an
+// `expectEvent` the reviewer may keep — never added on its own.
+//
+//   always on   a ring of the last 500 steps; `flow.record.harvest` drains it as candidates split at 60 s of silence
+//   a session   `flow.record.start` … `flow.record.stop`: up to 5,000 steps, then `truncated`
+//
+// A step is {kind, contractId, targetType, at, durationMs} plus what its kind needs (value, direction, command, args).
+import { onAnswer } from './dispatch.ts';
+import { onEmit } from './events.ts';
+import { commandScope, registerCommand } from './registry.ts';
+
+export type RecordedKind = 'tap' | 'type' | 'setValue' | 'swipe' | 'longPress' | 'selectItem' | 'popupButton' | 'dismiss' | 'bridge';
+
+export interface RecordedStep {
+  readonly kind: RecordedKind;
+  /** The testId (the automationId a flow addresses); '' for a step with no target (dismiss, bridge, a screen swipe). */
+  readonly contractId: string;
+  /** The target's type (Button, TabItem, Entry, …); '' when there is none. */
+  readonly targetType: string;
+  readonly at: number;
+  readonly durationMs: number;
+  /** type / setValue: the value; a secret field records `{{secret:<id>}}` instead. */
+  readonly value?: string;
+  /** swipe: where the finger went. */
+  readonly direction?: string;
+  /** selectItem: the row (itemId / text); popupButton: the caption. */
+  readonly item?: Readonly<Record<string, string>>;
+  /** bridge: the command and its arguments. */
+  readonly command?: string;
+  readonly args?: Readonly<Record<string, unknown>>;
+}
+
+/** A check the recording suggests from an event the app raised right after a step. Never applied by itself. */
+export interface SuggestedCheck {
+  /** Index of the step it follows (in the returned steps). */
+  readonly afterStep: number;
+  readonly step: { readonly action: 'expectEvent'; readonly kind: string; readonly match: Readonly<Record<string, unknown>>; readonly within: number };
+  /** In words: what the app said. */
+  readonly why: string;
+}
+
+/** What the recorder can ask the app (the Lynx adapter configures it from the testId registry). */
+export interface RecorderPort {
+  /** The value a field shows now (null: no such target, or it has no value). */
+  readonly fieldValue?: (contractId: string) => string | null;
+  /** A field whose text must never be recorded (a password). */
+  readonly isSecret?: (contractId: string, targetType: string) => boolean;
+}
+
+export const MAX_STEPS = 5_000;
+export const PASSIVE_CAPACITY = 500;
+export const CANDIDATE_GAP_MS = 60_000;
+/** Taps on nested targets arrive within one event dispatch: closer than this, they are the same tap. */
+export const SAME_TAP_MS = 40;
+/** An event this soon after a step is that step's consequence (a toast after Save). */
+export const SUGGEST_WITHIN_MS = 3_000;
+/** Targets whose value a person types or picks. */
+export const FIELD_TYPES: ReadonlySet<string> = /* @__PURE__ */ new Set(['Entry', 'Editor', 'SearchBar', 'SearchEntry', 'TextField', 'Password']);
+
+interface PendingField {
+  readonly contractId: string;
+  readonly targetType: string;
+  readonly before: string | null;
+}
+
+export class PilotRecorder {
+  private steps: RecordedStep[] = [];
+  private startedAt = 0;
+  private recording = false;
+  private truncated = false;
+  private passive: RecordedStep[] = [];
+  private passiveDropped = 0;
+  private pending: PendingField | null = null;
+  private suggestions: SuggestedCheck[] = [];
+  private port: RecorderPort = {};
+
+  private readonly now: () => number;
+
+  constructor(now: () => number = Date.now) {
+    this.now = now;
+  }
+
+  get isRecording(): boolean {
+    return this.recording;
+  }
+
+  /** The adapter's answers (field values, secret fields). */
+  configure(port: RecorderPort): void {
+    this.port = { ...this.port, ...port };
+  }
+
+  /** One target touched (the capture listener). Never throws. */
+  tap(contractId: string, targetType: string): void {
+    if (!contractId) return;
+    this.flushField();
+    this.push({ kind: 'tap', contractId, targetType, at: this.now(), durationMs: 0 });
+    if (FIELD_TYPES.has(targetType)) this.pending = { contractId, targetType, before: this.read(contractId) };
+  }
+
+  /** A person's own drag that started on a target (the capture listener): a `swipe` step. Never throws. */
+  swipe(contractId: string, direction: string): void {
+    if (!contractId) return;
+    this.flushField();
+    this.push({ kind: 'swipe', contractId, targetType: '', at: this.now(), durationMs: 0, direction });
+  }
+
+  /**
+   * A controller's ui.swipe (a real drag the capture listener heard a moment ago, maybe on an inner target): the
+   * controller's own step — its target and direction — replaces that one instead of following it.
+   */
+  swipeCommand(contractId: string, direction: string): void {
+    const step: RecordedStep = { kind: 'swipe', contractId, targetType: '', at: this.now(), durationMs: 0, direction };
+    const replace = (list: RecordedStep[]) => {
+      const last = list[list.length - 1];
+      return last?.kind === 'swipe' && step.at - last.at < 2_000 ? [...list.slice(0, -1), step] : null;
+    };
+    this.flushField();
+    const passive = replace(this.passive);
+    const steps = this.recording ? replace(this.steps) : null;
+    if (!passive && !steps) return this.push(step);
+    this.passive = passive ?? PilotRecorder.append(this.passive, step, PASSIVE_CAPACITY, () => this.passiveDropped++);
+    if (this.recording) this.steps = steps ?? PilotRecorder.append(this.steps, step, Number.POSITIVE_INFINITY, () => {});
+  }
+
+  /** A step that is not a tap (an adapter's gesture, or a bridge command). Never throws. */
+  record(step: Omit<RecordedStep, 'at' | 'durationMs'> & { readonly durationMs?: number }): void {
+    this.flushField();
+    this.push({ ...step, at: this.now(), durationMs: step.durationMs ?? 0 });
+  }
+
+  /** A field set through the bridge (ui.type / ui.setValue): its value, masked when secret, replaces a pending read. */
+  fieldSet(kind: 'type' | 'setValue', contractId: string, value: string): void {
+    this.pending = null;
+    this.push({ kind, contractId, targetType: '', at: this.now(), durationMs: 0, value: this.mask(contractId, '', value) });
+  }
+
+  /** An announcement the app raised (recordEvent filtered out telemetry): right after a step, a suggested check. */
+  suggest(kind: string, data: unknown): void {
+    if (!this.recording || this.steps.length === 0) return;
+    const last = this.steps.length - 1;
+    const step = this.steps[last]!;
+    // the recorder's own clock, the one its steps carry
+    if (this.now() - step.at > SUGGEST_WITHIN_MS) return;
+    if (this.suggestions.some((s) => s.afterStep === last && s.step.kind === kind)) return;
+    const match: Record<string, unknown> = {};
+    if (data && typeof data === 'object' && !Array.isArray(data)) {
+      for (const [k, v] of Object.entries(data as Record<string, unknown>)) {
+        if (typeof v === 'string' && v.length <= 120) match[k] = v;
+        else if (typeof v === 'number' || typeof v === 'boolean') match[k] = v;
+      }
+    }
+    const said = typeof (data as { text?: unknown } | null)?.text === 'string' ? `«${(data as { text: string }).text}»` : kind;
+    this.suggestions.push({ afterStep: last, step: { action: 'expectEvent', kind, match, within: 5_000 }, why: `the app said ${said} right after step ${last + 1}` });
+  }
+
+  start(): { recording: true; startedAt: number } {
+    this.steps = [];
+    this.suggestions = [];
+    this.pending = null;
+    this.truncated = false;
+    this.startedAt = this.now();
+    this.recording = true;
+    return { recording: true, startedAt: this.startedAt };
+  }
+
+  stop(): { recording: false; startedAt: number; stoppedAt: number; truncated: boolean; stepCount: number; steps: readonly RecordedStep[]; suggestions: readonly SuggestedCheck[] } {
+    this.flushField();
+    this.recording = false;
+    return { recording: false, startedAt: this.startedAt, stoppedAt: this.now(), truncated: this.truncated, stepCount: this.steps.length, steps: this.steps.slice(), suggestions: this.suggestions.slice() };
+  }
+
+  status(): { recording: boolean; startedAt: number; stepCount: number; truncated: boolean; suggestions: number } {
+    return { recording: this.recording, startedAt: this.startedAt, stepCount: this.steps.length, truncated: this.truncated, suggestions: this.suggestions.length };
+  }
+
+  /** Drains the always-on ring as candidates split at a minute of silence. */
+  harvest(): { candidates: Array<{ startedAt: number; endedAt: number; steps: readonly RecordedStep[] }>; count: number; buffer: { capacity: number; dropped: number } } {
+    this.flushField();
+    const steps = this.passive;
+    const dropped = this.passiveDropped;
+    this.passive = [];
+    this.passiveDropped = 0;
+    const candidates: Array<{ startedAt: number; endedAt: number; steps: readonly RecordedStep[] }> = [];
+    let first = 0;
+    for (let i = 1; i <= steps.length; i++) {
+      if (i < steps.length && steps[i]!.at - steps[i - 1]!.at <= CANDIDATE_GAP_MS) continue;
+      const part = steps.slice(first, i);
+      if (part.length > 0) candidates.push({ startedAt: part[0]!.at - part[0]!.durationMs, endedAt: part[part.length - 1]!.at, steps: part });
+      first = i;
+    }
+    return { candidates, count: steps.length, buffer: { capacity: PASSIVE_CAPACITY, dropped } };
+  }
+
+  /** The field tapped last: its new value becomes a `type` step before whatever comes next. */
+  private flushField(): void {
+    const p = this.pending;
+    if (!p) return;
+    this.pending = null;
+    const now = this.read(p.contractId);
+    if (now === null || now === p.before) return;
+    this.push({ kind: 'type', contractId: p.contractId, targetType: p.targetType, at: this.now(), durationMs: 0, value: this.mask(p.contractId, p.targetType, now) });
+  }
+
+  private read(contractId: string): string | null {
+    try {
+      return this.port.fieldValue?.(contractId) ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  private mask(contractId: string, targetType: string, value: string): string {
+    let secret = targetType === 'Password' || /pass(word)?|secret|token|pin\b/i.test(contractId);
+    try {
+      secret = this.port.isSecret?.(contractId, targetType) ?? secret;
+    } catch {
+      // keep the name-based guess
+    }
+    return secret ? `{{secret:${contractId}}}` : value;
+  }
+
+  private push(step: RecordedStep): void {
+    this.passive = PilotRecorder.append(this.passive, step, PASSIVE_CAPACITY, () => this.passiveDropped++);
+    if (!this.recording) return;
+    if (this.steps.length >= MAX_STEPS && !PilotRecorder.sameTap(this.steps[this.steps.length - 1], step)) {
+      this.truncated = true;
+      this.recording = false;
+      return;
+    }
+    this.steps = PilotRecorder.append(this.steps, step, Number.POSITIVE_INFINITY, () => {});
+  }
+
+  private static sameTap(previous: RecordedStep | undefined, next: RecordedStep): boolean {
+    // the same touch heard by nested targets (outermost first): one step, the innermost target's — a tap, or a swipe
+    return (
+      previous !== undefined &&
+      previous.kind === next.kind &&
+      (next.kind === 'tap' || (next.kind === 'swipe' && previous.direction === next.direction && previous.targetType === '')) &&
+      next.at - previous.at < SAME_TAP_MS
+    );
+  }
+
+  /** Appends, replacing the previous step when it is the same tap on an outer target; the oldest goes past [cap]. */
+  private static append(list: RecordedStep[], step: RecordedStep, cap: number, onDrop: () => void): RecordedStep[] {
+    const previous = list[list.length - 1];
+    if (PilotRecorder.sameTap(previous, step)) return [...list.slice(0, -1), step];
+    const next = [...list, step];
+    if (next.length > cap) {
+      onDrop();
+      return next.slice(next.length - cap);
+    }
+    return next;
+  }
+}
+
+/** The app's recorder (test builds; @g9tm/app-pilot-lynx's testId tap listener feeds it). */
+export const pilotRecorder = /* @__PURE__ */ new PilotRecorder();
+
+/**
+ * A recorded step as a FlowSpec step (`s1`, `s2`, …): what a reviewer saves after reading it. With the whole recording
+ * (`steps.map(flowStepOf)` passes it), a step also keeps `gapMs` — the person's pause before it (≥ 300 ms), which a runner
+ * replays with `--timing recorded` (a debounce, an animation the person waited out).
+ */
+export function flowStepOf(step: RecordedStep, index: number, all?: readonly RecordedStep[]): Record<string, unknown> {
+  const previous = index > 0 ? all?.[index - 1] : undefined;
+  const gap = previous ? Math.max(0, Math.round(step.at - previous.at - previous.durationMs)) : 0;
+  const out = flowStepBody(step, index);
+  return gap >= 300 ? { ...out, gapMs: gap } : out;
+}
+
+function flowStepBody(step: RecordedStep, index: number): Record<string, unknown> {
+  const id = `s${index + 1}`;
+  const target = step.contractId ? { target: { automationId: step.contractId } } : {};
+  switch (step.kind) {
+    case 'tap':
+      return { id, action: 'click', ...target };
+    case 'type':
+      return { id, action: 'type', ...target, value: step.value ?? '' };
+    case 'setValue':
+      return { id, action: 'setValue', ...target, value: step.value ?? '' };
+    case 'swipe':
+      return { id, action: 'swipe', ...target, direction: step.direction ?? '' };
+    case 'longPress':
+      return { id, action: 'longPress', ...target };
+    case 'selectItem':
+      return { id, action: 'selectItem', target: { automationId: step.contractId, ...(step.item ?? {}) } };
+    case 'popupButton':
+      return { id, action: 'popupButton', value: step.item?.text ?? '' };
+    case 'dismiss':
+      return { id, action: 'dismiss' };
+    default:
+      return { id, action: 'bridge', command: step.command ?? '', args: step.args ?? {} };
+  }
+}
+
+/**
+ * A command a controller sent, as it left the bridge: recorded when it changed something and a flow can say it.
+ * Outside the class on purpose: the command names are the QA bridge's, and a production bundle keeps the class (a
+ * minifier does not drop a class declaration) — only this function, used by registerRecorderCommands alone, goes.
+ */
+export function recordCommand(recorder: PilotRecorder, command: string, args: Readonly<Record<string, unknown>>, ok: boolean, result: unknown): void {
+  // the recorder's own commands, leases and the bridge's health checks are never steps
+  if (!ok || command.startsWith('flow.record.') || command.startsWith('lease.') || command.startsWith('qa.')) return;
+  const id = typeof args.automationId === 'string' ? args.automationId : '';
+  switch (command) {
+    case 'ui.tap':
+      // a real touch was already recorded by the capture listener; a handler activation was not
+      if ((result as { via?: unknown } | null)?.via === 'handler') recorder.record({ kind: 'tap', contractId: id, targetType: '' });
+      return;
+    case 'ui.swipe':
+      recorder.swipeCommand(id, String(args.direction ?? ''));
+      return;
+    case 'ui.longPress':
+      recorder.record({ kind: 'longPress', contractId: id, targetType: '' });
+      return;
+    case 'ui.type':
+    case 'ui.setValue':
+      recorder.fieldSet(command === 'ui.type' ? 'type' : 'setValue', id, typeof args.value === 'string' ? args.value : '');
+      return;
+    case 'ui.selectItem': {
+      const item: Record<string, string> = {};
+      for (const k of ['itemId', 'idField', 'text']) if (typeof args[k] === 'string') item[k] = args[k] as string;
+      recorder.record({ kind: 'selectItem', contractId: id, targetType: '', item });
+      return;
+    }
+    case 'ui.tapPopupButton':
+      recorder.record({ kind: 'popupButton', contractId: '', targetType: '', item: { text: String(args.text ?? '') } });
+      return;
+    case 'ui.dismissOverlay':
+      recorder.record({ kind: 'dismiss', contractId: '', targetType: '' });
+      return;
+    default:
+      // another ui.* command is a read or a wait; anything else that is not observe is a setup step
+      if (command.startsWith('ui.')) return;
+      recorder.record({ kind: 'bridge', contractId: '', targetType: '', command, args: { ...args } });
+  }
+}
+
+/** Event kinds that are telemetry, never an announcement worth checking. */
+const isTelemetry = (kind: string): boolean =>
+  ['log', 'log.line', 'net', 'net.body', 'net.shaped', 'trace', 'audit', 'store.change', 'perf.frame', 'oracle.violation', 'design.changed', 'clock', 'info', 'warn', 'error'].includes(kind);
+
+/** An event the app raised, as the recorder sees it: an announcement may become a suggested check. */
+export function recordEvent(recorder: PilotRecorder, kind: string, data: unknown): void {
+  if (!isTelemetry(kind)) recorder.suggest(kind, data);
+}
+
+/** `flow.record.start | stop | status | harvest` over [recorder], and the feeds: bridge answers and app events. */
+export function registerRecorderCommands(recorder: PilotRecorder = pilotRecorder): () => void {
+  const offs = [
+    registerCommand('flow.record.start', () => recorder.start(), { scope: 'drive', description: 'Starts recording what a person (or an agent) does: taps, typing, gestures, bridge steps.' }),
+    registerCommand(
+      'flow.record.stop',
+      () => {
+        const r = recorder.stop();
+        return { ...r, flowSteps: r.steps.map(flowStepOf) };
+      },
+      { scope: 'drive', description: 'Stops the recording: its steps, the same as FlowSpec steps, and the checks its events suggest.' },
+    ),
+    registerCommand('flow.record.status', () => recorder.status(), { scope: 'observe', description: 'Whether a recording runs, how long it is, how many checks it suggests.' }),
+    registerCommand('flow.record.harvest', () => recorder.harvest(), { scope: 'observe', description: 'Drains the always-on ring of recent steps as flow candidates.' }),
+    onAnswer((request, answer) => {
+      // a read changes nothing a replay must repeat
+      if (commandScope(request.command) === 'observe') return;
+      const args = (request.args ?? {}) as Readonly<Record<string, unknown>>;
+      recordCommand(recorder, request.command, args, answer.ok, answer.ok ? (answer as { result?: unknown }).result : null);
+    }),
+    onEmit((kind, data) => recordEvent(recorder, kind, data)),
+  ];
+  return () => offs.forEach((off) => off());
+}

package/src/registry.ts

@@ -0,0 +1,98 @@
+// The command registry. Any module of an app registers its commands:
+//
+//   import { registerCommand, PilotError } from '@g9tm/app-pilot';
+//   registerCommand('map.status', async (args, ctx) => ({ present: true }), { scope: 'observe', description: '…' });
+//   throw new PilotError('No map is on screen.', { code: 'NOT_FOUND', hint: 'Open the map tab first.' });
+//
+// The manifest (`manifest()`) is what the native side announces as `pilot.capabilities` and what an MCP server turns
+// into tools: name, scope, description (English, and Persian when given), whether it changes something, an example.
+import { defaultScope, type PilotScope } from './scopes.ts';
+
+export type PilotArgs = Readonly<Record<string, unknown>>;
+
+export interface PilotContext {
+  /** The request's timeout (default 30 000, clamped 1 000–120 000). */
+  readonly timeoutMs: number;
+  /** The lease id the request carried (lease.* commands read it). */
+  readonly leaseId: string | null;
+  /** The key that signed the request (null: an unsigned request a migration window allowed). */
+  readonly kid: string | null;
+  /** That key's scopes. */
+  readonly scopes: readonly string[];
+}
+
+export type PilotHandler = (args: PilotArgs, ctx: PilotContext) => unknown | Promise<unknown>;
+
+export interface CommandMeta {
+  readonly scope?: PilotScope;
+  readonly description?: string;
+  readonly descriptionFa?: string;
+  /** It changes the app or the world (false: a pure read). Default: scope !== 'observe'. */
+  readonly mutating?: boolean;
+  /** One correct call, for the manifest, the help and the error hints. */
+  readonly example?: Readonly<Record<string, unknown>>;
+  /** JSON Schema of the arguments (optional; MCP tools use it). */
+  readonly argsSchema?: Readonly<Record<string, unknown>>;
+}
+
+export interface ManifestEntry extends CommandMeta {
+  readonly name: string;
+  readonly scope: PilotScope;
+  readonly mutating: boolean;
+}
+
+interface Entry {
+  readonly handler: PilotHandler;
+  readonly meta: CommandMeta;
+}
+
+const entries = new Map<string, Entry>();
+const listeners = new Set<() => void>();
+
+export function registerCommand(name: string, handler: PilotHandler, meta: CommandMeta = {}): () => void {
+  const entry = { handler, meta };
+  entries.set(name, entry);
+  for (const l of Array.from(listeners)) l();
+  return () => {
+    if (entries.get(name) === entry) {
+      entries.delete(name);
+      for (const l of Array.from(listeners)) l();
+    }
+  };
+}
+
+export const commandHandler = (name: string): PilotHandler | undefined => entries.get(name)?.handler;
+export const commandNames = (): string[] => [...entries.keys()].sort();
+
+export function commandScope(name: string): PilotScope {
+  return entries.get(name)?.meta.scope ?? defaultScope(name);
+}
+
+/** A registered command that only reads (scope observe, not declared mutating). */
+export function isPureRead(name: string): boolean {
+  const meta = entries.get(name)?.meta;
+  if (!meta) return false;
+  const scope = meta.scope ?? defaultScope(name);
+  return scope === 'observe' && (meta.mutating ?? false) === false;
+}
+
+export function manifest(): ManifestEntry[] {
+  return commandNames().map((name) => {
+    const meta = entries.get(name)!.meta;
+    const scope = meta.scope ?? defaultScope(name);
+    return { ...meta, name, scope, mutating: meta.mutating ?? scope !== 'observe' };
+  });
+}
+
+/** The transport re-announces the manifest to the native listener whenever it changes. */
+export function onCommandsChanged(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+/** Tests: start from an empty registry. */
+export function resetRegistryForTests(): void {
+  entries.clear();
+}

package/src/scopes.ts

@@ -0,0 +1,30 @@
+// What a key may do (pilot/protocol/PROTOCOL.md «Scopes»). A command declares its scope when it registers; a command
+// registered without one gets the scope its NAME implies (defaultScope) — so an app's existing commands are classified
+// the day the library arrives, and a declaration wins over the guess.
+
+export type PilotScope = 'observe' | 'drive' | 'stage' | 'design' | 'write' | 'admin';
+export const SCOPES: readonly PilotScope[] = ['observe', 'drive', 'stage', 'design', 'write', 'admin'];
+
+export const scopeAllows = (scopes: readonly string[], scope: PilotScope): boolean => scopes.includes('*') || scopes.includes(scope);
+
+const OBSERVE_LEAF =
+  /\.(ping|capabilities|selftest|status|state|snapshot|find|list|probe|probes|busy|log|diagnostics|pages|users|subscriptions|perf|rect|frameStats|memory|startupMarks|waitIdle|waitFor|screenshot|recent|flight|model|stores|storesDiff|tokens|query)$/;
+const ADMIN = new Set(['env.overrides', 'admin.open', 'diagnostics.archive', 'app.eval', 'devtool.cdp', 'pilot.config.set']);
+const WRITE = new Set(['report.send', 'tester.send', 'tester.flush', 'live.consent']);
+
+export function defaultScope(name: string): PilotScope {
+  if (ADMIN.has(name) || name.startsWith('impersonation.') && !OBSERVE_LEAF.test(name)) return 'admin';
+  if (WRITE.has(name) || /\.report$/.test(name)) return 'write';
+  if (name.startsWith('design.')) return OBSERVE_LEAF.test(name) ? 'observe' : 'design';
+  if (OBSERVE_LEAF.test(name) || name.startsWith('perf.') || /^map\.(assert|wait)/.test(name) || name === 'app.state' || name === 'qa.selftest.page') return 'observe';
+  if (
+    /^(nfc|clock|net|state|stage|flags)\./.test(name) ||
+    /^dev\.(theme|language|initFailOnce|initHold|permissions|feature|server|reload)$/.test(name) ||
+    /^tester\./.test(name) ||
+    /\.offerCode$/.test(name) ||
+    ['barcode.inject', 'sync.run', 'sync.unsubscribeSite', 'update.check', 'attachments.remove'].includes(name)
+  ) {
+    return 'stage';
+  }
+  return 'drive';
+}