@crouton-kit/capture 1.4.2 → 1.4.11

package/src/cdp/commands/measure/text.ts

@@ -0,0 +1,147 @@
+import { ArtifactResolutionError, resolveSnapRef } from '../../../output/artifact.js';
+import { data, emitResult, fact, formatCoordinate, line, lineList, text, type FactLine, type RenderableResult } from '../../../output/render.js';
+import { type ParsedArgs } from '../../types.js';
+import { measureTextSnapshot, writeTextCrop, type TextMeasurement } from '../../measure/text.js';
+
+const USAGE = `capture measure text <snap> --selector <target> — direct DOM content text, font, recorded color-model contrast, and provenance from one settled snapshot
+
+input:
+  <snap>               snapshot id in the active session or absolute artifact path (required)
+  --selector <target>  one recorded CSS/text/AX selector input or backend:<id> (required)
+  --crop               write a measured selector crop artifact; its sessionless bundle is rooted by --artifact-dir
+  --artifact-dir <path>  root for the sessionless crop bundle; ignored when an active session owns the crop
+output: <text selector=… contrast=…> — one target's direct DOM content text, font metrics, recorded foreground/background color model, contrast ratio, and recorded style provenance
+effects: reads an existing snapshot and never drives the browser; --crop maps recorded CSS geometry through queries.json's CSS viewport and writes one PNG under the active session or, sessionless, a one-shot bundle under --artifact-dir`;
+
+function attestation(measurement: TextMeasurement) {
+  return {
+    kind: 'snapshot' as const,
+    id: measurement.ref.id,
+    path: measurement.ref.dir,
+    note: measurement.meta.settled === false
+      ? text`Snapshot was captured unsettled; text facts intersecting an unstable region may vary on re-capture.`
+      : measurement.meta.settled === true
+        ? fact`Snapshot settled${measurement.meta.settleMs === undefined ? '' : ` after ${measurement.meta.settleMs}ms`}.`
+        : text`Snapshot settledness was not recorded.`,
+  };
+}
+
+function textFacts(measurement: TextMeasurement): FactLine[] {
+  if (!measurement.textAvailable) return [fact`Text collection was unavailable: ${measurement.textUnavailableReason ?? 'no reason was recorded'}; no direct DOM content text, text metrics, or font facts are available.`];
+  const record = measurement.text;
+  if (!record) return [text`No text-layout record joined to the selected geometry record by backend node id or geometry element id.`];
+  const font = record.font ?? {};
+  const lines = record.lines ?? [];
+  return [
+    line(text`Direct DOM content text: `, data(record.text ?? '(not recorded)', Number.MAX_SAFE_INTEGER)),
+    text`This is raw text from the target's direct DOM text nodes; CSS text transforms and generated ::before/::after content are not represented in this text value.`,
+    fact`Text metrics: chars=${record.textLength ?? (record.text?.length ?? 0)}; lines=${record.lineCount ?? lines.length}; truncated=${String(record.truncated ?? false)}; truncation-style=${record.truncationStyle ?? 'none'}; scroll-width=${record.scrollWidth ?? 0}; client-width=${record.clientWidth ?? 0}.`,
+    fact`Font metrics: family=${font.family ?? 'unknown'}; size=${font.size ?? 'unknown'}; weight=${font.weight ?? 'unknown'}; line-height=${font.lineHeight ?? 'unknown'}; writing-mode=${record.writingMode ?? 'unknown'}; direction=${record.direction ?? 'unknown'}; fallback-used=${String(record.fallbackUsed ?? 'unknown')}.`,
+    fact`Text-line collection: ${lines.length} recorded line box(es); platform-fonts-available=${String(record.platformFontsAvailable ?? false)}; platform-families=${(record.platformFonts ?? []).map((entry) => entry.familyName ?? 'unknown').join(', ') || 'none recorded'}.`,
+  ];
+}
+
+function contrastFacts(measurement: TextMeasurement): FactLine[] {
+  const contrast = measurement.contrast;
+  if (!contrast.available) return [fact`Foreground/background color model and contrast ratio were not resolved: ${contrast.uncertainty}.`];
+  return [
+    fact`Foreground in the recorded color model: rgb(${contrast.foreground.join(', ')}).`,
+    fact`Background in the recorded color model: rgb(${contrast.background.join(', ')}); opaque background-color source=${contrast.backgroundSource}.`,
+    fact`Contrast ratio in the recorded color model: ${contrast.ratio.toFixed(2)}:1.`,
+    fact`Color-model provenance: ${contrast.provenance}. The model composites recorded computed color, background-color, and geometry opacity; background images, gradients, and other paint are not recorded.`,
+  ];
+}
+
+function styleFacts(measurement: TextMeasurement): FactLine[] {
+  const facts: FactLine[] = measurement.styles.map((style) => fact`Style winner for ${style.element}: ${style.property}=${style.value}; selector ${style.selector}; specificity ${style.specificity}; source ${style.source}.${style.uncertainty ? ` Cascade uncertainty: ${style.uncertainty}.` : ''}`);
+  if (!facts.length) facts.push(text`No recorded winning declaration provenance for the selected color or background-color paint chain.`);
+  if (measurement.styleProvenanceUnavailableFor.length) facts.push(fact`Winning-declaration provenance was unavailable for: ${measurement.styleProvenanceUnavailableFor.join(', ')}.`);
+  return facts;
+}
+
+function invalidInput(message: FactLine): RenderableResult {
+  return {
+    tag: 'error',
+    attrs: { command: 'measure text', status: 'invalid_input' },
+    summary: message,
+    followUp: text`Run capture measure text <snap> --selector <CSS|backend:id|axid:id|ax:name|text:value>.`,
+  };
+}
+
+export async function cmdMeasureText(parsed: ParsedArgs, _args: string[]): Promise<void> {
+  if (parsed.help) { console.log(USAGE); return; }
+  if (parsed.positional.length !== 1) {
+    emitResult(invalidInput(fact`Expected exactly one snapshot target; received ${parsed.positional.length}.`), { json: parsed.json });
+    process.exitCode = 1;
+    return;
+  }
+  if (!parsed.selector?.trim()) {
+    emitResult(invalidInput(text`The --selector flag is required.`), { json: parsed.json });
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const ref = await resolveSnapRef(parsed.positional[0]!);
+    const report = measureTextSnapshot(ref, parsed.selector);
+    if (report.kind === 'missing-selector') {
+      emitResult({
+        tag: 'error',
+        attrs: { command: 'measure text', status: 'missing_selector', selector: report.selector },
+        summary: fact`No geometry element matched selector input ${report.selector}.`,
+        sections: [lineList(report.available.candidates.map((candidate, index) => fact`${index + 1}. ${candidate}`))],
+        followUp: text`Use an exact recorded selector, backend id, AX identity, or text identity from this snapshot.`,
+      }, { json: parsed.json });
+      process.exitCode = 1;
+      return;
+    }
+    if (report.kind === 'ambiguous-selector') {
+      emitResult({
+        tag: 'error',
+        attrs: { command: 'measure text', status: 'ambiguous_selector', selector: report.selector, matches: report.matchCount, displayed: report.candidates.length },
+        summary: fact`Selector input ${report.selector} matched ${report.matchCount} recorded elements; no text target was selected.`,
+        sections: [lineList(report.candidates.map((candidate, index) => fact`${index + 1}. ${candidate.selector ?? candidate.id}${typeof candidate.backendNodeId === 'number' ? ` — backend:${candidate.backendNodeId}` : ''}`))],
+        followUp: text`Retry with an exact CSS selector, axid, or numeric backend id from the candidate identity facts.`,
+      }, { json: parsed.json });
+      process.exitCode = 1;
+      return;
+    }
+    const crop = parsed.textCrop ? writeTextCrop(report, parsed.artifactDir) : undefined;
+    const target = report.element.selector ?? report.element.id;
+    const result: RenderableResult = {
+      tag: 'text',
+      attestation: attestation(report),
+      attrs: {
+        selector: target,
+        matches: report.matchCount,
+        ...(typeof report.element.backendNodeId === 'number' ? { backend: report.element.backendNodeId } : {}),
+        settled: report.meta.settled ?? 'unknown',
+        contrast: report.contrast.available ? `${report.contrast.ratio.toFixed(2)}:1` : 'unresolved',
+        ...(crop ? { crop: crop.path } : {}),
+      },
+      summary: report.textAvailable
+        ? report.contrast.available
+          ? fact`Recorded direct-DOM-content text, font, color-model contrast, and style-provenance facts for ${target} from one snapshot.`
+          : fact`Recorded direct-DOM-content text, font, and style-provenance facts for ${target}; the recorded color model did not resolve a contrast ratio.`
+        : report.contrast.available
+          ? fact`Recorded color-model contrast and style-provenance facts for ${target}; text collection was unavailable (${report.textUnavailableReason ?? 'no reason was recorded'}).`
+          : fact`Recorded style-provenance facts for ${target}; text collection was unavailable (${report.textUnavailableReason ?? 'no reason was recorded'}) and the recorded color model did not resolve a contrast ratio.`,
+      sections: [
+        ...(report.element.rect && report.element.rect.width !== undefined && report.element.rect.height !== undefined ? [line(text`Target geometry: `, formatCoordinate({ x: report.element.rect.x, y: report.element.rect.y, w: report.element.rect.width, h: report.element.rect.height }))] : [text`Target geometry was not recorded.`]),
+        ...textFacts(report),
+        ...contrastFacts(report),
+        ...styleFacts(report),
+        ...(crop ? [fact`Crop artifact: ${crop.path}; requested CSS geometry x=${crop.requested.x} y=${crop.requested.y} w=${crop.requested.w} h=${crop.requested.h}; delivered raster geometry x=${crop.delivered.x} y=${crop.delivered.y} w=${crop.delivered.w} h=${crop.delivered.h}; CSS-to-raster scale x=${crop.scale.x} y=${crop.scale.y}, derived from queries.json's recorded CSS viewport.`] : []),
+      ],
+    };
+    emitResult(result, { json: parsed.json });
+  } catch (error) {
+    const detail = error instanceof ArtifactResolutionError || error instanceof Error ? error.message : String(error);
+    emitResult({
+      tag: 'error',
+      attrs: { command: 'measure text', status: error instanceof ArtifactResolutionError ? 'artifact_unavailable' : 'text_unavailable' },
+      summary: fact`The requested text measurement could not be read: ${detail}`,
+      followUp: text`Create a settled snapshot with capture measure snap <url>, then pass its id or absolute path.`,
+    }, { json: parsed.json });
+    process.exitCode = 1;
+  }
+}

