@unrulysystems/native-motion-conformance 0.1.0-alpha.0

package/src/scenarios/component.ts

@@ -0,0 +1,516 @@
+// SPEC-COMPONENT §4 Altitude-2 conformance scenarios (REQ-API-001/002/005/006). Authored ONCE,
+// engine-agnostic: each asserts the declarative component boundary contract — first-paint from
+// `initial`/`animate`, the `initial={false}` no-entrance sentinel, partial-target hold under retarget, and
+// fail-loud validation of unsupported / unimplemented properties. At Milestone 1 the "engine" is the
+// deterministic interior — the pure `validateTarget`/`resolveTarget`/`resolveStartValue` core functions
+// against a fake host, with no rendering. The IDENTICAL scenarios re-run against the real native runtime
+// and the motion/react web shim at Milestone 2 (one contract, two engines). Fail-closed: a validation
+// scenario passes ONLY if the descriptive error is raised (no throw = FAIL) and its message content
+// matches; a scenario a host cannot execute is `unassertable`, never a silent pass.
+
+import {
+  type HostCapabilities,
+  InvalidTargetError,
+  InvalidTransitionError,
+  type ResolvedTargetValue,
+  type ResolvedValue,
+  type Target,
+  type Transition,
+  createReferenceDriver,
+  hostCapabilities,
+  resolveInitialOverlay,
+  resolveStartValue,
+  resolveTarget,
+  resolveVariantDefinition,
+  validateTarget,
+  validateTransition,
+} from '@unrulysystems/native-motion-core'
+import type { ScenarioResult, Verdict } from '../runner'
+
+// The M1 fake hosts, derived from the registry. web declares universal + web-only + pointer-gated; native
+// declares universal (+ the currently-empty native-extension category).
+const WEB: HostCapabilities = hostCapabilities('web', ['universal', 'web-only', 'pointer-gated'])
+const NATIVE: HostCapabilities = hostCapabilities('native', ['universal', 'native-extension'])
+
+// The engine label these deterministic-interior results are recorded under (M1). M2 adds 'native' / 'web'.
+const FAKE_ENGINE = 'fake-host'
+
+// Model the value shape a Target carries as a plain value record for the pure merge functions. A target
+// value may be a keyframe array (REQ-API-033), so the honest element type is ResolvedTargetValue.
+function asValues(target: Target): Record<string, ResolvedTargetValue> {
+  return { ...target } as Record<string, ResolvedTargetValue>
+}
+
+// The first painted frame's value set, computed from the declarative props via the core primitives — the
+// contract the M2 real driver must reproduce on-device (REQ-API-010/011). Each covered key's base is
+// resolved from the `style` record else the documented host base (resolveStartValue); `initial===false`
+// starts the element at the resolved `animate` with no entrance; an `initial` Target paints as the first
+// frame; `initial` omitted paints the resolved base.
+function firstFrameValues(
+  props: { initial?: Target | false; animate?: Target },
+  style?: Record<string, ResolvedValue>,
+): Record<string, ResolvedTargetValue> {
+  const animate = props.animate ?? {}
+  const keys = new Set<string>(Object.keys(animate))
+  if (props.initial !== undefined && props.initial !== false) {
+    for (const k of Object.keys(props.initial)) keys.add(k)
+  }
+  const resolution = style !== undefined ? { style } : undefined
+  const base: Record<string, ResolvedValue> = {}
+  for (const k of keys) base[k] = resolveStartValue(k, resolution)
+
+  if (props.initial === false) return resolveTarget(base, asValues(animate)) // start at animate, no entrance
+  if (props.initial !== undefined) return resolveTarget(base, asValues(props.initial)) // paint initial first
+  return base // initial omitted → resolved style/host base (REQ-API-010 default)
+}
+
+// A single deterministic-interior assertion outcome. `unassertable` distinguishes "could not run here"
+// from a genuine pass/fail (three-valued accounting).
+interface Outcome {
+  readonly verdict: Verdict
+  readonly detail: string
+}
+
+function pass(detail: string): Outcome {
+  return { verdict: 'pass', detail }
+}
+function fail(detail: string): Outcome {
+  return { verdict: 'fail', detail }
+}
+function unassertable(detail: string): Outcome {
+  return { verdict: 'unassertable', detail }
+}
+
+export interface ComponentScenario {
+  readonly id: string
+  readonly requirements: readonly string[]
+  // Assert the boundary contract against the deterministic interior; pure, no rendering.
+  readonly assert: () => Outcome
+}
+
+export const COMPONENT_SCENARIOS: readonly ComponentScenario[] = [
+  {
+    // REQ-API-001/010 — the first painted frame is `initial`, not `animate`.
+    id: 'CMP-initial-paint',
+    requirements: ['REQ-API-001', 'REQ-API-010'],
+    assert() {
+      const frame = firstFrameValues({ initial: { opacity: 0 }, animate: { opacity: 1 } })
+      return frame['opacity'] === 0
+        ? pass('first frame paints initial opacity 0')
+        : fail(`expected first-frame opacity 0, got ${String(frame['opacity'])}`)
+    },
+  },
+  {
+    // REQ-API-010 — `initial={false}` starts at the resolved `animate` with no entrance.
+    id: 'CMP-initial-false',
+    requirements: ['REQ-API-010'],
+    assert() {
+      const frame = firstFrameValues({ initial: false, animate: { opacity: 1 } })
+      return frame['opacity'] === 1
+        ? pass('initial={false} paints the resolved animate opacity 1 (no entrance)')
+        : fail(
+            `expected first-frame opacity 1 for initial={false}, got ${String(frame['opacity'])}`,
+          )
+    },
+  },
+  {
+    // REQ-API-002/012 — a retarget holds every unlisted property; a target never resets.
+    id: 'CMP-partial-hold',
+    requirements: ['REQ-API-002'],
+    assert() {
+      const live = resolveTarget({ x: 0, y: 0 }, asValues({ x: 100 }))
+      return live['y'] === 0 && live['x'] === 100
+        ? pass('retarget {x:100} holds y at 0')
+        : fail(`expected {x:100,y:0}, got ${JSON.stringify(live)}`)
+    },
+  },
+  {
+    // REQ-API-011 — a first-seen property's base resolves from the resolved style, else host base.
+    id: 'CMP-base-resolution',
+    requirements: ['REQ-API-002'],
+    assert() {
+      const fromStyle = firstFrameValues({ animate: { x: 100 } }, { x: 40 })
+      const fromHostBase = firstFrameValues({ animate: { x: 100 } })
+      return fromStyle['x'] === 40 && fromHostBase['x'] === 0
+        ? pass('first-seen base reads style (40) then host base (0)')
+        : fail(
+            `expected style 40 / host-base 0, got ${String(fromStyle['x'])} / ${String(fromHostBase['x'])}`,
+          )
+    },
+  },
+  {
+    // REQ-API-005/013 — an unsupported (off-host) property fails loud with the descriptive error; no
+    // throw is a FAIL (fail-closed), and the message content is asserted.
+    id: 'CMP-unsupported-fail-loud',
+    requirements: ['REQ-API-005', 'REQ-API-013'],
+    assert() {
+      try {
+        validateTarget({ boxShadow: '0 1px 4px rgba(0,0,0,0.2)' }, NATIVE)
+        return fail('expected a throw for an off-host property; none raised (fail-open)')
+      } catch (err) {
+        const named =
+          err instanceof InvalidTargetError &&
+          /boxShadow/.test(err.message) &&
+          /web/.test(err.message)
+        return named
+          ? pass(
+              'off-host boxShadow raised InvalidTargetError naming the key + supporting platform',
+            )
+          : fail(`threw but wrong class/message: ${(err as Error).message}`)
+      }
+    },
+  },
+  {
+    // REQ-API-032 laws (a)/(c) — R7: initial labels overlay IN ORDER into one first-paint
+    // state (later label wins shared keys; transitions discarded); a local miss is the
+    // pinned NO-OP, never an error.
+    id: 'CMP-R7-initial-label-overlay',
+    requirements: ['REQ-API-032', 'REQ-API-010'],
+    assert() {
+      const dictionary = {
+        a: { opacity: 0.2, transition: { type: 'spring', stiffness: 500 } },
+        b: { opacity: 0.6, scale: 2 },
+      } as const
+      const overlay = resolveInitialOverlay(['a', 'b', 'missing'], dictionary)
+      const ordered =
+        (overlay as { opacity?: number }).opacity === 0.6 &&
+        (overlay as { scale?: number }).scale === 2 &&
+        !('transition' in overlay)
+      return ordered
+        ? pass('ordered overlay {opacity:0.6, scale:2}; miss is a no-op; transitions discarded')
+        : fail(`expected {opacity:0.6, scale:2}, got ${JSON.stringify(overlay)}`)
+    },
+  },
+  {
+    // REQ-API-032 law (b) — R7: an animation-time array resolves to ORDERED per-label
+    // applications, each preserving its OWN embedded transition (the collapsed-batch
+    // execution is the recorded FAIL shape).
+    id: 'CMP-R7-per-label-applications',
+    requirements: ['REQ-API-032'],
+    assert() {
+      const soft = { type: 'spring', stiffness: 120, damping: 20 } as const
+      const stiff = { type: 'spring', stiffness: 500, damping: 40 } as const
+      const applications = resolveVariantDefinition(['softOpacity', 'stiffScale'], {
+        softOpacity: { opacity: 0.5, transition: soft },
+        stiffScale: { scale: 2, transition: stiff },
+      })
+      const perLabel =
+        applications.length === 2 &&
+        applications[0]!.transition === soft &&
+        (applications[0]!.target as { opacity?: number }).opacity === 0.5 &&
+        applications[1]!.transition === stiff &&
+        (applications[1]!.target as { scale?: number }).scale === 2
+      return perLabel
+        ? pass('two applications in array order, each with its own transition')
+        : fail(`expected 2 attributed applications, got ${JSON.stringify(applications)}`)
+    },
+  },
+  {
+    // REQ-API-032 — this is an EXTERNAL-EVIDENCE-ONLY parity row (the sealed precedent is
+    // appstore-choreography.cross-engine-parity / layout.cross-engine-parity, NOT the
+    // scalar-injectable gesture.cross-engine-parity which parity.ts additively owns). The R7
+    // per-label/gesture/exit/propagation scenarios execute against real components on the NATIVE
+    // engine and against the WEB engine, but the comparison is not reducible to an injectable
+    // deterministic scalar (the engine adapter is scalar-only), so no single deterministic context
+    // owns it. Per the additive law the row therefore STAYS `unassertable` here, and at seal
+    // (R7 M5, ratified Option A; SPEC-CONFORMANCE §3) its reason NAMES the executed counterparts so
+    // the accounting records where parity actually executes — visible, never a silent pass.
+    id: 'CMP-R7-cross-engine-parity',
+    // REQ-CONFORM-002 rides every *.cross-engine-parity scenario (traceability for the
+    // routed parity obligation — M2 r4 minor 91be23a506dd).
+    requirements: ['REQ-API-032', 'REQ-CONFORM-002'],
+    assert() {
+      // Owners front-loaded: the on-device banner clamps a routed row's detail to 3 lines
+      // (ConformanceScreen numberOfLines), so both executing owners are named first.
+      return unassertable(
+        'WEB owner: variants.e2e.ts (Chromium, 19/19). NATIVE owner: PROOF.md §R7 device ' +
+          'cards variants-list + tap-label (Android real-touch VARIANTS_PUBLIC/TAPLABEL_PUBLIC, ' +
+          'iOS self-driving 12/12). Routed here — this deterministic host owns no second engine; ' +
+          'parity is discharged at those altitudes, never a silent pass ' +
+          '(appstore-choreography.cross-engine-parity precedent).',
+      )
+    },
+  },
+  {
+    // REQ-API-033 (R8) — like the R7 routed row, this deterministic host has no real second
+    // renderer to compare. The Chromium web leg and M5 device card executed at their own
+    // altitudes; recording both owners here keeps the parity obligation visible without
+    // pretending this scalar suite performed a cross-engine comparison.
+    id: 'CMP-R8-cross-engine-parity',
+    requirements: ['REQ-API-033', 'REQ-CONFORM-002'],
+    assert() {
+      return unassertable(
+        'WEB owner: keyframes.e2e.ts (Chromium, 20/20). NATIVE owner: PROOF.md §R8 device ' +
+          'keyframes card (Android real-touch KEYFRAMES_PUBLIC verdicts + measured arcs; iOS ' +
+          'self-driving AUTO-RUN 13/13 + measured peaks). Routed here — this deterministic host ' +
+          'owns no second engine; both named external owners executed, never a silent pass.',
+      )
+    },
+  },
+  {
+    // REQ-API-034 (R9) — like the R7/R8 routed rows, this deterministic host has no real second
+    // renderer to compare. The Chromium web leg and M5 device cards executed at their own
+    // altitudes; recording both owners here keeps the parity obligation visible without
+    // pretending this scalar suite performed a cross-engine comparison.
+    id: 'CMP-R9-cross-engine-parity',
+    requirements: ['REQ-API-034', 'REQ-CONFORM-002'],
+    assert() {
+      return unassertable(
+        'WEB owner: examples.smoke.e2e.ts + text-layout.e2e.ts + image-gallery.e2e.ts ' +
+          '(Chromium, 22/22). NATIVE owner: PROOF.md §R9 device element cards (Android gallery ' +
+          '17/17 including image-gallery stable post-fix — no Image-children crash; iOS ' +
+          'self-driving AUTO-RUN COMPLETE 17/17 with wallpaper loaded). Routed here — this ' +
+          'deterministic host owns no second engine; both named external owners executed, ' +
+          'never a silent pass.',
+      )
+    },
+  },
+  {
+    // REQ-API-033 (R8) — a keyframe ARRAY target interpolates THROUGH its elements over the transition
+    // and SETTLES at the LAST keyframe (not the interior peak); committed reads keyframes[0] at tick-0
+    // (the first-keyframe seed law), never the nominal `from`. Driven against the deterministic-interior
+    // reference driver — the engine-agnostic contract the M2 native runtime + M3 web shim must reproduce.
+    id: 'CMP-R8-keyframe-through-array',
+    requirements: ['REQ-API-033', 'REQ-API-001'],
+    assert() {
+      // Accept the valid keyframe target at the boundary, then drive it to settlement.
+      validateTarget({ x: [0, 100, 50] }, NATIVE)
+      const d = createReferenceDriver()
+      const h = d.register({ x: 999 }) // a live value that disagrees with keyframes[0]
+      d.command(h, {
+        kind: 'start',
+        targets: { x: { to: [0, 100, 50], from: 999 } },
+        transition: { type: 'tween', duration: 0.2 },
+      })
+      const seed = d.committed(h)['x'] // tick-0 = keyframes[0] (0), NOT the nominal from (999)
+      let peak = 0
+      for (let i = 0; i < 30; i++) {
+        d.step(16.67)
+        peak = Math.max(peak, d.committed(h)['x'] ?? 0)
+      }
+      for (let i = 0; i < 30; i++) d.step(16.67) // well past the 200ms duration
+      const settled = d.committed(h)['x']
+      const settledIdle = !d.isActive(h) // quiesces once the keyframe run settles (REQ-DRIVER-020)
+
+      // null-FIRST (R8-F2): the first keyframe reads the element's live value (20), never `null`.
+      const dn = createReferenceDriver()
+      const hn = dn.register({ x: 20 })
+      dn.command(hn, {
+        kind: 'start',
+        targets: { x: { to: [null, 100], from: 20 } },
+        transition: { type: 'tween', duration: 0.2 },
+      })
+      const nullFirstSeed = dn.committed(hn)['x'] // seeded from `from` (20), never `null`
+      for (let i = 0; i < 30; i++) dn.step(16.67)
+      const nullFirstSettled = dn.committed(hn)['x']
+
+      return seed === 0 &&
+        peak > 60 &&
+        settled === 50 &&
+        settledIdle &&
+        nullFirstSeed === 20 &&
+        nullFirstSettled === 100
+        ? pass(
+            'through-array: tick-0=0, peak>60, settle 50 + quiesce; null-first seeds 20→100 (R8-F2)',
+          )
+        : fail(
+            `seed/${String(seed)} peak/${peak} settle/${String(settled)} idle/${settledIdle} ` +
+              `nullseed/${String(nullFirstSeed)} nullsettle/${String(nullFirstSettled)}`,
+          )
+    },
+  },
+  {
+    // REQ-API-033 (R8, laws c/f + R8-F1/F2) — malformed keyframe arrays FAIL LOUD naming the offense:
+    // length<2, a mixed value-type, a null anywhere but index 0, a nested array; and an EXPLICIT spring
+    // on a >2 array (a spring interpolates exactly two keyframes — the driver refuses the successor).
+    id: 'CMP-R8-keyframe-refusals',
+    requirements: ['REQ-API-033', 'REQ-API-013'],
+    assert() {
+      // Capture the thrown error so IDENTITY + MESSAGE CONTENT are asserted — a blanket "did anything
+      // throw?" is fail-open (a raw TypeError or an unrelated driver failure would count as compliance;
+      // review major 9). No throw ⇒ null ⇒ the case fails below.
+      // Return the RAW thrown value — do NOT normalize a non-Error throw into an Error. The contract
+      // requires a TYPED Error; a thrown string/object is a contract violation the predicates below
+      // reject via `instanceof` (normalizing it to an Error masked exactly that, review major
+      // 0e4c6b8d2f19). No throw ⇒ null ⇒ the case fails below.
+      const capture = (fn: () => void): unknown => {
+        try {
+          fn()
+          return null
+        } catch (e) {
+          return e
+        }
+      }
+      // Each validation refusal must be the TYPED InvalidTargetError naming the offense (R8 laws c/f, F2).
+      const validationCases: readonly {
+        readonly label: string
+        readonly run: () => void
+        readonly want: RegExp
+      }[] = [
+        {
+          label: 'length<2',
+          run: () => validateTarget({ x: [0] }, NATIVE),
+          want: /keyframe array.*(at least two|≥ ?2)|(at least two|≥ ?2).*keyframe/i,
+        },
+        {
+          label: 'mixed-type',
+          run: () => validateTarget({ x: [0, 'not-a-length'] }, NATIVE),
+          want: /index 1|\[1\]/,
+        },
+        {
+          label: 'misplaced-null',
+          run: () => validateTarget({ x: [0, null, 50] }, NATIVE),
+          want: /index 1|\[1\]/,
+        },
+        {
+          label: 'nested-array',
+          run: () => validateTarget({ x: [0, [1, 2]] }, NATIVE),
+          want: /nested array/i,
+        },
+      ]
+      const validationFails = validationCases.filter((c) => {
+        const e = capture(c.run)
+        return !(e instanceof InvalidTargetError && c.want.test(e.message))
+      })
+      // The EXPLICIT spring on a >2 array is refused by the driver with the SPECIFIC R8-F1 message —
+      // asserted verbatim, and a raw TypeError/RangeError (the prohibited failure category) is
+      // EXCLUDED, so a broad "any Error mentioning keyframe" can no longer count as compliance
+      // (review major 11): the fail-open teeth are the exact phrase, not a fuzzy term.
+      const springErr = capture(() => {
+        const d = createReferenceDriver()
+        const h = d.register({ x: 0 })
+        d.command(h, {
+          kind: 'start',
+          targets: { x: { to: [0, 100, 50], from: 0 } },
+          transition: { type: 'spring', stiffness: 200, damping: 20 },
+        })
+      })
+      const springOk =
+        springErr instanceof Error &&
+        !(springErr instanceof TypeError) &&
+        !(springErr instanceof RangeError) &&
+        /a spring transition cannot interpolate through \d+ keyframes/.test(springErr.message)
+
+      return validationFails.length === 0 && springOk
+        ? pass(
+            'length<2 / mixed / misplaced-null / nested → typed InvalidTargetError; spring+>2 → named driver refusal',
+          )
+        : fail(
+            `refusal gap: validation=[${validationFails.map((c) => c.label).join(',')}] ` +
+              `spring>2 ok=${springOk} (${springErr instanceof Error ? springErr.message : String(springErr)})`,
+          )
+    },
+  },
+  {
+    // REQ-API-033 (R8, law d) — custom `transition.times` (keyframe offsets) and a per-segment
+    // `transition.ease` LIST EXECUTE through the keyframe generator: both reshape the trajectory versus
+    // the defaults (even offsets + `easeInOut` per segment) — proven engine-agnostically against the
+    // deterministic-interior reference driver, the cross-backend contract the native + web engines must
+    // reproduce. A shipped option that is INERT would sample identically to its default; these do not.
+    // `transition.times`/`transition.ease`-list shapes are also accepted by core `validateTransition`,
+    // and malformed shapes (an offset outside [0,1], a bogus per-segment easing) fail loud typed.
+    id: 'CMP-R8-keyframe-timing',
+    requirements: ['REQ-API-033', 'REQ-API-001'],
+    assert() {
+      // Sample committed x after driving `to` for `steps` × 16.67ms under `transition`.
+      const sampleAt = (
+        to: readonly (number | null)[],
+        transition: Transition,
+        steps: number,
+      ): number => {
+        const d = createReferenceDriver()
+        const h = d.register({ x: 0 })
+        d.command(h, { kind: 'start', targets: { x: { to, from: 0 } }, transition })
+        for (let i = 0; i < steps; i++) d.step(16.67)
+        return d.committed(h)['x'] ?? Number.NaN
+      }
+      // `times` honored: front-loaded offsets [0, 0.1, 1] reach the interior peak far sooner than the
+      // even default [0, 0.5, 1], so at the same instant the sampled value differs materially.
+      const evenOffsets = sampleAt([0, 100, 0], { type: 'tween', duration: 0.2 }, 3)
+      const customTimes = sampleAt(
+        [0, 100, 0],
+        { type: 'tween', duration: 0.2, times: [0, 0.1, 1] },
+        3,
+      )
+      const timesHonored = Math.abs(evenOffsets - customTimes) > 5
+      // Per-segment `ease` list honored: a `['linear', 'linear']` list samples the first segment
+      // linearly, differing from the default `easeInOut` per segment at an interior instant.
+      const defaultEase = sampleAt([0, 100, 50], { type: 'tween', duration: 0.3 }, 3)
+      const listEase = sampleAt(
+        [0, 100, 50],
+        { type: 'tween', duration: 0.3, ease: ['linear', 'linear'] },
+        3,
+      )
+      const easeListHonored = Math.abs(defaultEase - listEase) > 2
+
+      // Core shape law: valid shapes accepted; malformed shapes fail loud typed.
+      const acceptsValid = (() => {
+        try {
+          validateTransition({ type: 'tween', duration: 0.2, times: [0, 0.5, 1] })
+          validateTransition({ type: 'tween', duration: 0.2, ease: ['easeIn', 'easeOut'] })
+          return true
+        } catch {
+          return false
+        }
+      })()
+      const capture = (fn: () => void): unknown => {
+        try {
+          fn()
+          return null
+        } catch (e) {
+          return e
+        }
+      }
+      const badOffset = capture(() => validateTransition({ times: [0, 1.5] }))
+      const badEasing = capture(() => validateTransition({ ease: ['easeIn', 'nope'] }))
+      const shapeRefused =
+        badOffset instanceof InvalidTransitionError &&
+        /times/.test(badOffset.message) &&
+        badEasing instanceof InvalidTransitionError &&
+        /ease/.test(badEasing.message)
+
+      return timesHonored && easeListHonored && acceptsValid && shapeRefused
+        ? pass('custom times + per-segment ease execute (not inert); shapes typed-validated')
+        : fail(
+            `timesHonored/${timesHonored} (even ${evenOffsets.toFixed(1)} vs custom ${customTimes.toFixed(1)}) ` +
+              `easeListHonored/${easeListHonored} (default ${defaultEase.toFixed(1)} vs list ${listEase.toFixed(1)}) ` +
+              `acceptsValid/${acceptsValid} shapeRefused/${shapeRefused}`,
+          )
+    },
+  },
+  {
+    // REQ-API-016 — a reserved-but-unimplemented capability fails loud "not yet supported", not a no-op.
+    id: 'CMP-unimplemented-fail-loud',
+    requirements: ['REQ-API-006', 'REQ-API-016'],
+    assert() {
+      try {
+        // filter is declared on web (web-only) so it clears membership, but its animation is unimplemented.
+        validateTarget({ filter: 'blur(4px)' }, WEB)
+        return fail(
+          'expected a "not yet supported" throw for an unimplemented capability; none raised',
+        )
+      } catch (err) {
+        const named =
+          err instanceof InvalidTargetError &&
+          /filter/.test(err.message) &&
+          /not yet supported/i.test(err.message)
+        return named
+          ? pass('unimplemented filter raised "not yet supported" naming the key')
+          : fail(`threw but wrong class/message: ${(err as Error).message}`)
+      }
+    },
+  },
+]
+
+// Run one component scenario against the deterministic interior, producing a ScenarioResult under the
+// fake-host engine (M1). No adapter/clock needed — the boundary contract is pure.
+export function runComponentScenario(scenario: ComponentScenario): ScenarioResult {
+  const outcome = scenario.assert()
+  return {
+    id: scenario.id,
+    engine: FAKE_ENGINE,
+    verdict: outcome.verdict,
+    readings: [],
+    detail: outcome.detail,
+  }
+}