@things-factory/figure-ui 10.1.15 → 10.1.17

package/test/ai-proposal-contract.test.ts

@@ -8,6 +8,7 @@
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
+import { createRequire } from 'node:module'
 import { test } from 'node:test'
 
 import { applyProposal, diffProposal, takeProposal } from '../dist-client/modeller/proposal.js'
@@ -126,17 +127,24 @@ test('피드백은 후보 세션의 선택과 측정값만 전송한다', () =>
   })
 })
 
-test('모델러 AI 입구는 후보만 알리고, 팔레트·그림·현재 정본을 서버에 함께 보낸다', () => {
-  /* Lit 컴포넌트는 DOM 없이 실로드하지 않는다. 이 경계에서는 실제 소스 계약을 읽는다. */
-  const path = fileURLToPath(new URL('../client/modeller/figure-ask.ts', import.meta.url))
+/*
+ * The modeller has one AI entrance now: the toolbar button opens the asidebar dock, and the dock
+ * runs the whole exchange. `figure-ask` — a second, inline form that called `proposeFigure`
+ * directly — was removed on 2026-09-16. It had already stopped being rendered, so it was dead
+ * code a reader would still have to understand before touching this path.
+ *
+ * What the entrance owes the author is unchanged and checked here: it must not save anything by
+ * itself, and it must hand the server the current source and palette so the candidate is a
+ * revision of what is open rather than something invented from the prompt alone.
+ */
+test('the modeller has exactly one AI entrance, and it opens the dock', () => {
+  const path = fileURLToPath(new URL('../client/pages/figure-modeller-page.ts', import.meta.url))
   const source = readFileSync(path, 'utf8')
 
-  assert.match(source, /const baseSource = this\.source \? JSON\.stringify\(this\.source\) : undefined/)
-  assert.match(source, /proposeFigure\(\{[\s\S]*prompt,[\s\S]*base: baseSource,[\s\S]*type: this\.source \? undefined : this\.type,[\s\S]*palette: Object\.keys\(activePalette\(\)/)
-  assert.match(source, /image: this\.picture/)
-  assert.match(source, /feedback: this\.feedback/)
-  assert.match(source, /new CustomEvent\('proposed', \{ detail: \{ proposal, baseSource \}/)
-  assert.match(source, /this\.failure = \(err as Error\)\.message/)
+  assert.match(source, /requestFigureAI\(\{ figureId: this\.figure\?\.id, source: this\.folded \}\)/)
+  assert.match(source, /openOverlay\('figure-ai-dock'/)
+  assert.doesNotMatch(source, /<figure-ask/, 'the inline ask form is gone; the dock is the entrance')
+  assert.doesNotMatch(source, /proposeFigure\(/, 'the page must not call the propose mutation itself')
 })
 
 test('그림이 붙은 AI 요청은 JSON이 아니라 GraphQL multipart Upload 링크를 탄다', () => {
@@ -189,7 +197,7 @@ test('새 Figure 경로는 MDI에 남아 있는 직전 Figure를 재사용하지
   assert.match(pageUpdated, /if \(this\.figure\.id\)[\s\S]*this\.startNew\(\)/)
   // 새 초안은 저장 식별자·선택·기존 부품·진단을 모두 초기화한다.
   assert.match(startNew, /this\.figure = \{ id: '', type: draftType, name: '' \}/)
-  assert.match(startNew, /const \{ board, parts \} = startingModel\(draftType\)/)
+  assert.match(startNew, /const \{ draft, parts \} = startingModel\(draftType\)/)
   assert.match(startNew, /this\.selected = -1/)
   assert.match(startNew, /this\.dirty = true/)
   assert.match(startNew, /this\.violations = \[\]/)
@@ -200,7 +208,7 @@ test('빈 새 Figure는 캔버스의 직전 씬을 폐기하고 안내 상태로
   const source = readFileSync(path, 'utf8')
   const standUp = source.slice(source.indexOf('  private standUp()'), source.indexOf('  /**\n   * 지금 판 위에'))
 
-  assert.match(standUp, /if \(!board\) \{[\s\S]*this\.teardown\(\)/)
+  assert.match(standUp, /if \(!draft\) \{[\s\S]*this\.teardown\(\)/)
   assert.match(standUp, /if \(this\.parts\.length === 0\) \{[\s\S]*this\.teardown\(\)[\s\S]*canvas-appears-once-a-part-exists/)
 })
 
@@ -212,7 +220,7 @@ test('캔버스는 figureId를 판별에 포함하고 없어진 부품을 씬에
 
   // figureId 변경 시 새 씬을 세우도록 signature에 figureId가 포함된다
   assert.match(canvasSource, /@property\(\{ type: String \}\) figureId\?: string/)
-  assert.match(canvasSource, /signature = `\$\{this\.figureId \?\? ''\}:\$\{board\.width\}x\$\{board\.height\}x\$\{board\.depth\}/)
+  assert.match(canvasSource, /signature = `\$\{this\.figureId \?\? ''\}:\$\{draft\.width\}x\$\{draft\.height\}x\$\{draft\.depth\}/)
   
   // 없어진 부품은 root.removeComponent와 component.dispose로 제거된다
   assert.match(canvasSource, /root\.removeComponent\?\.\(component\)/)
@@ -222,3 +230,376 @@ test('캔버스는 figureId를 판별에 포함하고 없어진 부품을 씬에
   assert.match(modellerSource, /\.figureId=\$\{this\.figure\?\.id \|\| this\.figure\?\.type\}/)
 })
 
+
+/*
+ * ── The whole round trip, not just one hop ───────────────────────────────────
+ *
+ * Everything above checks a single step. What broke on 2026-09-15 was the sequence: a candidate
+ * that only added animations produced an EMPTY change list, so the take button — disabled while
+ * nothing is picked — could never be pressed. The author could neither accept the candidate nor
+ * get rid of it. Asking again did not help, because the second candidate had the same shape.
+ *
+ * `FIGURE_FIELDS` in proposal.ts decides which figure-level fields are visible at all, and it had
+ * fallen behind the format: `animations`, `capabilities` and `placement` were missing, while
+ * `anchor` — removed from the format on 2026-09-10 — was still listed. The tests below walk the
+ * sequence an author actually performs, so a gap in that list shows up as a stuck session rather
+ * than as a silently dropped field.
+ */
+
+/** A candidate whose only change is movement — the shape that could not be finished. */
+const animationOnly = () => ({
+  ...current(),
+  animations: [
+    {
+      name: 'door',
+      drive: 'loop',
+      channels: [
+        {
+          target: 'motor',
+          path: 'rotation',
+          keys: [
+            { at: 0, value: { x: 0, y: 0, z: 0 } },
+            { at: 2, value: { x: 0, y: 90, z: 0 } }
+          ]
+        }
+      ]
+    }
+  ]
+})
+
+test('a candidate that only adds movement is something the author can act on', () => {
+  const changes = diffProposal(current() as any, animationOnly() as any)
+
+  assert.deepEqual(
+    changes.map(c => `${c.kind}:${c.key}`),
+    ['animations:animations'],
+    'movement-only candidates used to diff to nothing, which left the take button disabled forever'
+  )
+
+  const taken = applyProposal(current() as any, animationOnly() as any, new Set(['animations'])) as any
+  assert.equal(taken.animations?.length, 1, 'the clip has to survive being taken')
+  assert.equal(taken.animations[0].channels[0].target, 'motor')
+})
+
+test('figure-level fields the format has are all offered, and ones it dropped are not', () => {
+  const before = { ...current(), placement: 'floor', capabilities: ['Holdable'] }
+  const after = {
+    ...current(),
+    placement: 'ceiling',
+    capabilities: ['Holdable', 'FlowNode'],
+    styleKit: 'factory',
+    detailLevel: 'L',
+    base: { x: 120, y: 100, z: 100 },
+    animations: animationOnly().animations
+  }
+
+  const kinds = diffProposal(before as any, after as any).map(c => c.kind)
+  for (const kind of ['base', 'placement', 'detail', 'styleKit', 'animations', 'capabilities']) {
+    assert.ok(kinds.includes(kind as any), `${kind} changed and the author was never shown it`)
+  }
+  assert.ok(!kinds.includes('anchor' as any), 'figure-level anchor left the format on 2026-09-10')
+})
+
+test('propose, revise, then accept — each round starts from what the author has now', () => {
+  /* Round one: the author keeps the new guard but not the wider base. */
+  const first = openAiProposal(current() as any, { source: JSON.stringify(proposal()) } as any)
+  assert.ok(first.picked.size > 0, 'a fresh session starts with every change picked')
+
+  const withoutBase = toggleProposalChange(first, 'base')
+  assert.ok(!withoutBase.picked.has('base'))
+
+  const afterFirst = applyProposal(current() as any, proposal() as any, withoutBase.picked) as any
+  assert.deepEqual(afterFirst.base, current().base, 'the change left unpicked must not be applied')
+  assert.ok(afterFirst.parts.some((p: any) => p.name === 'guard'), 'the picked addition must be applied')
+
+  /* Round two: asked again, this time about movement. The base the author refused stays refused. */
+  const revised = { ...afterFirst, animations: animationOnly().animations }
+  const second = openAiProposal(afterFirst, { source: JSON.stringify(revised) } as any)
+  assert.deepEqual(
+    [...second.picked],
+    ['animations'],
+    'the second round compares against the accepted draft, not the original — already-taken changes are not offered again'
+  )
+
+  const afterSecond = applyProposal(afterFirst, revised as any, second.picked) as any
+  assert.equal(afterSecond.animations?.length, 1)
+  assert.ok(afterSecond.parts.some((p: any) => p.name === 'guard'), 'round one survives round two')
+  assert.deepEqual(afterSecond.base, current().base, 'and so does the refusal')
+})
+
+test('cancelling leaves the draft exactly as it was', () => {
+  const draft = current()
+  const session = openAiProposal(draft as any, { source: JSON.stringify(proposal()) } as any)
+
+  /* Cancelling is dropping the session. The draft is a separate value and must be untouched. */
+  assert.deepEqual(draft, current(), 'opening a candidate for review must not mutate the draft')
+  assert.ok(session.source !== (draft as any), 'and the session must hold its own copy')
+
+  /* Unpicking everything is the other way to refuse: the take button disables and nothing moves. */
+  let emptied = session
+  for (const key of [...session.picked]) emptied = toggleProposalChange(emptied, key)
+  assert.equal(emptied.picked.size, 0)
+  assert.deepEqual(applyProposal(draft as any, proposal() as any, emptied.picked) as any, {
+    ...draft,
+    parts: draft.parts
+  }, 'with nothing picked the result is the draft itself')
+})
+
+/*
+ * ── The cases the four tests above did not reach ─────────────────────────────
+ *
+ * Those covered the happy sequence. What follows are the ones an author actually hits and that a
+ * happy-path test never touches: refusing a deletion, a candidate that takes movement away, the
+ * draft moving under an open candidate, and every change kind surviving being applied rather than
+ * merely being listed. The animation defect was in exactly that gap — the kind was listed nowhere,
+ * so nothing that only listed kinds could have caught it.
+ */
+
+const withAnimation = () => ({ ...current(), animations: animationOnly().animations })
+
+test('refusing a deletion keeps the part, and taking it removes it', () => {
+  const dropsMotor = { ...current(), parts: current().parts.filter(p => p.name !== 'motor') }
+
+  const changes = diffProposal(current() as any, dropsMotor as any)
+  assert.deepEqual(changes.map(c => `${c.kind}:${c.key}`), ['removed:motor'])
+
+  const refused = applyProposal(current() as any, dropsMotor as any, new Set()) as any
+  assert.ok(refused.parts.some((p: any) => p.name === 'motor'), 'an unpicked removal must not delete anything')
+
+  const taken = applyProposal(current() as any, dropsMotor as any, new Set(['motor'])) as any
+  assert.ok(!taken.parts.some((p: any) => p.name === 'motor'))
+})
+
+test('a candidate that takes movement away is shown, not applied behind the author', () => {
+  /* The reverse direction of the defect: the draft has clips and the candidate comes back without. */
+  const stripped = { ...withAnimation(), animations: undefined }
+
+  const changes = diffProposal(withAnimation() as any, stripped as any)
+  assert.deepEqual(changes.map(c => c.kind), ['animations'], 'losing the clips has to appear as a change')
+
+  const refused = applyProposal(withAnimation() as any, stripped as any, new Set()) as any
+  assert.equal(refused.animations?.length, 1, 'unpicked, the clips stay')
+
+  const taken = applyProposal(withAnimation() as any, stripped as any, new Set(['animations'])) as any
+  assert.equal(taken.animations, undefined, 'picked, they go — but only because the author said so')
+})
+
+test('every change kind survives being applied, not just being listed', () => {
+  const before = { ...current(), placement: 'floor', capabilities: ['Holdable'], styleKit: 'plain' }
+  const after = {
+    ...current(),
+    placement: 'ceiling',
+    capabilities: ['Holdable', 'FlowNode'],
+    styleKit: 'factory',
+    detailLevel: 'L',
+    base: { x: 120, y: 100, z: 100 },
+    animations: animationOnly().animations
+  }
+
+  const all = new Set(diffProposal(before as any, after as any).map(c => c.key))
+  const taken = applyProposal(before as any, after as any, all) as any
+
+  assert.equal(taken.placement, 'ceiling')
+  assert.deepEqual(taken.capabilities, ['Holdable', 'FlowNode'])
+  assert.equal(taken.styleKit, 'factory')
+  assert.equal(taken.detailLevel, 'L')
+  assert.deepEqual(taken.base, { x: 120, y: 100, z: 100 })
+  assert.equal(taken.animations?.length, 1)
+})
+
+test('each figure-level change can be taken on its own without dragging the others along', () => {
+  const before = { ...current(), placement: 'floor', capabilities: ['Holdable'] }
+  const after = {
+    ...current(),
+    placement: 'ceiling',
+    capabilities: ['Holdable', 'FlowNode'],
+    animations: animationOnly().animations
+  }
+
+  for (const only of ['placement', 'capabilities', 'animations']) {
+    const taken = applyProposal(before as any, after as any, new Set([only])) as any
+    assert.equal(taken.placement, only === 'placement' ? 'ceiling' : 'floor', `${only}: placement leaked`)
+    assert.equal(
+      taken.capabilities.length,
+      only === 'capabilities' ? 2 : 1,
+      `${only}: capabilities leaked`
+    )
+    assert.equal(taken.animations === undefined, only !== 'animations', `${only}: animations leaked`)
+  }
+})
+
+test('taking part of a candidate and then asking again offers only what is still different', () => {
+  const after = {
+    ...current(),
+    placement: 'ceiling',
+    animations: animationOnly().animations,
+    parts: [...current().parts, proposal().parts[1]]
+  }
+
+  /* The author takes the movement only. */
+  const firstRound = applyProposal(current() as any, after as any, new Set(['animations'])) as any
+  assert.equal(firstRound.animations?.length, 1)
+  assert.equal(firstRound.placement, undefined)
+
+  /* Asking again with the same candidate must still offer what was left behind — and not movement. */
+  const second = openAiProposal(firstRound, { source: JSON.stringify(after) } as any)
+  assert.deepEqual([...second.picked].sort(), ['guard', 'placement'])
+})
+
+test('a malformed candidate is refused at the session boundary, not half-opened', () => {
+  for (const bad of ['{"type":"MIXER"}', '{"parts":"not an array"}', 'not json at all']) {
+    assert.throws(
+      () => openAiProposal(current() as any, { source: bad } as any),
+      'a candidate without a usable parts array must not open a review session'
+    )
+  }
+})
+
+test('an identical candidate leaves nothing to decide', () => {
+  const same = openAiProposal(current() as any, { source: JSON.stringify(current()) } as any)
+  assert.equal(same.picked.size, 0, 'no differences means no picks')
+  assert.deepEqual(
+    applyProposal(current() as any, current() as any, same.picked) as any,
+    current(),
+    'and applying it changes nothing'
+  )
+})
+
+test('taking a candidate twice does not compound — the second time there is nothing left', () => {
+  const once = applyProposal(current() as any, proposal() as any) as any
+  const twice = applyProposal(once, proposal() as any) as any
+  assert.deepEqual(twice, once, 'apply has to be idempotent, or a double click duplicates parts')
+  assert.equal(
+    once.parts.filter((p: any) => p.name === 'guard').length,
+    1,
+    'the added part must not appear twice'
+  )
+})
+
+test('part names are matched exactly — a renamed part is an addition plus a removal', () => {
+  const renamed = {
+    ...current(),
+    parts: current().parts.map(p => (p.name === 'motor' ? { ...p, name: 'Motor' } : p))
+  }
+
+  const kinds = diffProposal(current() as any, renamed as any).map(c => `${c.kind}:${c.key}`).sort()
+  assert.deepEqual(kinds, ['added:Motor', 'removed:motor'], 'case differences are different parts — bindings are exact')
+})
+
+/*
+ * ── The three properties this path has to keep, stated as properties ─────────
+ *
+ * Everything above is a case. Cases are written by hand and a hand-written list stops where its
+ * author stopped thinking — which is how a whole feature (movement) went unreachable while every
+ * test stayed green. These are closed over the format instead: they read what a FigureSource may
+ * contain and assert something that must hold for all of it, so the format growing is what makes
+ * them fail.
+ *
+ * They are also the contract another authoring surface would have to meet. Nothing below knows
+ * about figures specifically — only that there is a canonical document, a candidate for it, and a
+ * person deciding between the two.
+ */
+
+/** 형식이 선언한 저작 칸. 손으로 적지 않는다 — 형식이 자라면 이 시험도 같이 자란다. */
+function figureFields(): string[] {
+  /* 패키지가 호이스팅되면 이 패키지 아래에 없다. 해석으로 찾는다 — 경로를 적어 두지 않는다. */
+  const entry = createRequire(import.meta.url).resolve('@hatiolab/figure-model/package.json')
+  const source = readFileSync(entry.replace(/package\.json$/, 'dist/types.d.ts'), 'utf8')
+  const body = source.match(/interface FigureSource \{([\s\S]*?)\n\}/)
+  assert.ok(body, 'FigureSource 를 형식에서 못 찾았다')
+  return [...body![1].matchAll(/^ {4}([a-zA-Z]+)\??:/gm)].map(m => m[1]!)
+}
+
+test('구조 · 저작 가능한 모든 칸은 검토를 지난다 — 조용히 지나가는 칸이 없다', () => {
+  /*
+    `type` 은 저장 식별자라 후보가 바꿔도 받지 않고, `parts` 는 부품 단위로 따로 센다.
+    `version` 은 저장할 때 서버가 찍는다. 나머지는 전부 사람이 보고 고를 수 있어야 한다.
+  */
+  const decidedElsewhere = new Set(['type', 'parts', 'version'])
+  const mustBeReviewable = figureFields().filter(f => !decidedElsewhere.has(f))
+
+  const before: any = { ...current() }
+  const after: any = { ...current() }
+  /* 각 칸을 실제로 다르게 만들어 본다 — 이름만 맞추는 시험은 값이 안 옮겨져도 통과한다. */
+  const sample: Record<string, [unknown, unknown]> = {
+    base: [{ x: 100, y: 100, z: 100 }, { x: 120, y: 100, z: 100 }],
+    placement: ['floor', 'ceiling'],
+    detailLevel: ['M', 'L'],
+    styleKit: ['plain', 'factory'],
+    animations: [undefined, animationOnly().animations],
+    capabilities: [['Holdable'], ['Holdable', 'FlowNode']]
+  }
+
+  const unsampled = mustBeReviewable.filter(f => !(f in sample))
+  assert.deepEqual(unsampled, [], '형식에 칸이 늘었다 — 여기에 다른 값 한 쌍을 더해 검토를 확인하라')
+
+  for (const field of mustBeReviewable) {
+    const [b, a] = sample[field]!
+    before[field] = b
+    after[field] = a
+  }
+
+  const changes = diffProposal(before, after)
+  const shown = new Set(changes.map(c => c.key))
+  const hidden = mustBeReviewable.filter(f => !shown.has(f))
+  assert.deepEqual(hidden, [], '바뀌었는데 사람에게 안 보이는 칸이다 — 받아도 반영되지 않고 아무 말도 안 난다')
+
+  const taken = applyProposal(before, after, new Set(mustBeReviewable)) as any
+  for (const field of mustBeReviewable) {
+    assert.deepEqual(taken[field], sample[field]![1], `${field}: 목록에는 떴는데 받아도 안 옮겨졌다`)
+  }
+})
+
+test('구조 · 고른 것만 옮겨진다 — 어떤 부분집합에도', () => {
+  const before: any = { ...current(), placement: 'floor', capabilities: ['Holdable'] }
+  const after: any = {
+    ...current(),
+    placement: 'ceiling',
+    capabilities: ['Holdable', 'FlowNode'],
+    animations: animationOnly().animations,
+    parts: [...current().parts, proposal().parts[1]]
+  }
+
+  const keys = diffProposal(before, after).map(c => c.key)
+  /* 부분집합 전수. 칸이 늘면 경우도 자동으로 는다. */
+  for (let mask = 0; mask < 1 << keys.length; mask++) {
+    const picked = new Set(keys.filter((_, i) => mask & (1 << i)))
+    const taken = applyProposal(before, after, picked) as any
+    const left = diffProposal(taken, after).map(c => c.key)
+
+    for (const key of keys) {
+      const wasPicked = picked.has(key)
+      assert.equal(
+        left.includes(key),
+        !wasPicked,
+        `고른 것은 남으면 안 되고 안 고른 것은 남아야 한다 (${[...picked].join(',') || '없음'} 에서 ${key})`
+      )
+    }
+  }
+})
+
+test('구조 · 검토는 정본을 건드리지 않는다 — 받기 전까지', () => {
+  const draft = Object.freeze({
+    ...current(),
+    parts: Object.freeze(current().parts.map(p => Object.freeze(p)))
+  }) as any
+  const candidate = { ...current(), animations: animationOnly().animations, placement: 'ceiling' } as any
+
+  /* 얼린 것에 쓰면 던진다. 던지지 않는다는 것이 곧 안 건드렸다는 것이다. */
+  const session = openAiProposal(draft, { source: JSON.stringify(candidate) } as any)
+  diffProposal(draft, candidate)
+  applyProposal(draft, candidate, session.picked)
+  toggleProposalChange(session, 'placement')
+
+  assert.deepEqual(draft.animations, undefined, '검토를 열었다고 정본이 달라지면 안 된다')
+  assert.equal(draft.placement, undefined)
+})
+
+test('구조 · 같은 후보를 두 번 받아도 한 번 받은 것과 같다', () => {
+  const after: any = { ...current(), animations: animationOnly().animations, placement: 'ceiling' }
+  const once = applyProposal(current() as any, after, undefined) as any
+  const twice = applyProposal(once, after, undefined) as any
+
+  assert.deepEqual(twice, once, '두 번 눌러도 달라지면 안 된다')
+  assert.deepEqual(diffProposal(once, after), [], '한 번 받으면 남는 변경이 없다')
+})

package/test/expect.ts

@@ -0,0 +1,55 @@
+/*
+ * A thin `expect` over `node:assert`, so Jest-shaped tests can run here.
+ *
+ * ── Why this exists ──────────────────────────────────────────────────────────
+ * This package runs `node --test test/*.test.ts`. Two suites were written in Jest's shape and
+ * left under `client/modeller/`, where **neither runner picked them up** — `npm test` does not
+ * look there, and the repository's Jest is not configured for this package. They had not executed
+ * since they were written.
+ *
+ * That mattered more than the count. `figure-source.ts` carries a comment saying the round-trip
+ * guard "now reads the field list the format declares rather than trusting the fixture", and that
+ * guard lives in one of those files. The source leaned on a test that never ran.
+ *
+ * Rewriting 662 lines of assertions by hand would have changed what they mean in places nobody
+ * would notice. Eight matchers cover both files, so the cheaper and safer move is to give them
+ * the eight.
+ *
+ * Only add a matcher here when a test needs it. This is a bridge for suites that already exist,
+ * not a second assertion library for new ones — new tests in this package use `node:assert`
+ * directly, like every other file under `test/`.
+ */
+import assert from 'node:assert/strict'
+
+export interface Expectation {
+  toBe(expected: unknown): void
+  toEqual(expected: unknown): void
+  toMatchObject(expected: Record<string, unknown>): void
+  toHaveLength(expected: number): void
+  toBeUndefined(): void
+  toBeGreaterThan(expected: number): void
+  toBeLessThan(expected: number): void
+  toBeLessThanOrEqual(expected: number): void
+}
+
+export function expect(actual: any): Expectation {
+  return {
+    /* Jest's toBe is Object.is; assert.strictEqual is the same comparison. */
+    toBe: expected => assert.strictEqual(actual, expected),
+    toEqual: expected => assert.deepStrictEqual(actual, expected),
+    toMatchObject: expected => {
+      for (const [key, value] of Object.entries(expected)) {
+        assert.deepStrictEqual(
+          actual?.[key],
+          value,
+          `${key}: ${JSON.stringify(actual?.[key])} !== ${JSON.stringify(value)}`
+        )
+      }
+    },
+    toHaveLength: expected => assert.strictEqual(actual?.length, expected, `length ${actual?.length} !== ${expected}`),
+    toBeUndefined: () => assert.strictEqual(actual, undefined),
+    toBeGreaterThan: expected => assert.ok(actual > expected, `${actual} is not greater than ${expected}`),
+    toBeLessThan: expected => assert.ok(actual < expected, `${actual} is not less than ${expected}`),
+    toBeLessThanOrEqual: expected => assert.ok(actual <= expected, `${actual} is not <= ${expected}`)
+  }
+}