@pikku/core 0.12.107 → 0.12.112

package/src/wirings/virtual-user/virtual-user-dispositions.ts

@@ -1,210 +0,0 @@
-import type { VirtualUserDisposition } from './virtual-user.types.js'
-
-/**
- * The dials a disposition turns. Everything here changes what the engine does;
- * `instructions` is the only field the model ever sees, and it describes
- * behaviour the dials cannot express on their own.
- */
-export interface DispositionProfile {
-  /** Appended to the persona instructions. Behaviour, never identity. */
-  instructions: string
-  /**
-   * Relative weights for the scheduler's four moves. `continue` dominating is
-   * what makes a run look like work rather than channel-surfing.
-   */
-  moves: {
-    continue: number
-    suspend: number
-    resume: number
-    abandon: number
-  }
-  /** Sampling temperature for the model's own turns. */
-  temperature: number
-  /** Chance of re-issuing the previous call unchanged — the double-click. */
-  repeatRate: number
-  /** Chance of re-reading before acting instead of trusting memory. */
-  reReadRate: number
-  /** Start with nothing remembered, whatever the caller seeded. */
-  emptyMemory: boolean
-  /** Non-read calls are refused by the engine, not merely discouraged. */
-  readOnly: boolean
-  /**
-   * A 2xx is a finding rather than a success. The engine cannot know *whose*
-   * resource an id belongs to, so it flags the success and leaves ownership to
-   * the app's classifier — the honest split, since ownership is app knowledge.
-   */
-  invertedOracle: boolean
-}
-
-/**
- * Per-user overrides for a disposition's dials.
- *
- * The six profiles below are starting points, not laws — the weights are a
- * considered guess about how people behave, and your product is allowed to know
- * better. A user that declares `disposition: 'careless'` with a higher
- * `repeatRate` is still a careless user; it is the same behaviour tuned to a
- * product where double-submits actually happen.
- *
- * `instructions` is the one field that appends rather than replaces. Everything
- * else is a number the engine reads, so overriding it changes the run and
- * nothing else; instructions are the model's sense of who it is, and letting a
- * declaration replace them wholesale is how you end up with a `careless` user
- * that is not careless — which makes the name, and every run labelled with it,
- * a lie.
- */
-export interface VirtualUserTuning {
-  /** Relative weights for the scheduler's moves. Merged over the profile's. */
-  moves?: Partial<DispositionProfile['moves']>
-  temperature?: number
-  repeatRate?: number
-  reReadRate?: number
-  emptyMemory?: boolean
-  readOnly?: boolean
-  invertedOracle?: boolean
-  /** Extra behaviour, appended to the disposition's own instructions. */
-  instructions?: string
-}
-
-const REALISTIC: DispositionProfile = {
-  instructions: [
-    'Work towards your current goal the way a competent user would.',
-    'Read an endpoint schema before you use it, and prefer values that a real person would plausibly enter.',
-  ].join(' '),
-  moves: { continue: 88, suspend: 6, resume: 5, abandon: 1 },
-  temperature: 0.7,
-  repeatRate: 0,
-  reReadRate: 0.1,
-  emptyMemory: false,
-  readOnly: false,
-  invertedOracle: false,
-}
-
-/**
- * The profiles, keyed by disposition. `careless` is the one worth reading twice:
- * it is not malice, it is an ordinary person being interrupted and impatient,
- * and it is where most production bugs actually live.
- */
-export const DISPOSITIONS: Readonly<
-  Record<VirtualUserDisposition, DispositionProfile>
-> = {
-  realistic: REALISTIC,
-
-  careless: {
-    ...REALISTIC,
-    instructions: [
-      'You are busy and easily distracted. You act on what you half-remember rather than checking first,',
-      'you sometimes submit the same thing twice because you are not sure it went through,',
-      'and you are comfortable entering odd-but-legal values — a very long name, an empty optional field, an emoji, a huge page size.',
-      'Stay within what the schema allows; you are careless, not malicious.',
-    ].join(' '),
-    moves: { continue: 62, suspend: 18, resume: 12, abandon: 8 },
-    temperature: 1,
-    repeatRate: 0.18,
-    reReadRate: 0.03,
-  },
-
-  newcomer: {
-    ...REALISTIC,
-    instructions: [
-      'This is your first time in this product. You know nothing about it and hold no ids or names in your head.',
-      'Find your way from whatever lists or lookups exist, and say plainly when there is no path forward from where you are.',
-    ].join(' '),
-    moves: { continue: 80, suspend: 8, resume: 6, abandon: 6 },
-    temperature: 0.8,
-    reReadRate: 0.4,
-    emptyMemory: true,
-  },
-
-  stale: {
-    ...REALISTIC,
-    instructions: [
-      'You used this product a while ago and are working from notes you took then.',
-      'Reach for the ids and names you already have rather than looking them up again — some of them are out of date, and finding out how the product tells you so is the point.',
-    ].join(' '),
-    moves: { continue: 84, suspend: 8, resume: 6, abandon: 2 },
-    temperature: 0.7,
-    reReadRate: 0.02,
-  },
-
-  auditor: {
-    ...REALISTIC,
-    instructions: [
-      'You are reconciling, not achieving. Pick one fact the product reports — a total, a count, a balance, a status —',
-      'and read it from every endpoint that claims to know it, then say whether they agree.',
-      'Report a disagreement precisely: which endpoints, which field, which two values.',
-      'Never change anything.',
-    ].join(' '),
-    moves: { continue: 92, suspend: 4, resume: 4, abandon: 0 },
-    temperature: 0.4,
-    reReadRate: 0.5,
-    readOnly: true,
-  },
-
-  adversarial: {
-    ...REALISTIC,
-    instructions: [
-      'You are testing whether this product actually enforces the boundaries it claims.',
-      'Try reaching resources that should not be yours, reusing identifiers you were given for one purpose in another,',
-      'and calling endpoints that look like they belong to someone with more authority than you.',
-      'You are probing authorization, not causing damage: never destroy data you can reach, and prefer reads over writes when either would prove the point.',
-    ].join(' '),
-    moves: { continue: 70, suspend: 10, resume: 8, abandon: 12 },
-    temperature: 0.9,
-    reReadRate: 0.2,
-    invertedOracle: true,
-  },
-
-  // knowledge: decisions/internals/the-worker-disposition-is-the-one-that-is-not-testing.md
-  accountable: {
-    ...REALISTIC,
-    instructions: [
-      'You are doing this job for real. What you change stays changed, and every call you make is recorded against your name.',
-      'Work towards your goals as the person you are, using the tools you have been given.',
-      'Where a specialist agent exists for part of the work, hand that part to it rather than reconstructing it yourself.',
-      'When you are unsure whether something is wanted, stop and say what you would do and why, rather than doing it and reporting afterwards.',
-      'Never guess at an identifier, an amount or a recipient — read it from the product first.',
-    ].join(' '),
-    moves: { continue: 94, suspend: 5, resume: 1, abandon: 0 },
-    temperature: 0.4,
-    repeatRate: 0,
-    reReadRate: 0.25,
-  },
-}
-
-/**
- * The profile for a disposition, defaulting to `realistic`, with any declared
- * tuning merged over it.
- *
- * Every consumer resolves a profile through here — the engine, the CLI report
- * and the console screen — so a tuned user reads as tuned everywhere rather
- * than only behaving differently when it runs.
- */
-export const dispositionProfile = (
-  disposition: VirtualUserDisposition = 'realistic',
-  tuning?: VirtualUserTuning
-): DispositionProfile => {
-  const base = DISPOSITIONS[disposition] ?? DISPOSITIONS.realistic
-  if (!tuning) {
-    return base
-  }
-
-  const { moves, instructions, ...dials } = tuning
-  const profile: DispositionProfile = {
-    ...base,
-    // An explicit `undefined` is someone spreading an optional value, not a
-    // request to unset a dial — spreading `dials` straight in would erase it.
-    ...Object.fromEntries(
-      Object.entries(dials).filter(([, value]) => value !== undefined)
-    ),
-    moves: {
-      ...base.moves,
-      ...Object.fromEntries(
-        Object.entries(moves ?? {}).filter(([, value]) => value !== undefined)
-      ),
-    },
-  }
-  if (instructions) {
-    profile.instructions = `${base.instructions} ${instructions}`
-  }
-  return profile
-}

