@namzu/sdk 14.0.6 → 15.0.0

package/src/tools/coordinator/__tests__/wait-with-idle-bound.test.ts

@@ -1,247 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import type { TaskGateway, TaskHandle } from '../../../types/agent/gateway.js'
-import type { TaskId } from '../../../types/ids/index.js'
-import { describeWaitTimeout, waitForTaskWithBounds } from '../wait-with-idle-bound.js'
-
-/**
- * A wall clock cannot tell a slow worker from a stuck one.
- *
- * The bound before this was an hour of elapsed time, and an hour has to do
- * two incompatible jobs: be long enough for a child doing real work, and
- * short enough to notice one that wedged. It cannot be both, so a worker
- * stuck in minute two held the supervisor for another fifty-eight, and one
- * making steady progress at minute fifty-nine was killed for being slow.
- *
- * These tests drive both clocks with a fake one, because the real bounds are
- * measured in minutes and a test that actually waits them out is a test
- * nobody runs.
- */
-
-function gatewayFor(opts: {
-	/** Resolve the wait when this is called. */
-	settle?: (resolve: (h: TaskHandle) => void) => void
-	withProgress?: boolean
-}): { gateway: TaskGateway; progress: () => void; finish: () => void } {
-	let resolveWait: ((h: TaskHandle) => void) | undefined
-	const listeners = new Set<(id: TaskId) => void>()
-
-	const handle: TaskHandle = {
-		taskId: 'tsk_1' as TaskId,
-		agentId: 'worker',
-		state: 'completed',
-		createdAt: 0,
-		completedAt: 1,
-	}
-
-	const gateway = {
-		waitForTask: () =>
-			new Promise<TaskHandle>((resolve) => {
-				resolveWait = resolve
-				opts.settle?.(resolve)
-			}),
-		...(opts.withProgress === false
-			? {}
-			: {
-					onTaskProgress: (cb: (id: TaskId) => void) => {
-						listeners.add(cb)
-						return () => listeners.delete(cb)
-					},
-				}),
-	} as unknown as TaskGateway
-
-	return {
-		gateway,
-		progress: () => {
-			for (const cb of listeners) cb('tsk_1' as TaskId)
-		},
-		finish: () => resolveWait?.(handle),
-	}
-}
-
-/** A clock the test moves by hand. */
-function fakeClock(): { now: () => number; advance: (ms: number) => void } {
-	let t = 1_000_000
-	return {
-		now: () => t,
-		advance: (ms) => {
-			t += ms
-		},
-	}
-}
-
-describe('a worker that is still working is not killed for being slow', () => {
-	it('keeps waiting past the idle bound while progress keeps arriving', async () => {
-		vi.useFakeTimers()
-		try {
-			const clock = fakeClock()
-			const { gateway, progress, finish } = gatewayFor({})
-
-			const waiting = waitForTaskWithBounds(
-				gateway,
-				'tsk_1' as TaskId,
-				{ runMs: 60_000, idleMs: 5_000 },
-				clock.now,
-			)
-
-			// Four times the idle bound in elapsed time, but never quiet for
-			// more than half of it.
-			for (let i = 0; i < 8; i += 1) {
-				clock.advance(2_500)
-				progress()
-				await vi.advanceTimersByTimeAsync(1_000)
-			}
-
-			finish()
-			await vi.advanceTimersByTimeAsync(1_000)
-
-			expect((await waiting).kind, 'a working worker was cut off').toBe('completed')
-		} finally {
-			vi.useRealTimers()
-		}
-	})
-})
-
-describe('a worker that has gone quiet is reported as quiet', () => {
-	it('fires the idle bound and says which clock it was', async () => {
-		vi.useFakeTimers()
-		try {
-			const clock = fakeClock()
-			const { gateway } = gatewayFor({})
-
-			const waiting = waitForTaskWithBounds(
-				gateway,
-				'tsk_1' as TaskId,
-				{ runMs: 600_000, idleMs: 5_000 },
-				clock.now,
-			)
-
-			clock.advance(6_000)
-			await vi.advanceTimersByTimeAsync(1_100)
-
-			const outcome = await waiting
-			expect(outcome.kind).toBe('timeout')
-			if (outcome.kind !== 'timeout') return
-			// The distinction is the point: "went quiet" and "ran too long"
-			// are different diagnoses and the caller acts on the message.
-			expect(outcome.cause).toBe('idle')
-			expect(outcome.idleBoundArmed).toBe(true)
-		} finally {
-			vi.useRealTimers()
-		}
-	})
-
-	it('says it went quiet, and that the worker was not cancelled', () => {
-		const text = describeWaitTimeout({
-			kind: 'timeout',
-			cause: 'idle',
-			elapsedMs: 30_000,
-			idleBoundArmed: true,
-		})
-
-		expect(text).toContain('went quiet')
-		// A wait that ran out is a statement about the WAITER. Losing an
-		// eight-minute worker's output because a short clock expired is the
-		// bug this whole area has been unpicking.
-		expect(text).toContain('not been cancelled')
-	})
-})
-
-describe('the run bound still catches a worker that never stops', () => {
-	it('fires on elapsed time even while progress keeps arriving', async () => {
-		vi.useFakeTimers()
-		try {
-			const clock = fakeClock()
-			const { gateway, progress } = gatewayFor({})
-
-			const waiting = waitForTaskWithBounds(
-				gateway,
-				'tsk_1' as TaskId,
-				{ runMs: 10_000, idleMs: 5_000 },
-				clock.now,
-			)
-
-			for (let i = 0; i < 6; i += 1) {
-				clock.advance(2_000)
-				progress()
-				await vi.advanceTimersByTimeAsync(1_000)
-			}
-
-			const outcome = await waiting
-			expect(outcome.kind).toBe('timeout')
-			if (outcome.kind !== 'timeout') return
-			expect(outcome.cause).toBe('run')
-		} finally {
-			vi.useRealTimers()
-		}
-	})
-})
-
-describe('a gateway that cannot see its children', () => {
-	it('is bounded by the wall clock alone, as it was before', async () => {
-		vi.useFakeTimers()
-		try {
-			const clock = fakeClock()
-			const { gateway } = gatewayFor({ withProgress: false })
-
-			const waiting = waitForTaskWithBounds(
-				gateway,
-				'tsk_1' as TaskId,
-				{ runMs: 10_000, idleMs: 1_000 },
-				clock.now,
-			)
-
-			// Far past the idle bound, and it must NOT fire — there is no
-			// signal, so silence carries no information.
-			clock.advance(5_000)
-			await vi.advanceTimersByTimeAsync(1_100)
-			clock.advance(6_000)
-			await vi.advanceTimersByTimeAsync(1_100)
-
-			const outcome = await waiting
-			expect(outcome.kind).toBe('timeout')
-			if (outcome.kind !== 'timeout') return
-			expect(outcome.cause).toBe('run')
-			// And the degradation is visible rather than silent.
-			expect(outcome.idleBoundArmed).toBe(false)
-		} finally {
-			vi.useRealTimers()
-		}
-	})
-
-	it('says so, instead of implying the worker was stuck', () => {
-		const text = describeWaitTimeout({
-			kind: 'timeout',
-			cause: 'run',
-			elapsedMs: 3_600_000,
-			idleBoundArmed: false,
-		})
-
-		expect(text).toContain('cannot report progress')
-	})
-})
-
-describe('a completion always wins', () => {
-	it('returns the handle rather than a timeout when the task finishes first', async () => {
-		vi.useFakeTimers()
-		try {
-			const clock = fakeClock()
-			const { gateway, finish } = gatewayFor({})
-
-			const waiting = waitForTaskWithBounds(
-				gateway,
-				'tsk_1' as TaskId,
-				{ runMs: 10_000, idleMs: 5_000 },
-				clock.now,
-			)
-
-			finish()
-			await vi.advanceTimersByTimeAsync(10)
-
-			const outcome = await waiting
-			expect(outcome.kind).toBe('completed')
-		} finally {
-			vi.useRealTimers()
-		}
-	})
-})