package/src/cdp/commands/motion/index.ts

@@ -16,26 +16,18 @@ import { cmdMotionResponse } from './response.js';
 
 /** Root-help representation of this branch, assembled by `src/capture.ts`. */
 export const COMMAND_BLOCK = `<command name="motion">
-facts over a recording — recorder lifecycle plus read-only queries over a finalized recording
-use when recording an interaction (one-shot or composed) and reading motion facts: diffs, timelines, jank, input response
-  rec · mask · timeline · jank · response — \`capture motion -h\`
+the screencast-recording substrate — what changed on screen across frames; \`rec\` writes the recording, every other leaf is a read-only query over it
+use for per-element frame geometry, changed regions, and input-to-settle timing; use \`perf\` instead for trace-event timing
 </command>`;
 
-export const MOTION_USAGE = `capture motion — recorder lifecycle + read-only queries over a finalized recording.
-
-\`rec\` drives (and records) the browser, one-shot or composed across
-intervening commands; every other leaf below is a cheap read over the
-finalized recording artifact. Every leaf defaults to rendered prose; --json
-mirrors the same result. Findings exit 0 — a report, not a failure;
-input/precondition errors exit 1. No leaf accepts --gate.
-
-<subcommand name="rec" args="[url] --do <action> [--duration <seconds>] | --start | --stop" whenToUse="record an interaction — one-shot action, or composed across commands with --start/--stop (needs an active session)"/>
-<subcommand name="mask" args="<rec> [--limit <N>]" whenToUse="motion-diff composite image + per-region facts"/>
-<subcommand name="timeline" args="<rec> --element <sel> [--prop <prop>]" whenToUse="per-frame geometry/scroll/property timeline for one element"/>
-<subcommand name="jank" args="<rec>" whenToUse="dropped-frame/long-task/layout-shift facts"/>
-<subcommand name="response" args="<rec> [--action <action>] [--occurrence <n>]" whenToUse="input-to-settled response timeline"/>
-
-capture motion <leaf> -h    Per-leaf usage`;
+export const MOTION_USAGE = `<command name="motion" description="recording lifecycle and read-only queries over a finalized recording">
+<model>\`rec\` drives and records the browser, one-shot or composed across intervening commands; every other leaf below reads the finalized recording artifact. Findings exit 0 — a report, not a failure; input and precondition errors exit 1. No leaf accepts --gate.</model>
+<subcommand name="rec" description="interaction recording" whenToUse="Use to record an interaction in one command or across a held session."/>
+<subcommand name="mask" description="motion-difference image and regions" whenToUse="Use to inspect where a recording changed across frames."/>
+<subcommand name="timeline" description="element timeline" whenToUse="Use to inspect one element's geometry, scroll, or property values over time."/>
+<subcommand name="jank" description="long-task and layout-shift facts" whenToUse="Use to inspect rendering interruption and layout instability in a recording."/>
+<subcommand name="response" description="input-to-settled timeline" whenToUse="Use to measure the response from one recorded input to settled rendering."/>
+</command>`;
 
 export async function motionMain(parsed: ParsedArgs, args: string[]): Promise<void> {
   const leaf = parsed.positional[0];

package/src/cdp/commands/motion/jank.ts

@@ -3,11 +3,11 @@ import { resolveRecRef } from '../../../output/artifact.js';
 import { emitResult, fact, lineList, text, type FactLine, type RenderableResult } from '../../../output/render.js';
 import { readMotionJank, type ArtifactLossFact, type LayoutShiftFact, type LayoutShiftRectFact, type LongTaskFact } from '../../motion/jank.js';
 
-const USAGE = `capture motion jank <rec> — dropped-frame, long-task-record, and layout-shift facts over a finalized recording
+const USAGE = `capture motion jank <rec> — long-task-record and layout-shift facts over a finalized recording
 
 input:
   <rec>   recording id in the active session or an absolute recording path (required; the recording must be finalized)
-output: <jank …> — dropped-frame, long-task-record, and layout-shift facts; observer and screencast timing is recorder-relative performance.now(), trace timing recorder-relative only when an explicit trace/performance baseline was retained; --json mirrors
+output: <jank …> — long-task-record and layout-shift facts. Its PerformanceObserver records carry no call-stack, handler, or script/style/layout/paint attribution; \`capture perf trace\`/\`capture perf insights\` own trace-engine attribution when a trace records it. Screencast frames are change-driven, not a dropped-frame measurement; use \`capture perf trace\` for frame-timing questions. Observer and screencast timing is recorder-relative performance.now(), trace timing recorder-relative only when an explicit trace/performance baseline was retained; --json mirrors
 effects: read-only — reads the finalized recording artifact, never drives the browser`;
 
 export async function cmdMotionJank(parsed: ParsedArgs, _args: string[]): Promise<void> {
@@ -25,15 +25,9 @@ export async function cmdMotionJank(parsed: ParsedArgs, _args: string[]): Promis
     const state = typeof meta.state === 'string' ? meta.state : 'unknown';
     const sections: FactLine[] = [fact`${analysis.timingNote}`];
 
-    if (analysis.droppedFrames.length) {
-      sections.push(lineList(analysis.droppedFrames.map((drop, index) =>
-        fact`${index + 1}. frames ${drop.beforeFrame}→${drop.afterFrame}: interval ${drop.intervalMs.toFixed(2)}ms, cadence ${analysis.cadenceMs?.toFixed(2) ?? 'unavailable'}ms, estimated dropped frames ${drop.estimatedDroppedFrames}, t=${drop.startMs.toFixed(2)}→${drop.endMs.toFixed(2)}ms (±frame)`,
-      )));
-    } else {
-      sections.push(fact`Dropped-frame intervals: 0; ${analysis.frameCount} timestamped rect sample(s), cadence ${analysis.cadenceMs?.toFixed(2) ?? 'unavailable'}ms.`);
-    }
-    if (analysis.missingFrameSampleCount > 0) sections.push(fact`${analysis.missingFrameSampleCount} screencast frame(s) have no rect timestamp sample; dropped-frame count is incomplete.`);
-    if (analysis.cadenceMs === null) sections.push(text`Fewer than two positive frame intervals were retained; nominal cadence is unavailable and the dropped-frame count is incomplete.`);
+    sections.push(fact`PerformanceObserver records carry no call-stack, handler, or script/style/layout/paint attribution. Trace-engine attribution belongs to capture perf trace and capture perf insights when a trace records it.`);
+    sections.push(fact`Page.screencastFrame is change-driven; its ${analysis.frameCount} timestamped rect sample(s) do not measure page dropped frames.`);
+    if (analysis.missingFrameSampleCount > 0) sections.push(fact`${analysis.missingFrameSampleCount} screencast frame(s) have no rect timestamp sample.`);
 
     if (analysis.longTasks.length) {
       sections.push(lineList(analysis.longTasks.map((task, index) => formatLongTask(task, index))));
@@ -47,6 +41,10 @@ export async function cmdMotionJank(parsed: ParsedArgs, _args: string[]): Promis
       sections.push(text`Layout-shift records: 0.`);
     }
 
+    if (analysis.preRecordingObserverEntriesExcluded > 0) {
+      sections.push(fact`${analysis.preRecordingObserverEntriesExcluded} buffered PerformanceObserver entr${analysis.preRecordingObserverEntriesExcluded === 1 ? 'y was' : 'ies were'} excluded because ${analysis.preRecordingObserverEntriesExcluded === 1 ? 'it predates' : 'they predate'} the recorder arm baseline.`);
+    }
+
     if (analysis.artifactLoss.length) {
       sections.push(lineList(analysis.artifactLoss.map(formatArtifactLoss)));
     }
@@ -62,15 +60,15 @@ export async function cmdMotionJank(parsed: ParsedArgs, _args: string[]): Promis
       attrs: {
         state,
         frames: analysis.frameCount,
-        'dropped-frames': analysis.droppedFrameCount,
-        'dropped-frames-incomplete': analysis.droppedFramesIncomplete,
         'long-task-records': analysis.longTasks.length,
         'long-task-records-incomplete': analysis.longTasksIncomplete,
         'layout-shift-records': analysis.layoutShifts.length,
         'layout-shift-records-incomplete': analysis.layoutShiftsIncomplete,
+        'pre-recording-observer-entries-excluded': analysis.preRecordingObserverEntriesExcluded,
         'timestamp-uncertainty': analysis.frameTimestampUncertainty,
+        'observer-attribution': 'no-call-stack-handler-or-script-style-layout-paint-attribution',
       },
-      summary: fact`${analysis.droppedFrameCount} estimated dropped frame(s)${analysis.droppedFramesIncomplete ? ' (incomplete)' : ''}, ${analysis.longTasks.length} long-task record(s)${analysis.longTasksIncomplete ? ' (incomplete)' : ''}, ${analysis.layoutShifts.length} layout-shift record(s)${analysis.layoutShiftsIncomplete ? ' (incomplete)' : ''}.`,
+      summary: fact`${analysis.longTasks.length} long-task record(s)${analysis.longTasksIncomplete ? ' (incomplete)' : ''}, ${analysis.layoutShifts.length} layout-shift record(s)${analysis.layoutShiftsIncomplete ? ' (incomplete)' : ''}; ${analysis.preRecordingObserverEntriesExcluded} pre-recording observer entr${analysis.preRecordingObserverEntriesExcluded === 1 ? 'y' : 'ies'} excluded.`,
       sections,
     };
     emitResult(result, { json: parsed.json });
@@ -86,14 +84,7 @@ function formatLongTask(task: LongTaskFact, index: number): FactLine {
     : task.timingDomain === 'trace-relative-first-event'
       ? `t=${task.startMs!.toFixed(2)}→${task.endMs!.toFixed(2)}ms relative to first trace event`
       : 'timing unavailable after navigation gap';
-  const overlapText = task.overlapsDroppedFrames === null
-    ? task.timingDomain === 'unavailable'
-      ? '; dropped-frame overlap unavailable after navigation gap'
-      : '; dropped-frame overlap unavailable across trace-relative and recorder-relative timing domains'
-    : task.overlapsDroppedFrames.length
-      ? `, overlaps dropped-frame interval(s) ending at frame ${task.overlapsDroppedFrames.join(', ')}`
-      : '';
-  return fact`long-task record ${index + 1} (${task.source}): ${timingText}, duration ${task.durationMs.toFixed(2)}ms${overlapText}.`;
+  return fact`long-task record ${index + 1} (${task.source}): ${timingText}, duration ${task.durationMs.toFixed(2)}ms.`;
 }
 
 function formatLayoutShift(shift: LayoutShiftFact, index: number): FactLine {

package/src/cdp/commands/motion/mask.ts

@@ -1,7 +1,8 @@
 import { type ParsedArgs } from '../../types.js';
+import { selectRecords } from '../../../output/selection.js';
 import { createMotionMask } from '../../motion/mask.js';
 import { readMeta, resolveRecRef } from '../../../output/artifact.js';
-import { emitResult, fact, formatArtifactList, line, lineList, text, type FactLine, type RenderableResult } from '../../../output/render.js';
+import { capped, emitResult, fact, formatArtifactList, line, lineList, text, type FactLine, type RenderableResult } from '../../../output/render.js';
 
 const DEFAULT_REGION_LIMIT = 20;
 
@@ -9,7 +10,7 @@ const USAGE = `capture motion mask <rec> — motion-diff composite image plus pe
 
 input:
   <rec>          recording id in the active session or an absolute recording path (required; the recording must be finalized)
-  --limit <N>    render at most N size-sorted region rows (default: ${DEFAULT_REGION_LIMIT}); --json always contains every region row
+  --limit <N>    return at most N size-sorted region rows in prose and JSON (default: ${DEFAULT_REGION_LIMIT})
 output: <motion-mask …> — the composite image path plus per-region area, distance, velocity, and element attribution where recorded rects overlap; frame-derived times carry ±1-frame uncertainty; --json mirrors
 effects: reads the finalized recording artifact, never drives the browser; writes motion-mask.png inside the recording directory`;
 
@@ -36,10 +37,8 @@ export async function cmdMotionMask(parsed: ParsedArgs, _args: string[]): Promis
       return emitCommandError(parsed, 'recording_not_finalized', `Recording ${ref.id} has state ${state}; finalize it with \`capture motion rec --stop\` before creating a mask.`);
     }
     const mask = createMotionMask(ref);
-    // A recording can have many isolated changed-pixel components. Limit the
-    // human/agent prose view, while JSON keeps the complete size-sorted list.
     const proseLimit = parsed.limit ?? DEFAULT_REGION_LIMIT;
-    const reportedRegions = parsed.json ? mask.regions : mask.regions.slice(0, proseLimit);
+    const reportedRegions = selectRecords(mask.regions, parsed, proseLimit);
     const regionLines = reportedRegions.length
       ? reportedRegions.map((region) => formatRegion(region))
       : [text`No changed pixels were measured across the recorded frame pairs.`];
@@ -63,8 +62,8 @@ export async function cmdMotionMask(parsed: ParsedArgs, _args: string[]): Promis
       artifacts: formatArtifactList([{ name: 'motion-mask.png', note: 'motion-diff composite' }]),
       sections: [
         ...(mask.caveat ? [line(text`${mask.caveat}`)] : []),
-        ...(mask.regions.length > proseLimit && !parsed.json
-          ? [fact`Showing ${reportedRegions.length} of ${mask.regions.length} size-sorted changed-pixel regions; --json contains all region rows.`]
+        ...(mask.regions.length > reportedRegions.length
+          ? [fact`Showing ${reportedRegions.length} of ${mask.regions.length} size-sorted changed-pixel regions; the recording artifact retains all rows.`]
           : []),
         lineList(regionLines),
       ],
@@ -74,7 +73,9 @@ export async function cmdMotionMask(parsed: ParsedArgs, _args: string[]): Promis
     };
     emitResult(result, { json: parsed.json });
   } catch (err) {
-    emitCommandError(parsed, 'artifact_unavailable', err instanceof Error ? err.message : String(err));
+    // The recording resolved and was read; createMotionMask's rejection names
+    // why its contents cannot form a mask, which is not an unavailable artifact.
+    emitCommandError(parsed, 'mask_failed', err instanceof Error ? capped(err.message, 600) : capped(String(err), 600));
   }
 }
 
@@ -88,7 +89,7 @@ function formatRegion(region: ReturnType<typeof createMotionMask>['regions'][num
   );
 }
 
-function emitCommandError(parsed: ParsedArgs, status: string, message: string): void {
+function emitCommandError(parsed: ParsedArgs, status: string, message: string | ReturnType<typeof capped>): void {
   emitResult({
     tag: 'error',
     attrs: { command: 'motion mask', status },