@nan0web/ui 1.10.0 → 1.12.0

package/src/test/ScenarioTest.js

@@ -0,0 +1,51 @@
+import { runGenerator } from '../core/GeneratorRunner.js'
+import OutputAdapter from '../core/OutputAdapter.js'
+import ScenarioAdapter from './ScenarioAdapter.js'
+
+/**
+ * Deterministic Scenario Test Runner.
+ * Orchestrates a model against a predefined scenario, mocking I/O immediately.
+ */
+export class ScenarioTest {
+	/**
+	 * Runs an application model with a specific set of answers.
+	 *
+	 * @param {typeof import('../domain/ModelAsApp.js').ModelAsApp} AppClass
+	 * @param {Array<{field: string, value: any, cancelled?: boolean}>} scenario
+	 * @param {any} [appData={}]
+	 * @returns {Promise<{ value: any, intents: any[], error?: Error | undefined }>}
+	 */
+	static async run(AppClass, scenario = [], appData = {}) {
+		const inputAdapter = new ScenarioAdapter(scenario)
+
+		const app = new AppClass(appData, { adapter: inputAdapter })
+
+		let value
+		let error
+
+		try {
+			// runGenerator executes the Intents returned by AppClass.run()
+			value = await runGenerator(
+				app.run(),
+				{
+					ask: inputAdapter.askIntent.bind(inputAdapter),
+					progress: inputAdapter.progressIntent.bind(inputAdapter),
+					show: inputAdapter.showIntent.bind(inputAdapter),
+					render: inputAdapter.renderIntent.bind(inputAdapter),
+					result: inputAdapter.resultIntent.bind(inputAdapter),
+				},
+				{ timeoutMs: 3333 },
+			)
+		} catch (err) {
+			error = /** @type {Error} */ (err)
+		}
+
+		return {
+			value,
+			intents: inputAdapter.intents,
+			error,
+		}
+	}
+}
+
+export default ScenarioTest

package/src/test/ScenarioTest.story.js

@@ -0,0 +1,56 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import DB from '@nan0web/db-fs'
+import { SpecRunner } from '../testing/index.js'
+import { ModelAsApp, ask, show, result } from '../index.js'
+
+const db = new DB({ root: 'tests/uk' })
+
+async function loadStory(name) {
+	const doc = await db.loadDocument(`${name}.nan0`)
+	return doc
+}
+
+describe('Workflow Story: Shopping Cart Purchase', () => {
+	class ShoppingCartApp extends ModelAsApp {
+		async *run() {
+			const { value: product } = yield ask('product', { help: 'Select product' })
+			if (product === 'laptop') {
+				yield show('Good choice!')
+			}
+			const { value: confirm } = yield ask('confirm', { help: 'Confirm purchase?' })
+			return result({ product: product, confirm: confirm })
+		}
+	}
+
+	it('should successfully buy a laptop and show a message via SpecRunner', async () => {
+		const doc = await loadStory('shopping.story')
+		assert.ok(Array.isArray(doc.story), 'Story must be an array')
+
+		await assert.doesNotReject(() => SpecRunner.execute(doc.story, { ShoppingCartApp }))
+	})
+})
+
+describe('Workflow Story: Validated Input Form', () => {
+	class ValidatedApp extends ModelAsApp {
+		async *run() {
+			const { value: code } = yield ask('code', { help: 'Enter code', required: true })
+			if (!code) throw new Error('Code is mandatory')
+			return result({ code: code })
+		}
+	}
+
+	it('should successfully process a valid code via SpecRunner', async () => {
+		const doc = await loadStory('validated.story')
+		assert.ok(Array.isArray(doc.story), 'Story must be an array')
+
+		await assert.doesNotReject(() => SpecRunner.execute(doc.story, { ValidatedApp }))
+	})
+
+	it('should fail if user provides empty input (Node.js Test)', async () => {
+		// Testing error conditions are better suited as explicit scenarios or node:test
+		const stream = [{ ValidatedApp: {} }, { ask: 'code', $value: '' }]
+
+		await assert.rejects(SpecRunner.execute(stream, { ValidatedApp }), /Code is mandatory/)
+	})
+})

package/src/testing/CrashReporter.js