package/src/types/common/__tests__/numeric-correctness.test.ts

@@ -1,123 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { toolsHash } from '../../../connector/mcp/policy.js'
-import type { MCPToolDefinition } from '../../../types/connector/index.js'
-import { mergeTokenUsage } from '../index.js'
-
-/**
- * Arithmetic defects, each pinned by the exact counterexample that proves it.
- * A test here is only worth having if it fails against the old formula, so
- * every one names the number the old code produced.
- */
-
-describe('mergeTokenUsage — totalTokens is derived, not independent', () => {
-	it('does not lose the completion tokens Anthropic reports in a later frame', () => {
-		// A driver reports the input on `message_start` and the output on
-		// `message_delta`. The driver derives each frame's own total as
-		// input+output, so the two frames carry 1200 and 350 — and a max of
-		// those returns the larger COMPONENT, not the sum.
-		const messageStart = {
-			promptTokens: 1200,
-			completionTokens: 0,
-			totalTokens: 1200,
-			cachedTokens: 0,
-			cacheWriteTokens: 0,
-		}
-		const messageDelta = {
-			promptTokens: 0,
-			completionTokens: 350,
-			totalTokens: 350,
-			cachedTokens: 0,
-			cacheWriteTokens: 0,
-		}
-
-		const merged = mergeTokenUsage(messageStart, messageDelta)
-
-		expect(merged.promptTokens).toBe(1200)
-		expect(merged.completionTokens).toBe(350)
-		// Old formula: Math.max(1200, 350) = 1200. Every completion token was
-		// invisible to the budget hard stop, which reads only totalTokens.
-		expect(merged.totalTokens).toBe(1550)
-	})
-
-	it('holds for the minimal case too', () => {
-		const a = {
-			promptTokens: 1,
-			completionTokens: 0,
-			totalTokens: 1,
-			cachedTokens: 0,
-			cacheWriteTokens: 0,
-		}
-		const b = {
-			promptTokens: 0,
-			completionTokens: 1,
-			totalTokens: 1,
-			cachedTokens: 0,
-			cacheWriteTokens: 0,
-		}
-		expect(mergeTokenUsage(a, b).totalTokens).toBe(2)
-	})
-
-	it('never under-reports a provider total that exceeds prompt + completion', () => {
-		// Some providers count tokens the two components do not cover. The
-		// merge must be monotone: it may never return less than what was
-		// reported.
-		const reported = {
-			promptTokens: 10,
-			completionTokens: 5,
-			totalTokens: 99,
-			cachedTokens: 0,
-			cacheWriteTokens: 0,
-		}
-		const empty = {
-			promptTokens: 0,
-			completionTokens: 0,
-			totalTokens: 0,
-			cachedTokens: 0,
-			cacheWriteTokens: 0,
-		}
-		expect(mergeTokenUsage(reported, empty).totalTokens).toBe(99)
-	})
-
-	it('is idempotent, so re-merging a frame cannot inflate the total', () => {
-		const usage = {
-			promptTokens: 1200,
-			completionTokens: 350,
-			totalTokens: 1550,
-			cachedTokens: 0,
-			cacheWriteTokens: 0,
-		}
-		expect(mergeTokenUsage(usage, usage).totalTokens).toBe(1550)
-		expect(mergeTokenUsage(mergeTokenUsage(usage, usage), usage).totalTokens).toBe(1550)
-	})
-})
-
-describe('toolsHash — the fingerprint covers what the HITL gate reads', () => {
-	const tool = (annotations?: Record<string, unknown>): MCPToolDefinition =>
-		({
-			name: 'delete_rows',
-			description: 'Delete rows',
-			inputSchema: { type: 'object', properties: {} },
-			...(annotations ? { annotations } : {}),
-		}) as MCPToolDefinition
-
-	it('notices a server flipping destructive to read-only', () => {
-		// `annotations` becomes `isDestructive` / `isReadOnly` on the tool
-		// definition, and those drive whether a human reviews the call. A
-		// fingerprint that ignores them cannot see the exact rug-pull it was
-		// built to catch: same name, same schema, no longer reviewed.
-		const before = toolsHash([tool({ destructiveHint: true, readOnlyHint: false })])
-		const after = toolsHash([tool({ destructiveHint: false, readOnlyHint: true })])
-		expect(after).not.toBe(before)
-	})
-
-	it('notices annotations appearing where there were none', () => {
-		expect(toolsHash([tool()])).not.toBe(toolsHash([tool({ readOnlyHint: true })]))
-	})
-
-	it('is still stable for an unchanged tool', () => {
-		expect(toolsHash([tool({ destructiveHint: true })])).toBe(
-			toolsHash([tool({ destructiveHint: true })]),
-		)
-	})
-})