package/src/wirings/virtual-user/virtual-user-intents.test.ts

@@ -1,218 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { IntentStack, intentsForPersona } from './virtual-user-intents.js'
-import { createRng } from './virtual-user-rng.js'
-import {
-  DISPOSITIONS,
-  type DispositionProfile,
-} from './virtual-user-dispositions.js'
-import type { IntentSource } from './virtual-user.types.js'
-
-const profileWith = (
-  moves: DispositionProfile['moves']
-): DispositionProfile => ({ ...DISPOSITIONS.realistic, moves })
-
-const ONLY_CONTINUE = profileWith({
-  continue: 1,
-  suspend: 0,
-  resume: 0,
-  abandon: 0,
-})
-const ONLY_SUSPEND = profileWith({
-  continue: 0,
-  suspend: 1,
-  resume: 0,
-  abandon: 0,
-})
-const ONLY_ABANDON = profileWith({
-  continue: 0,
-  suspend: 0,
-  resume: 0,
-  abandon: 1,
-})
-
-const sources = (count: number): IntentSource[] =>
-  Array.from({ length: count }, (_, i) => ({
-    id: `source_${i}`,
-    title: `do thing ${i}`,
-  }))
-
-describe('intent stack', () => {
-  test('nothing to do means no tick at all', () => {
-    const stack = new IntentStack([], createRng(1), ONLY_CONTINUE)
-    assert.equal(stack.next(0), null)
-    assert.deepEqual(stack.records(), [])
-  })
-
-  test('the first tick always starts something', () => {
-    const stack = new IntentStack(sources(2), createRng(1), ONLY_SUSPEND)
-    const tick = stack.next(0)
-    assert.equal(tick?.move, 'start')
-    assert.equal(tick?.intent.status, 'open')
-  })
-
-  test('continue keeps the same intent live and records the step', () => {
-    const stack = new IntentStack(sources(3), createRng(1), ONLY_CONTINUE)
-    const first = stack.next(0)!
-    for (let step = 1; step < 5; step++) {
-      const tick = stack.next(step)!
-      assert.equal(tick.move, 'continue')
-      assert.equal(tick.intent.id, first.intent.id)
-    }
-    const [record] = stack.records()
-    assert.deepEqual(record!.steps, [0, 1, 2, 3, 4])
-  })
-
-  test('completing frees the stack to schedule the next thing', () => {
-    const stack = new IntentStack(sources(2), createRng(1), ONLY_CONTINUE)
-    const first = stack.next(0)!
-    stack.complete('got what I came for')
-    const second = stack.next(1)!
-    assert.notEqual(second.intent.id, first.intent.id)
-    assert.equal(second.move, 'start')
-
-    const completed = stack.records().find((r) => r.id === first.intent.id)!
-    assert.equal(completed.status, 'completed')
-    assert.equal(completed.summary, 'got what I came for')
-  })
-
-  test('a run ends once every intent is seen through', () => {
-    const stack = new IntentStack(sources(2), createRng(1), ONLY_CONTINUE)
-    stack.next(0)
-    stack.complete()
-    stack.next(1)
-    stack.complete()
-    assert.equal(stack.next(2), null)
-    assert.deepEqual(
-      stack.records().map((r) => r.status),
-      ['completed', 'completed']
-    )
-  })
-
-  test('suspending switches to something else and counts the interruption', () => {
-    const stack = new IntentStack(sources(2), createRng(1), ONLY_SUSPEND)
-    const first = stack.next(0)!
-    const second = stack.next(1)!
-    assert.equal(second.move, 'suspend')
-    assert.notEqual(second.intent.id, first.intent.id)
-
-    const suspended = stack.records().find((r) => r.id === first.intent.id)!
-    assert.equal(suspended.status, 'suspended')
-    assert.equal(suspended.suspensions, 1)
-  })
-
-  test('a suspended intent gets picked back up, not lost', () => {
-    const stack = new IntentStack(sources(2), createRng(1), ONLY_SUSPEND)
-    const first = stack.next(0)!
-    stack.next(1)
-    // Nowhere new to start now, so the suspended one is the only candidate.
-    const third = stack.next(2)!
-    assert.equal(third.intent.id, first.intent.id)
-    assert.equal(third.intent.status, 'open')
-  })
-
-  test('a move with nowhere to go degrades to continue rather than stalling', () => {
-    const stack = new IntentStack(sources(1), createRng(1), ONLY_SUSPEND)
-    const first = stack.next(0)!
-    const second = stack.next(1)!
-    assert.equal(second.move, 'continue')
-    assert.equal(second.intent.id, first.intent.id)
-    // The interruption never happened, so it must not be counted as one.
-    assert.equal(stack.records()[0]!.suspensions, 0)
-    assert.equal(stack.records()[0]!.status, 'open')
-  })
-
-  test('abandoning is final — the user does not quietly come back to it', () => {
-    const stack = new IntentStack(sources(1), createRng(1), ONLY_ABANDON)
-    stack.next(0)
-    assert.equal(stack.next(1), null)
-    assert.equal(stack.records()[0]!.status, 'abandoned')
-  })
-
-  test('stuck records why the user could not get there', () => {
-    const stack = new IntentStack(sources(1), createRng(1), ONLY_CONTINUE)
-    stack.next(0)
-    stack.stuck('no endpoint accepts an invite')
-    const [record] = stack.records()
-    assert.equal(record!.status, 'stuck')
-    assert.equal(record!.summary, 'no endpoint accepts an invite')
-  })
-
-  test('a distractible user still only juggles so many things at once', () => {
-    const stack = new IntentStack(sources(10), createRng(4), ONLY_SUSPEND, 3)
-    for (let step = 0; step < 40; step++) {
-      stack.next(step)
-      const live = stack
-        .records()
-        .filter((r) => r.status === 'open' || r.status === 'suspended')
-      assert.ok(live.length <= 3, `juggling ${live.length}`)
-    }
-  })
-
-  test('the same seed schedules the same run', () => {
-    const schedule = (seed: number) => {
-      const stack = new IntentStack(
-        sources(5),
-        createRng(seed),
-        DISPOSITIONS.careless
-      )
-      return Array.from({ length: 30 }, (_, step) => {
-        const tick = stack.next(step)
-        return tick ? `${tick.move}:${tick.intent.source.id}` : 'end'
-      })
-    }
-    assert.deepEqual(schedule(123), schedule(123))
-    assert.notDeepEqual(schedule(123), schedule(456))
-  })
-
-  test('a careless user interrupts itself far more than a careful one', () => {
-    const suspensions = (profile: DispositionProfile) => {
-      const stack = new IntentStack(sources(6), createRng(21), profile)
-      for (let step = 0; step < 200; step++) stack.next(step)
-      return stack
-        .records()
-        .reduce((total, record) => total + record.suspensions, 0)
-    }
-    assert.ok(
-      suspensions(DISPOSITIONS.careless) >
-        suspensions(DISPOSITIONS.realistic) * 2
-    )
-  })
-})
-
-describe('intents for an actor', () => {
-  const catalogue: IntentSource[] = [
-    { id: 'a', title: 'invite a teammate', personas: ['orgAdmin'] },
-    { id: 'b', title: 'read the dashboard' },
-    {
-      id: 'c',
-      title: 'deploy a stage',
-      personas: ['platformAdmin', 'orgAdmin'],
-    },
-  ]
-
-  test('an actor gets what names it, plus anything that names nobody', () => {
-    assert.deepEqual(
-      intentsForPersona(catalogue, 'orgAdmin').map((i) => i.id),
-      ['a', 'b', 'c']
-    )
-  })
-
-  test('an actor is not given other people’s work', () => {
-    assert.deepEqual(
-      intentsForPersona(catalogue, 'member').map((i) => i.id),
-      ['b']
-    )
-  })
-
-  test('an empty actor list means everyone', () => {
-    assert.deepEqual(
-      intentsForPersona(
-        [{ id: 'x', title: 'anything', personas: [] }],
-        'nobody'
-      ),
-      [{ id: 'x', title: 'anything', personas: [] }]
-    )
-  })
-})