@@ -0,0 +1,56 @@
+/**
+ * @file CrashReporter.js — Nan0Spec serialization.
+ */
+
+/**
+ * Transforms an execution trace from GeneratorRunner into a strict Nan0Spec model
+ * ready to be saved as a .nan0 file for Crash Reporting and Integration Tests.
+ *
+ * @param {string} appName The name of the root model/app (e.g. 'ShoppingCartApp').
+ * @param {object} appData The initial data provided to the app.
+ * @param {import('../core/Intent.js').Intent[]} trace The array of intents executed.
+ * @returns {Array<object>} The serializable Nan0Spec array.
+ */
+export function buildNan0SpecFromTrace(appName, appData, trace) {
+	const spec = []
+
+	// 1. Initial State
+	spec.push({
+		[appName]: appData ? JSON.parse(JSON.stringify(appData)) : {},
+	})
+
+	/** @type {Record<string, string>} Mapping from intent type to its primary payload field in Nan0Spec */
+	const PAYLOAD_MAP = {
+		ask: 'field',
+		show: 'message',
+		log: 'message',
+		progress: 'message',
+		render: 'component',
+		agent: 'task'
+	}
+
+	// 2. Map trace
+	for (const intent of trace) {
+		if (intent.type === 'result') {
+			spec.push({ result: intent.data || null })
+			continue
+		}
+
+		const key = PAYLOAD_MAP[intent.type]
+		if (!key) continue
+
+		// Create the primary step { type: payload }
+		const step = { [intent.type]: intent[key] }
+
+		// Automatically include all metadata/response fields (starting with $)
+		for (const [k, v] of Object.entries(intent)) {
+			if (k.startsWith('$') && v !== undefined) {
+				step[k] = v
+			}
+		}
+
+		spec.push(step)
+	}
+
+	return spec
+}

package/src/testing/GalleryGenerator.js

@@ -1,85 +1,29 @@
-import fs from 'fs'
 import path from 'path'
 import { fileURLToPath } from 'url'
-import yaml from 'js-yaml'
-import { LogicInspector } from './LogicInspector.js'
-import { VisualAdapter } from './VisualAdapter.js'
-import * as Models from '../domain/index.js'
+import { SnapshotRunner } from './SnapshotRunner.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const rootDir = path.resolve(__dirname, '../../')
 const dataDir = path.resolve(rootDir, 'docs/data')
 const snapshotsDir = path.resolve(rootDir, 'snapshots/core')
 
-// Clean before generation
-if (fs.existsSync(snapshotsDir)) fs.rmSync(snapshotsDir, { recursive: true, force: true })
-fs.mkdirSync(snapshotsDir, { recursive: true })
-
 const groups = {
-    Actions: ['Button', 'Toggle'],
-    Forms: ['Input', 'Select', 'Slider', 'Autocomplete', 'Color', 'Shadow'],
-    Data: ['Accordion', 'Card', 'Sortable', 'Table', 'Tree', 'CodeBlock', 'Markdown', 'Badge'],
-    Feedback: ['Alert', 'Confirm', 'Modal', 'ProgressBar', 'Spinner', 'Toast'],
-    System: ['LangSelect', 'ThemeToggle'],
+	Actions: ['Button', 'Toggle'],
+	Forms: ['Input', 'Select', 'Slider', 'Autocomplete', 'Color', 'Shadow'],
+	Data: ['Accordion', 'Card', 'Sortable', 'Table', 'Tree', 'CodeBlock', 'Markdown', 'Badge'],
+	Feedback: ['Alert', 'Confirm', 'Modal', 'ProgressBar', 'Spinner', 'Toast'],
+	System: ['LangSelect', 'ThemeToggle'],
 }
 
 function getCategory(comp) {
-    for (const [cat, comps] of Object.entries(groups)) {
-        if (comps.includes(comp)) return cat
-    }
-    return 'Other'
-}
-
-async function generate() {
-    const langs = fs.readdirSync(dataDir).filter(d => fs.statSync(path.join(dataDir, d)).isDirectory() && d !== '_')
-
-    for (const lang of langs) {
-        const langDir = path.join(dataDir, lang)
-        const components = fs.readdirSync(langDir).filter(f => f.endsWith('.yaml'))
-
-        for (const file of components) {
-            const compName = file.replace('.yaml', '')
-            const category = getCategory(compName)
-            const text = fs.readFileSync(path.join(langDir, file), 'utf-8')
-            const data = yaml.load(text)
-
-            // Variations are in data.content
-            const variations = data.content || []
-            
-            for (let i = 0; i < variations.length; i++) {
-                const varData = variations[i][compName] || variations[i]
-                
-                // Get variation name from 'content', 'title', 'message', or fallback to index
-                let varName = varData.content || varData.title || varData.message || `var${i + 1}`
-                if (typeof varName !== 'string') varName = `var${i + 1}`
-                
-                // Clean filename: allow Ukrainian, but replace spaces/special chars with single underscore
-                const safeVarName = varName
-                    .trim()
-                    .toLowerCase()
-                    .replace(/[./\\:]/g, '_') // Replace paths/dots
-                    .replace(/\s+/g, '_')      // Replace spaces
-                    .replace(/_{2,}/g, '_')   // No double underscores
-                    .slice(0, 50)              // Max length
-
-                // Logic Capture
-                /** @type {() => AsyncGenerator<import('../core/Intent.js').Intent, import('../core/Intent.js').ResultIntent, any>} */
-                const modelStream = async function* () {
-                    yield { type: 'render', component: `ui-${compName.toLowerCase()}`, props: varData }
-                    return { type: 'result', data: { ok: true } }
-                }
-
-                const intents = await LogicInspector.capture(modelStream())
-                const snapshot = intents.map(it => VisualAdapter.render(it)).join('\n')
-
-                const outPath = path.join(snapshotsDir, lang, category, compName)
-                if (!fs.existsSync(outPath)) fs.mkdirSync(outPath, { recursive: true })
-                
-                fs.writeFileSync(path.join(outPath, `${safeVarName}.txt`), snapshot)
-                console.log(`📸 Generated snapshot for ${lang}/${category}/${compName}/${safeVarName}`)
-            }
-        }
-    }
+	for (const [cat, comps] of Object.entries(groups)) {
+		if (comps.includes(comp)) return cat
+	}
+	return 'Other'
 }
 