package/src/types/common/usage-merge.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { type TokenUsage, accumulateTokenUsage, mergeTokenUsage } from './index.js'
-
-const zero: TokenUsage = {
-	promptTokens: 0,
-	completionTokens: 0,
-	totalTokens: 0,
-	cachedTokens: 0,
-	cacheWriteTokens: 0,
-}
-
-/**
- * M7: within one streamed turn, usage frames are cumulative/monotonic but a
- * late frame may omit fields. `mergeTokenUsage` keeps the per-field high-water
- * mark so a trailing output-only frame does not zero the earlier prompt/cache
- * counts (the under-report the audit flagged).
- */
-describe('mergeTokenUsage (within-turn, per-field max)', () => {
-	it('preserves prompt/cache tokens when a later frame reports only output', () => {
-		// message_start-like frame: input + cache set, output still 0.
-		const early: TokenUsage = {
-			...zero,
-			promptTokens: 1200,
-			cachedTokens: 800,
-			cacheWriteTokens: 200,
-		}
-		// message_delta-like frame: only output tokens, input/cache dropped to 0.
-		const lateOutputOnly: TokenUsage = { ...zero, completionTokens: 350 }
-
-		const merged = mergeTokenUsage(early, lateOutputOnly)
-		expect(merged.promptTokens).toBe(1200) // NOT zeroed by the late frame
-		expect(merged.cachedTokens).toBe(800)
-		expect(merged.cacheWriteTokens).toBe(200)
-		expect(merged.completionTokens).toBe(350)
-	})
-
-	it('takes the growing (max) completion count across frames', () => {
-		const a: TokenUsage = { ...zero, promptTokens: 100, completionTokens: 10 }
-		const b: TokenUsage = { ...zero, promptTokens: 100, completionTokens: 42 }
-		expect(mergeTokenUsage(a, b).completionTokens).toBe(42)
-		// Order-independent (a late smaller frame never regresses the max).
-		expect(mergeTokenUsage(b, a).completionTokens).toBe(42)
-	})
-
-	it('is distinct from accumulateTokenUsage (which sums across turns)', () => {
-		const t1: TokenUsage = { ...zero, promptTokens: 100, completionTokens: 20 }
-		const t2: TokenUsage = { ...zero, promptTokens: 100, completionTokens: 30 }
-		// merge = max within a turn; accumulate = sum across turns.
-		expect(mergeTokenUsage(t1, t2).promptTokens).toBe(100)
-		expect(accumulateTokenUsage(t1, t2).promptTokens).toBe(200)
-	})
-})