package/src/wirings/virtual-user/virtual-user-intents.ts

@@ -1,185 +0,0 @@
-import type { DispositionProfile } from './virtual-user-dispositions.js'
-import type { VirtualUserRng } from './virtual-user-rng.js'
-import type {
-  IntentRecord,
-  IntentSource,
-  IntentStatus,
-} from './virtual-user.types.js'
-
-/** One intent as the stack tracks it. */
-interface TrackedIntent {
-  id: string
-  source: IntentSource
-  status: IntentStatus
-  steps: number[]
-  suspensions: number
-  summary?: string
-}
-
-/** The move the scheduler rolled for a tick. */
-export type IntentMove = 'start' | 'continue' | 'suspend' | 'resume' | 'abandon'
-
-/** What the stack scheduled: which intent is active, and how it got there. */
-export interface ScheduledTick {
-  intent: TrackedIntent
-  move: IntentMove
-}
-
-/**
- * The stack of things this user is in the middle of — and the whole of the
- * engine's randomness.
- *
- * A real person does not run a flow end to end: they start something, get
- * pulled away, do a bit of something else, come back to a world that moved
- * underneath them, and sometimes never come back at all. Modelling that as a
- * stack of partially-completed intents is what produces the bugs worth having —
- * half-mutated state, a flow resumed against changed data, an invite accepted
- * after the plan changed — none of which a scripted scenario can reach.
- *
- * Scheduling is the engine's job and the model's turns are not: the model
- * decides what to do *within* the active intent, the stack decides which intent
- * that is. Keeping the split there is what makes a run reproducible from a seed
- * while the work inside it stays free.
- *
- * A feature is only where an intent comes from. Nothing here tracks whether one
- * was "completed correctly", and the model is never told an intent boundary
- * exists.
- */
-export class IntentStack {
-  private readonly tracked: TrackedIntent[] = []
-  private readonly unstarted: IntentSource[]
-  private active: TrackedIntent | null = null
-  private counter = 0
-
-  constructor(
-    sources: readonly IntentSource[],
-    private readonly rng: VirtualUserRng,
-    private readonly profile: DispositionProfile,
-    /** Cap on intents open at once, so a distractible user still finishes things. */
-    private readonly maxOpen = 3
-  ) {
-    this.unstarted = [...sources]
-  }
-
-  /**
-   * Pick the intent for this tick, or `null` when there is nothing left to do.
-   *
-   * The first tick always starts something; after that the four moves are
-   * weighted by the disposition, and a move that has nowhere to go degrades to
-   * `continue` rather than stalling the run.
-   */
-  next(step: number): ScheduledTick | null {
-    if (!this.active) {
-      const started = this.startOrResume()
-      if (!started) return null
-      started.steps.push(step)
-      this.active = started
-      return { intent: started, move: 'start' }
-    }
-
-    const move = this.rng.weighted(this.profile.moves) ?? 'continue'
-    if (move === 'continue') {
-      this.active.steps.push(step)
-      return { intent: this.active, move: 'continue' }
-    }
-
-    const current = this.active
-    if (move === 'abandon') {
-      current.status = 'abandoned'
-    } else {
-      current.status = 'suspended'
-      current.suspensions++
-    }
-    this.active = null
-
-    const next =
-      move === 'resume' ? this.resumeSuspended() : this.startOrResume(current)
-    if (!next) {
-      // Nowhere to go: keep working on what we had rather than ending a run
-      // early. An abandoned intent stays abandoned — that decision stands.
-      if (current.status === 'abandoned') return null
-      current.status = 'open'
-      current.suspensions--
-      current.steps.push(step)
-      this.active = current
-      return { intent: current, move: 'continue' }
-    }
-
-    next.status = 'open'
-    next.steps.push(step)
-    this.active = next
-    return { intent: next, move }
-  }
-
-  /** Mark the active intent finished; the next tick schedules something else. */
-  complete(summary?: string): void {
-    if (!this.active) return
-    this.active.status = 'completed'
-    this.active.summary = summary
-    this.active = null
-  }
-
-  /** Mark the active intent as one the user could not get through. */
-  stuck(reason?: string): void {
-    if (!this.active) return
-    this.active.status = 'stuck'
-    this.active.summary = reason
-    this.active = null
-  }
-
-  /** Every intent the run touched, in the order it first opened them. */
-  records(): IntentRecord[] {
-    return this.tracked.map((intent) => ({
-      id: intent.id,
-      sourceId: intent.source.id,
-      title: intent.source.title,
-      status: intent.status,
-      steps: [...intent.steps],
-      suspensions: intent.suspensions,
-      summary: intent.summary,
-    }))
-  }
-
-  /** Prefer opening something new, falling back to picking a suspended one up. */
-  private startOrResume(exclude?: TrackedIntent): TrackedIntent | null {
-    const openCount = this.tracked.filter(
-      (intent) => intent.status === 'open' || intent.status === 'suspended'
-    ).length
-    if (this.unstarted.length > 0 && openCount < this.maxOpen) {
-      const source = this.rng.pick(this.unstarted)!
-      this.unstarted.splice(this.unstarted.indexOf(source), 1)
-      const intent: TrackedIntent = {
-        id: `intent_${++this.counter}`,
-        source,
-        status: 'open',
-        steps: [],
-        suspensions: 0,
-      }
-      this.tracked.push(intent)
-      return intent
-    }
-    return this.resumeSuspended(exclude)
-  }
-
-  private resumeSuspended(exclude?: TrackedIntent): TrackedIntent | null {
-    const suspended = this.tracked.filter(
-      (intent) => intent.status === 'suspended' && intent !== exclude
-    )
-    return this.rng.pick(suspended) ?? null
-  }
-}
-
-/**
- * The intents a persona may be given: those whose source names them, plus every
- * source that names nobody.
- *
- * This is a free lookup rather than new authoring — scenario meta already
- * records which personas each scenario runs as.
- */
-export const intentsForPersona = (
-  sources: readonly IntentSource[],
-  personaId: string
-): IntentSource[] =>
-  sources.filter(
-    (source) => !source.personas?.length || source.personas.includes(personaId)
-  )