-generate().catch(console.error)
+SnapshotRunner.generateAndAudit({
+	dataDir,
+	snapshotsDir,
+	getCategory,
+}).catch(console.error)

package/src/testing/LogicInspector.js

@@ -27,11 +27,11 @@ export class LogicInspector {
                 const value = resolvedInputs[inputIdx++]
                 const entry = { type: 'ask', field: i.field, schema: i.schema, input: value }
                 intents.push(entry)
-                return { value }
+                return { value, cancelled: false }
             },
-            /** @param {import('../core/Intent.js').LogIntent} i */
-            log: async (i) => {
-                intents.push({ type: 'log', level: i.level || 'info', message: i.message })
+            /** @param {import('../core/Intent.js').ShowIntent} i */
+            show: async (i) => {
+                intents.push({ type: 'show', level: i.level || 'info', message: i.message })
             },
             /** @param {import('../core/Intent.js').ProgressIntent} i */
             progress: async (i) => {

package/src/testing/SnapshotRunner.js

@@ -0,0 +1,22 @@
+import { SnapshotRunner as Runner } from '../domain/app/SnapshotRunner.js'
+import DBFS from '@nan0web/db-fs'
+
+/**
+ * Legacy bridge for SnapshotRunner.
+ * @deprecated Use SnapshotRunner model from domain/app
+ */
+export class SnapshotRunner {
+	static async generateAndAudit(options) {
+		const db = options.db || new DBFS({ root: options.dataDir })
+		const runner = new Runner(options, { db })
+		if (options.getCategory) runner.getCategory = options.getCategory
+		if (options.createModelStream) runner.createModelStream = options.createModelStream
+		
+		const gen = runner.run()
+		let res = await gen.next()
+		while (!res.done) {
+			res = await gen.next()
+		}
+		return res.value
+	}
+}

package/src/testing/SpecAdapter.js

@@ -0,0 +1,114 @@
+import assert from 'node:assert/strict'
+
+/**
+ * @typedef {Object} SpecAdapterOptions
+ * @property {typeof import('node:assert/strict')} [assert] Custom assertion library (falls back to node:assert in Node runtime)
+ */
+
+export class SpecAdapter {
+	/** @type {Array<object>} */
+	stream
+	/** @type {typeof import('node:assert/strict')} */
+	assert
+
+	/**
+	 * @param {Array<object>} stream The remaining nan0 array without the first element.
+	 * @param {SpecAdapterOptions} [options={}]
+	 */
+	constructor(stream, options = {}) {
+		this.stream = stream
+		this.assert = options.assert || assert
+	}
+
+	/**
+	 * Helper to get the next step and assert type match.
+	 * @param {string} intentType
+	 */
+	#popExpected(intentType) {
+		const step = this.stream.shift()
+		if (!step) {
+			this.assert.fail(`Model yielded '${intentType}' intent, but Nan0Spec stream is exhausted (no more steps expected).`)
+		}
+		if (!(intentType in step)) {
+			// Find what step type it actually is
+			const actualType = Object.keys(step).find(k => !k.startsWith('$'))
+			this.assert.fail(`Strict mismatch: Model yielded '${intentType}', but Nan0Spec stream expected '${actualType}'. Trace: ${JSON.stringify(step)}`)
+		}
+		return step
+	}
+
+	/**
+	 * @param {import('../core/Intent.js').AskIntent} intent
+	 */
+	async ask(intent) {
+		const step = this.#popExpected('ask')
+		this.assert.equal(step.ask, intent.field, `Field mismatch on ask. Expected '${step.ask}', got '${intent.field}'`)
+		return { value: step.$value, cancelled: false }
+	}
+
+	/**
+	 * @param {import('../core/Intent.js').ShowIntent} intent
+	 */
+	async show(intent) {
+		const step = this.#popExpected('show')
+		if (step.show && typeof step.show === 'string') {
+			const activeMessage = intent.message
+			if (activeMessage && step.show !== '*' && step.show !== '') {
+				this.assert.equal(activeMessage, step.show, `Show message mismatch`)
+			}
+		}
+	}
+
+	/**
+	 * @param {import('../core/Intent.js').LogIntent} intent
+	 */
+	async log(intent) {
+		const step = this.#popExpected('log')
+		if (step.log && typeof step.log === 'string') {
+			const activeMessage = intent.message
+			if (activeMessage && step.log !== '*' && step.log !== '') {
+				this.assert.equal(activeMessage, step.log, `Log message mismatch`)
+			}
+		}
+	}
+
+	/**
+	 * @param {import('../core/Intent.js').ProgressIntent} intent
+	 */
+	async progress(intent) {
+		this.#popExpected('progress')
+	}
+
+	/**
+	 * @param {import('../core/Intent.js').RenderIntent} intent
+	 */
+	async render(intent) {
+		const step = this.#popExpected('render')
+		const activeComponent = intent.component
+		this.assert.equal(activeComponent, step.render, `Render component mismatch. Expected '${step.render}'.`)
+	}
+
+	/**
+	 * @param {import('../core/Intent.js').AgentIntent} intent
+	 */
+	async agent(intent) {
+		const step = this.#popExpected('agent')
+		this.assert.equal(step.agent, intent.task, `Agent task mismatch. Expected '${step.agent}'.`)
+		
+		return { success: step.$success !== false, files: step.$files, message: step.$message }
+	}
+
+	/**
+	 * @param {import('../core/Intent.js').ResultIntent} intent
+	 */
+	async result(intent) {
+		// Only pop result if there's a result recorded in the spec stream
+		if (this.stream.length > 0 && typeof this.stream[0] === 'object' && 'result' in this.stream[0]) {
+			const step = this.#popExpected('result')
+			if (step.result !== undefined && step.result !== '*') {
+				const actualData = intent?.data ?? intent
+				this.assert.deepEqual(actualData, step.result, `Result object deep mismatch`)
+			}
+		}
+	}
+}

package/src/testing/SpecRunner.js

@@ -0,0 +1,121 @@
+import assert from 'node:assert/strict'
+import { runGenerator } from '../core/GeneratorRunner.js'
+import { ModelAsApp } from '../domain/ModelAsApp.js'
+import { result, progress } from '../core/Intent.js'
+import { SpecAdapter } from './SpecAdapter.js'
+
+export class SpecRunner extends ModelAsApp {
+	static stream = { help: 'The .nan0 intent stream array', default: [] }
+	static registry = { help: 'A registry of Model Classes that can be mounted', default: {} }
+	static UI = {
+		invalidStream: 'Invalid Nan0Spec: stream must be a non-empty array',
+		invalidFirstStep: 'Invalid Nan0Spec: first step missing or invalid',
+		missingAppName:
+			'Invalid Nan0Spec: first step must define the AppName key (e.g. ShoppingCartApp)',
+		appNotFound:
+			"SpecRunner: AppName '{app}' not found in provided registry. Did you forget to import it?",
+		invalidGenerator: "SpecRunner: Model '{app}' does not have a valid run() async generator",
+		running: 'Running {app}...',
+		unhandledSteps: 'Model finished execution, but stream still has {count} unhandled steps',
+	}
+
+	/** @type {typeof import('node:assert/strict')} */
+	#assert
+
+	/**
+	 * @param {Partial<SpecRunner>} [data={}]
+	 * @param {Partial<import('../index.js').ModelAsAppOptions> & { assert?: typeof import('node:assert/strict') }} [options={}]
+	 */
+	constructor(data = {}, options = {}) {
+		super(data, /** @type {import('../index.js').ModelAsAppOptions} */ (options))
+		this.#assert = options.assert || assert
+		/** @type {Array<object>} The Nan0Spec stream */
+		this.stream
+		/** @type {Record<string, any>} The registry of Model Classes */
+		this.registry
+	}
+
+	/**
+	 * @throws {Error}
+	 * @returns {AsyncGenerator<import('../core/Intent.js').Intent, import('../core/Intent.js').ResultIntent, any>}
+	 */
+	async *run() {
+		const { t } = this._
+		const stream = this.stream
+		const registry = this.registry
+
+		if (!Array.isArray(stream) || stream.length === 0) {
+			throw new Error(t(SpecRunner.UI.invalidStream))
+		}
+
+		// Clone the stream so we can shift without destroying the original reference
+		const localStream = [...stream]
+
+		const firstStep = localStream.shift()
+		if (!firstStep || typeof firstStep !== 'object') {
+			throw new Error(t(SpecRunner.UI.invalidFirstStep))
+		}
+
+		const appName = Object.keys(firstStep).find((k) => !k.startsWith('$'))
+		if (!appName) {
+			throw new Error(t(SpecRunner.UI.missingAppName))
+		}
+
+		const ModelClass = /** @type {any} */ (registry[appName])
+		if (!ModelClass) {
+			throw new Error(t(SpecRunner.UI.appNotFound, { app: appName }))
+		}
+
+		const appData = firstStep[appName] || {}
+		const adapter = new SpecAdapter(localStream, { assert: this.#assert })
+
+		// Create the model, passing our own context so it inherits translations etc
+		const model = new ModelClass(appData, this._)
+		const generator = typeof model.run === 'function' ? model.run() : null
+
+		if (!generator || typeof generator.next !== 'function') {
+			throw new Error(t(SpecRunner.UI.invalidGenerator, { app: appName }))
+		}
+
+		try {
+			yield progress(t(SpecRunner.UI.running, { app: appName }))
+			await runGenerator(generator, {
+				ask: adapter.ask.bind(adapter),
+				show: adapter.show.bind(adapter),
+				log: adapter.log.bind(adapter),
+				progress: adapter.progress.bind(adapter),
+				render: adapter.render.bind(adapter),
+				agent: adapter.agent.bind(adapter),
+				result: adapter.result.bind(adapter),
+			})
+		} catch (err) {
+			// Bubbling assertion errors correctly
+			throw err
+		}
+
+		// The stream must be fully consumed
+		if (localStream.length > 0) {
+			assert.fail(t(SpecRunner.UI.unhandledSteps, { count: localStream.length }))
+		}
+
+		return result({ success: true, appName })
+	}
+
+	/**
+	 * Run a Nan0Spec sequence programmatically (for unit tests).
+	 *
+	 * @param {Array<object>} stream The .nan0 intent stream array
+	 * @param {Record<string, any>} registry A registry of Model Classes that can be mounted
+	 * @param {typeof import('node:assert/strict')} [asserter] Custom assertion library
+	 */
+	static async execute(stream, registry, asserter = assert) {
+		const runner = new SpecRunner({ stream, registry }, { assert: asserter })
+		const it = runner.run()
+		while (true) {
+			const { value, done } = await it.next()
+			if (done) return value?.data
+		}
+	}
+}
+
+export default SpecRunner

package/src/testing/VisualAdapter.js

@@ -2,8 +2,9 @@
  * VisualAdapter (Base)
  * 
  * Базовий клас для візуальної трансформації інтенцій OLMUI.
- * Використовувана у @nan0web/ui як фундамент для спеціалізованих рендерерів.
  */
+import { NaN0 } from '@nan0web/types'
+
 export class VisualAdapter {
     /**
      * Конвертує одну інтенцію у просте текстове представлення.
@@ -12,30 +13,34 @@ export class VisualAdapter {
      * @returns {string} Raw description
      */
     static render(intent, t = (k) => k) {
+        let node;
         switch (intent.type) {
             case 'ask':
-                return `[ASK] ${intent.field}: ${intent.input !== undefined ? intent.input : '...'}`
+                node = { ask: { field: intent.field, input: intent.input !== undefined ? intent.input : '...' } }
+                break
             case 'progress':
-                return `[PROGRESS] ${intent.message || ''}`
+                node = { progress: { message: intent.message || '' } }
+                break
             case 'log':
-                return `[LOG ${intent.level?.toUpperCase() || 'INFO'}] ${typeof intent.message === 'object' ? JSON.stringify(intent.message) : intent.message}`
-            case 'render': {
-                const { content, ...propsData } = intent.props || {}
-                const props = Object.entries(propsData)
-                    .map(([k, v]) => `  ${k}="${typeof v === 'object' ? JSON.stringify(v) : v}"`)
-                    .join('\n')
-                
-                if (content) {
-                    const attrs = props ? `\n${props}\n` : ' '
-                    return `[RENDER] <${intent.component}${attrs}>${content}</${intent.component}>`
-                }
-                
-                return `[RENDER] <${intent.component}${props ? '\n' + props + '\n' : ''}>`
+                node = { log: { level: intent.level?.toUpperCase() || 'INFO', message: intent.message } }
+                break
+            case 'render':
+                node = { render: { [intent.component]: intent.props || {} } }
+                break
+            case 'result': {
+                const data = intent.data || {}
+                node = { result: (typeof data === 'object' && data !== null && Object.keys(data).length === 0) ? {} : data }
+                break
             }
-            case 'result':
-                return `[RESULT] ${JSON.stringify(intent.data)}`
             default:
-                return `[UNKNOWN: ${intent.type}] ${JSON.stringify(intent)}`
+                node = { [intent.type || 'unknown']: intent }
+                break
+        }
+        
+        try {
+            return NaN0.stringify([node]).trim()
+        } catch (e) {
+            return `- error: ${JSON.stringify(node)}`
         }
     }
 }

package/src/testing/index.js

@@ -1,3 +1,7 @@
 export * from './LogicInspector.js'
 export * from './VisualAdapter.js'
-export * from './SnapshotInspector.js'
+export * from '../domain/app/SnapshotAuditor.js'
+export * from './verifySnapshot.js'
+export { SpecRunner } from './SpecRunner.js'
+export { SpecAdapter } from './SpecAdapter.js'
+export * from './CrashReporter.js'

package/src/testing/verifySnapshot.js

@@ -0,0 +1,17 @@
+/**
+ * Saves a logical JSONL snapshot sequence
+ * @param {Object} options
+ * @param {string} options.name Snapshot file name (e.g. 'uk/ExploreCatalog.jsonl')
+ * @param {Array<Object>} options.data Array of intents to serialize
+ * @param {typeof import('node:fs/promises')} [options.fs] Injected filesystem
+ * @param {typeof import('node:path')} [options.path] Injected path module
+ */
+export async function verifySnapshot({ name, data, fs, path }) {
+	if (!fs) fs = await import('node:fs/promises')
+	if (!path) path = await import('node:path')
+
+	const outPath = path.resolve(process.cwd(), 'snapshots/jsonl', name)
+	await fs.mkdir(path.dirname(outPath), { recursive: true })
+	const content = data.map((i) => JSON.stringify(i)).join('\n')
+	await fs.writeFile(outPath, content + '\n')
+}

package/types/App/Command/DepsCommand.d.ts

@@ -1,8 +1,6 @@
 export class DepsCommand extends UiMessage {
     static Body: typeof DepsCommandBody;
     constructor(input?: {});
-    /** @type {DepsCommandBody} */
-    body: DepsCommandBody;
 }
 export default DepsCommand;
 import UiMessage from '../../core/Message/Message.js';