package/src/types/errors/__tests__/catalog.test.ts

@@ -1,130 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { ProviderError } from '../../provider/errors.js'
-import { DEFAULT_ERROR_RULES, explainError, factsOf, readHint, withHint } from '../catalog.js'
-import { NamzuError } from '../index.js'
-
-/**
- * A failure surfaced as whatever prose the vendor SDK happened to write:
- * no stable id to grep in logs, no instruction on what to change, and no
- * growth point — a newly-observed failure shape could only be given
- * curated copy by editing the classifier itself.
- *
- * Classification and remediation are separate jobs. The first is
- * structural and belongs at the boundary; the second is editorial and
- * belongs in a list a human appends to. `DoctorCheckResult` already
- * carried `message` and `remediation` as separate fields — `namzu doctor`
- * was simply the only surface that got either.
- */
-
-const providerError = (code: string, status?: number) =>
-	new ProviderError({
-		code: code as never,
-		message: 'the vendor wrote this',
-		providerId: 'test',
-		...(status !== undefined ? { status } : {}),
-	})
-
-describe('explaining a failure', () => {
-	it('gives a stale key an id and something to do about it', () => {
-		const explanation = explainError(providerError('auth', 401))
-
-		expect(explanation?.id).toBe('provider.auth')
-		expect(explanation?.hint).toMatch(/API key/)
-		// Not the vendor's sentence: the point is copy an operator can act
-		// on, keyed by an id they can grep for.
-		expect(explanation?.message).not.toContain('the vendor wrote this')
-	})
-
-	it('separates a permission failure from an authentication one', () => {
-		// The provider codes collapse 401 and 403, but the two call for
-		// different actions and the status still tells them apart.
-		expect(explainError(providerError('auth', 403))?.id).toBe('provider.permission')
-		expect(explainError(providerError('auth', 401))?.id).toBe('provider.auth')
-	})
-
-	it('recognises the failures an operator hits first', () => {
-		expect(explainError(providerError('rate_limit', 429))?.id).toBe('provider.rate_limit')
-		expect(explainError(providerError('context_length_exceeded'))?.id).toBe(
-			'provider.context_overflow',
-		)
-		expect(explainError(providerError('overloaded', 529))?.id).toBe('provider.unavailable')
-		expect(explainError(providerError('network'))?.id).toBe('provider.network')
-		expect(explainError(providerError('not_found', 404))?.id).toBe('provider.model_not_found')
-	})
-
-	it('says nothing rather than inventing advice', () => {
-		// A generic fallback would send the reader somewhere specific and
-		// wrong, which is worse than admitting the failure is unfamiliar.
-		expect(explainError(new Error('something nobody has characterised'))).toBeNull()
-	})
-
-	it('matches on structure, not on vendor prose', () => {
-		// Vendor copy changes without warning and differs per SDK version,
-		// so a rule keyed to it silently stops matching.
-		const reworded = providerError('rate_limit', 429)
-		Object.defineProperty(reworded, 'message', { value: 'completely different wording' })
-		expect(explainError(reworded)?.id).toBe('provider.rate_limit')
-	})
-
-	it('takes the first matching rule, so a rule can be as specific as it likes', () => {
-		const ids = DEFAULT_ERROR_RULES.map((rule) => rule.id)
-		expect(ids.indexOf('provider.permission')).toBeLessThan(ids.indexOf('provider.auth'))
-	})
-})
-
-describe('a hint attached where the failure was raised', () => {
-	it('wins over a rule matched on a status code', () => {
-		// Code that raised the failure knows more about it than a generic
-		// rule ever will — a container that has not been built, a daemon
-		// that is not running.
-		const err = withHint(providerError('rate_limit', 429), 'the sandbox worker is not running')
-		const explanation = explainError(err)
-
-		expect(explanation?.id).toBe('hint.from_throw_site')
-		expect(explanation?.hint).toBe('the sandbox worker is not running')
-	})
-
-	it('survives being read back off a plain throwable', () => {
-		expect(readHint(withHint(new Error('boom'), 'check the socket path'))).toBe(
-			'check the socket path',
-		)
-	})
-
-	it('does not change the message or the type', () => {
-		// Baking remediation into the message is what made it impossible to
-		// separate again — a surface could not render one without the other.
-		const original = new NamzuError({ code: 'storage_error', message: 'write failed' })
-		const hinted = withHint(original, 'the run directory is not writable')
-
-		expect(hinted).toBe(original)
-		expect(hinted.message).toBe('write failed')
-		expect(hinted instanceof NamzuError).toBe(true)
-	})
-
-	it('is not enumerable, so it cannot leak into a serialized error', () => {
-		const err = withHint(new Error('boom'), 'a hint')
-		expect(Object.keys(err)).not.toContain('hint')
-	})
-
-	it('ignores an empty or non-string hint', () => {
-		expect(readHint(withHint(new Error('boom'), ''))).toBeUndefined()
-		expect(readHint({ hint: 42 })).toBeUndefined()
-		expect(readHint(null)).toBeUndefined()
-	})
-})
-
-describe('the facts a rule matches on', () => {
-	it('reads a provider classification', () => {
-		const facts = factsOf(providerError('rate_limit', 429))
-		expect(facts).toMatchObject({ code: 'rate_limit', status: 429 })
-	})
-
-	it('reads a namzu code', () => {
-		expect(factsOf(new NamzuError({ code: 'tool_error', message: 'x' })).code).toBe('tool_error')
-	})
-
-	it('still produces facts for something that was never an Error', () => {
-		expect(factsOf('just a string').message).toBe('just a string')
-	})
-})