package/src/wirings/virtual-user/virtual-user-rng.test.ts

@@ -1,72 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { createRng } from './virtual-user-rng.js'
-
-describe('virtual user rng', () => {
-  test('the same seed replays the same run', () => {
-    const a = createRng(42)
-    const b = createRng(42)
-    const drawsA = Array.from({ length: 50 }, () => a.next())
-    const drawsB = Array.from({ length: 50 }, () => b.next())
-    assert.deepEqual(drawsA, drawsB)
-  })
-
-  test('different seeds diverge', () => {
-    const a = Array.from({ length: 20 }, createRng(1).next)
-    const b = Array.from({ length: 20 }, createRng(2).next)
-    assert.notDeepEqual(a, b)
-  })
-
-  test('draws stay in [0, 1)', () => {
-    const rng = createRng(7)
-    for (let i = 0; i < 1000; i++) {
-      const value = rng.next()
-      assert.ok(value >= 0 && value < 1, `out of range: ${value}`)
-    }
-  })
-
-  test('chance is roughly its probability', () => {
-    const rng = createRng(9)
-    let hits = 0
-    for (let i = 0; i < 10_000; i++) if (rng.chance(0.25)) hits++
-    assert.ok(hits > 2200 && hits < 2800, `got ${hits} of 10000`)
-  })
-
-  test('chance(0) never fires and chance(1) always does', () => {
-    const rng = createRng(3)
-    for (let i = 0; i < 200; i++) {
-      assert.equal(rng.chance(0), false)
-      assert.equal(rng.chance(1), true)
-    }
-  })
-
-  test('pick returns undefined for an empty list and only members otherwise', () => {
-    const rng = createRng(11)
-    assert.equal(rng.pick([]), undefined)
-    const items = ['a', 'b', 'c']
-    const seen = new Set<string>()
-    for (let i = 0; i < 200; i++) seen.add(rng.pick(items)!)
-    assert.deepEqual([...seen].sort(), items)
-  })
-
-  test('weighted respects the weights', () => {
-    const rng = createRng(5)
-    const counts = { continue: 0, suspend: 0 }
-    for (let i = 0; i < 10_000; i++) {
-      counts[rng.weighted({ continue: 90, suspend: 10 })!]++
-    }
-    assert.ok(counts.continue > counts.suspend * 5, JSON.stringify(counts))
-  })
-
-  test('a zero weight can never be drawn — that is how a disposition switches a move off', () => {
-    const rng = createRng(13)
-    for (let i = 0; i < 5000; i++) {
-      assert.notEqual(rng.weighted({ continue: 92, abandon: 0 }), 'abandon')
-    }
-  })
-
-  test('weighted with nothing to draw returns undefined', () => {
-    assert.equal(createRng(1).weighted({ a: 0, b: 0 }), undefined)
-  })
-})