@pikku/core 0.12.72 → 0.12.74

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

@@ -0,0 +1,213 @@
+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,
+  },
+
+  // The only disposition that is not testing anything. It is doing the job, so
+  // it abandons rarely, runs cool, and is told to stop and say so rather than
+  // guess — the failure mode here is a wrong action nobody asked for, not a
+  // missed bug.
+  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

@@ -0,0 +1,208 @@
+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

@@ -0,0 +1,185 @@
+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

@@ -0,0 +1,72 @@
+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)
+  })
+})