package/src/types/errors/__tests__/errors.test.ts

@@ -1,118 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { ProviderError } from '../../provider/errors.js'
-import { NamzuError, isNamzuError, toPlatformError } from '../index.js'
-
-/**
- * `PlatformError` was declared and never constructed — a shape nothing
- * produced and nothing consumed — while the runtime threw bare `Error`
- * everywhere. A caller catching a failure from `query()` could not tell
- * "the model rate-limited us" from "the run was configured wrong" from
- * "that checkpoint does not exist". Matching on message text was the only
- * recourse, and message text is not an interface.
- */
-
-describe('NamzuError', () => {
-	it('is an Error, so code that only knows about Error still works', () => {
-		const err = new NamzuError({ code: 'invalid_config', message: 'no model' })
-		expect(err).toBeInstanceOf(Error)
-		expect(err.message).toBe('no model')
-		expect(err.stack).toBeDefined()
-	})
-
-	it('preserves the cause chain', () => {
-		const root = new Error('ENOENT')
-		const err = new NamzuError({ code: 'storage_error', message: 'write failed', cause: root })
-		expect(err.cause).toBe(root)
-	})
-
-	it('defaults `retryable` per code, and lets a caller override it', () => {
-		expect(new NamzuError({ code: 'invalid_config', message: 'x' }).retryable).toBe(false)
-		expect(new NamzuError({ code: 'storage_error', message: 'x' }).retryable).toBe(true)
-		expect(
-			new NamzuError({ code: 'invalid_config', message: 'x', retryable: true }).retryable,
-		).toBe(true)
-	})
-
-	it('narrows through `isNamzuError`', () => {
-		expect(isNamzuError(new NamzuError({ code: 'unknown', message: 'x' }))).toBe(true)
-		expect(isNamzuError(new Error('x'))).toBe(false)
-		expect(isNamzuError('x')).toBe(false)
-	})
-})
-
-describe('toPlatformError', () => {
-	it('gives a host ONE shape regardless of what was thrown', () => {
-		// Which is the entire point: without this, "handle errors from the
-		// SDK" means writing the same instanceof ladder in every caller.
-		for (const thrown of [
-			new NamzuError({ code: 'plugin_error', message: 'a' }),
-			new ProviderError({ code: 'rate_limit', message: 'b' }),
-			new Error('c'),
-			'not even an error',
-		]) {
-			const platform = toPlatformError(thrown)
-			expect(typeof platform.code).toBe('string')
-			expect(typeof platform.message).toBe('string')
-			expect(typeof platform.retryable).toBe('boolean')
-		}
-	})
-
-	it('carries a NamzuError through unchanged', () => {
-		const err = new NamzuError({
-			code: 'not_found',
-			message: 'Checkpoint not found: cp_1',
-			details: { checkpointId: 'cp_1' },
-		})
-		expect(toPlatformError(err)).toEqual({
-			code: 'not_found',
-			message: 'Checkpoint not found: cp_1',
-			details: { checkpointId: 'cp_1' },
-			retryable: false,
-		})
-	})
-
-	it('keeps a ProviderError`s classification instead of recomputing it', () => {
-		// The provider taxonomy already knows things this one does not —
-		// which status codes back off, what the server asked for.
-		const err = new ProviderError({
-			code: 'rate_limit',
-			message: 'slow down',
-			providerId: 'anthropic',
-			status: 429,
-			retryAfterMs: 3_000,
-		})
-
-		expect(toPlatformError(err)).toEqual({
-			code: 'provider_error',
-			message: 'slow down',
-			details: {
-				providerCode: 'rate_limit',
-				providerId: 'anthropic',
-				status: 429,
-				retryAfterMs: 3_000,
-			},
-			retryable: true,
-		})
-	})
-
-	it('does not claim a non-retryable provider failure is retryable', () => {
-		const err = new ProviderError({ code: 'auth', message: 'bad key' })
-		expect(toPlatformError(err).retryable).toBe(false)
-	})
-
-	it('reports a plain Error honestly as `unknown` rather than guessing', () => {
-		expect(toPlatformError(new Error('something broke'))).toEqual({
-			code: 'unknown',
-			message: 'something broke',
-			retryable: false,
-		})
-	})
-
-	it('does not lose a thrown non-Error', () => {
-		// Rare, and usually a bug elsewhere — but dropping it is worse than
-		// reporting it as-is.
-		expect(toPlatformError({ weird: true }).message).toBe('[object Object]')
-		expect(toPlatformError(undefined).message).toBe('undefined')
-	})
-})