@nan0web/ui 1.12.1 → 1.12.3

package/src/domain/app/SnapshotAuditor.js

@@ -1,12 +1,11 @@
 import { NaN0 } from '@nan0web/types'
-import { AuditorModel } from '@nan0web/inspect'
-import { progress, result, show } from '../../core/Intent.js'
+import { AuditorModel } from '@nan0web/inspect/domain/AuditorModel'
+
+import { result, show } from '../../core/Intent.js'
 
 /**
  * SnapshotAuditor — Zero-Hallucination Snapshot Validation (Model-as-Schema v2).
  * Parses snapshots without evaluating the app logic and detects artifacts.
- *
- * @extends {AuditorModel}
  */
 export class SnapshotAuditor extends AuditorModel {
 	static alias = 'audit'
@@ -24,7 +23,6 @@ export class SnapshotAuditor extends AuditorModel {
 		default: 'data',
 	}
 
-	/** @type {Object<string, string>} Messages for UI */
 	static UI = {
 		title: 'Snapshot Auditor',
 		description: 'Validates UI snapshots against hallucinations and localization leaks.',
@@ -36,6 +34,7 @@ export class SnapshotAuditor extends AuditorModel {
 		auditPassed: 'Audit passed: {file}',
 		auditFailed: 'Audit failed for {file}: {errors}',
 
+		errorDb: 'Database not provided to auditor',
 		errorGlitch: 'Filename "{filename}" has multiple consecutive separators (glitch detected).',
 		errorShort: 'Filename "{filename}" is too short.',
 		errorSyntax: 'Syntax Error: Failed to parse NaN0 file. {msg}',
@@ -56,7 +55,24 @@ export class SnapshotAuditor extends AuditorModel {
 	static ARTIFACTS = ['[object Object]', 'undefined', 'NaN']
 
 	/** @type {string[]} Words to ignore across all languages */
-	static EXEMPT_WORDS = ['true', 'false', 'value', 'max', 'min', 'step', 'open', 'first', 'what', 'how', 'start', 'code', 'successfully', 'enter', 'with', 'system']
+	static EXEMPT_WORDS = [
+		'true',
+		'false',
+		'value',
+		'max',
+		'min',
+		'step',
+		'open',
+		'first',
+		'what',
+		'how',
+		'start',
+		'code',
+		'successfully',
+		'enter',
+		'with',
+		'system',
+	]
 
 	/** @type {RegExp} Pattern for suspicious filenames */
 	static SUSPICIOUS_FILENAME = /__|--/
@@ -64,14 +80,24 @@ export class SnapshotAuditor extends AuditorModel {
 	/** @type {number} Minimum filename length */
 	static MIN_FILENAME_LENGTH = 3
 
+	/** @type {string[]} Directories to ignore during scanning */
+	static IGNORE_DIRS = ['node_modules', '.git', '.venv', '.datasets', 'dist', 'build', 'types']
+
+	/**
+	 * Checks if a directory or file should be ignored.
+	 * @param {string} name
+	 * @returns {boolean}
+	 */
+	static isIgnored(name) {
+		return name.startsWith('.') || SnapshotAuditor.IGNORE_DIRS.includes(name)
+	}
+
 	/**
 	 * @param {Partial<SnapshotAuditor> | Record<string, any>} [data={}]
-	 * @param {Partial<import('@nan0web/types').ModelOptions>} [options={}]
+	 * @param {Partial<import('@nan0web/ui').ModelAsAppOptions>} [options={}]
 	 */
 	constructor(data = {}, options = {}) {
 		super(data, options)
-		/** @type {import('@nan0web/types').ModelOptions} */
-		this.options = options
 		/** @type {string} Target directory to audit */ this.dir
 		/** @type {string} Directory to scan for dictionaries */ this.data
 	}
@@ -96,7 +122,7 @@ export class SnapshotAuditor extends AuditorModel {
 
 	/**
 	 * Scans data directories to build a word set for each language.
-	 * @param {any} fsDb FileSystem DB.
+	 * @param {import('@nan0web/db').DB} fsDb FileSystem DB.
 	 * @param {string} data
 	 * @returns {Promise<Record<string, Set<string>>>}
 	 */
@@ -104,106 +130,74 @@ export class SnapshotAuditor extends AuditorModel {
 		/** @type {Record<string, Set<string>>} */
 		const dicts = {}
 
-		let entries = []
 		try {
-			let entriesList;
-			try {
-				entriesList = await fsDb.listDir(data)
-			} catch (e) {
-				if (/** @type {any} */ (e).code === 'ENOENT' && !data.startsWith('../')) {
-					entriesList = await fsDb.listDir('../' + data)
-				} else {
-					throw e;
-				}
-			}
-			for (const e of entriesList) entries.push(e)
-		} catch (e) {
-			return dicts
-		}
-
-		for (const entry of entries) {
-			if (entry.stat.isDirectory && entry.name !== '_') {
-				const lang = entry.name
-				if (!dicts[lang]) dicts[lang] = new Set()
-
-				const scanLang = async (dirPath) => {
-					let files = []
-					try {
-						const entries = await fsDb.listDir(dirPath)
-						for (const f of entries) files.push(f)
-					} catch (e) {
-						return
+			// Find all language directories
+			const entries = await fsDb
+				.listDir(data)
+				.catch(async (e) => {
+					if (/** @type {any} */ (e).code === 'ENOENT' && !data.startsWith('../')) {
+						return await fsDb.listDir('../' + data)
 					}
-
-					for (const f of files) {
-						if (f.stat.isDirectory) {
-							await scanLang(f.path)
-						} else {
+					throw e
+				})
+				.catch(() => [])
+
+			for (const entry of entries) {
+				if (entry.stat.isDirectory && entry.name !== '_') {
+					const lang = entry.name
+					if (!dicts[lang]) dicts[lang] = new Set()
+
+					// Use browse for deep dictionary scanning
+					for await (const f of fsDb.browse(entry.path, { depth: Infinity })) {
+						if (SnapshotAuditor.isIgnored(f.name)) continue
+						if (f.isFile) {
 							try {
-								const _fsDb = /** @type {any} */ (fsDb)
-								const raw = _fsDb.FS ? await _fsDb.FS.loadTXT(_fsDb.location(f.path), '', true) : await fsDb.fetch(f.path)
+								const raw = await fsDb.fetch(f.path)
 								SnapshotAuditor.extractWords(raw, dicts[lang])
 							} catch (e) {}
 						}
 					}
 				}
-				await scanLang(entry.path)
 			}
+		} catch (e) {
+			// Ignore dictionary errors
 		}
 		return dicts
 	}
 
 	/**
 	 * Run the snapshot audit inside the target directory.
-	 * @returns {AsyncGenerator<import('@nan0web/ui').Intent, any, any>}
+	 * @returns {AsyncGenerator<import('@nan0web/ui').Intent, import('@nan0web/ui').ResultIntent, any>}
 	 */
 	async *run() {
-		const { t } = this.options
-		const snapshotsDir = this.dir || '.'
-
-		yield show(t(SnapshotAuditor.UI.starting, { dir: snapshotsDir }))
+		const { t } = this._
 
-		const files = []
+		yield show(t(SnapshotAuditor.UI.starting, { dir: this.dir }))
 
-		/** @type {import('@nan0web/db').DB} */
-		let fsDb = this.options.db
-		if (fsDb && fsDb.mounts && fsDb.mounts.has('')) {
-			fsDb = /** @type {import('@nan0web/db').DB} */ (fsDb.mounts.get(''))
-		}
+		const fsDb = this._.db
 
 		if (!fsDb) {
-			yield show('FS Database not provided to auditor', 'error')
+			yield show(t(SnapshotAuditor.UI.errorDb), 'error')
 			return result({ success: false })
 		}
 
-		const findSnapshots = async (dir) => {
-			try {
-				let entries;
-				try {
-					entries = await fsDb.listDir(dir)
-				} catch (e) {
-					if (/** @type {any} */ (e).code === 'ENOENT' && !dir.startsWith('../')) {
-						entries = await fsDb.listDir('../' + dir)
-					} else {
-						throw e;
-					}
-				}
-				for (const entry of entries) {
-					if (entry.stat.isDirectory) {
-						await findSnapshots(entry.path)
-					} else if (entry.name.endsWith('.nan0') || entry.name.endsWith('.txt')) {
-						files.push(entry.path)
-					}
+		const files = []
+		const snapshotsDir = '@app/' + (this.dir || 'snapshots/core')
+
+		// Use robust DB.browse for recursive snapshot detection
+		try {
+			for await (const entry of fsDb.browse(snapshotsDir, { depth: Infinity })) {
+				if (SnapshotAuditor.isIgnored(entry.name)) continue
+				if (entry.isFile && (entry.name.endsWith('.nan0') || entry.name.endsWith('.txt'))) {
+					files.push(entry.path)
 				}
-			} catch (e) {
-				console.error('Error reading dir:', dir, e)
 			}
+		} catch (e) {
+			// Directory might be missing
 		}
 
-		await findSnapshots(snapshotsDir)
-
 		if (files.length === 0) {
-			yield show(t(SnapshotAuditor.UI.noSnapshots, { dir: snapshotsDir }), 'error')
+			yield show(t(SnapshotAuditor.UI.noSnapshots, { dir: this.dir }), 'error')
 			return result({ success: false })
 		}
 
@@ -216,8 +210,7 @@ export class SnapshotAuditor extends AuditorModel {
 			const locale = segments[segments.indexOf('core') + 1] || 'uk'
 			const componentName = segments.pop() || ''
 
-			const _fsDb = /** @type {any} */ (fsDb)
-			const content = _fsDb.FS ? await _fsDb.FS.loadTXT(_fsDb.location(file), '', true) : await fsDb.fetch(file)
+			const content = await fsDb.fetch(file)
 			const textContent = typeof content === 'string' ? content : JSON.stringify(content)
 
 			return {
@@ -231,10 +224,13 @@ export class SnapshotAuditor extends AuditorModel {
 		let hasErrors = false
 
 		for (const { file, audit } of results) {
-			const displayFile = file.startsWith('../') ? file.slice(3) : file
+			const displayFile = file.startsWith('@app/') ? file.slice(5) : file
 			if (audit.score < 100) {
 				const errorMessages = audit.errors.join('; ')
-				yield show(t(SnapshotAuditor.UI.auditFailed, { file: displayFile, errors: errorMessages }), 'error')
+				yield show(
+					t(SnapshotAuditor.UI.auditFailed, { file: displayFile, errors: errorMessages }),
+					'error',
+				)
 				allErrors.push(...audit.errors.map((e) => ({ file: displayFile, error: e })))
 				hasErrors = true
 			} else {

package/src/domain/app/SnapshotRunner.js

@@ -36,7 +36,7 @@ export class SnapshotRunner extends Model {
 
 	/**
 	 * @param {Partial<SnapshotRunner> | Record<string, any>} [data={}]
-	 * @param {import('@nan0web/types').ModelOptions} [options={}]
+	 * @param {Partial<import('@nan0web/types').ModelOptions>} [options={}]
 	 */
 	constructor(data = {}, options = {}) {
 		super(data, options)

package/src/domain/app/UIApp.js

@@ -5,6 +5,11 @@ import GalleryCommand from './GalleryCommand.js'
 import ConfigApp from './ConfigApp.js'
 import { show, result } from '../../core/Intent.js'
 
+/**
+ * @property {string[]} _positionals
+ * @property {string} command Type of command to run
+ * @property {boolean} help Show help message
+ */
 export class UIApp extends ModelAsApp {
 	static command = {
 		type: 'string',
@@ -40,39 +45,25 @@ export class UIApp extends ModelAsApp {
 
 	/**
 	 * @param {Partial<UIApp> | Record<string, any>} [data={}]
-	 * @param {import('@nan0web/types').ModelOptions} [options={}]
+	 * @param {Partial<import('@nan0web/types').ModelOptions>} [options={}]
 	 */
 	constructor(data = {}, options = {}) {
 		super(data, options)
-		/** @type {string[]} */ this._positionals = []
-		/** @type {string} Type of command to run */ this.command
-		/** @type {boolean} Show help message */ this.help
 	}
 
 	async *run() {
 		const t = this._.t
-		if (this.help || this.command === 'help') {
-			yield show(t(UIApp.UI.helpText, undefined))
-			return result({})
-		}
+		const cmd = /** @type {any} */ (this).command
+		const help = /** @type {any} */ (this).help
 
-		const TargetCommand = UIApp.command.options.find((opt) =>
-			[opt.alias, opt.name].includes(this.command),
-		)
+		if (help) return yield* super.run()
 
-		if (!TargetCommand) {
-			yield show(t(UIApp.UI.unknownCommand, { command: this.command }), 'error')
+		if (!cmd || !(cmd instanceof ModelAsApp)) {
+			yield show(t(UIApp.UI.unknownCommand, { command: cmd }), 'error')
 			return result({ status: 'error' })
 		}
 
-		// Pass remaining positionals down to the target action
-		const nextData = resolvePositionalArgs(
-			/** @type {any} */ (TargetCommand),
-			this._positionals || [],
-			this
-		)
-		const intent = new TargetCommand(nextData, this._)
-		return yield* intent.run()
+		return yield* cmd.run()
 	}
 }
 

package/src/index.js

@@ -5,11 +5,12 @@ import StdOut from './StdOut.js'
 import View from './View/View.js'
 import RenderOptions from './View/RenderOptions.js'
 import FrameProps from './Frame/Props.js'
-import Model from './Model/index.js'
+import { Model } from '@nan0web/types'
+import Models from './Model/index.js'
 import Component from './Component/index.js'
 import App from './App/index.js'
 
-export { Frame, FrameProps, Locale, StdIn, StdOut, View, RenderOptions, Model, Component, App }
+export { Frame, FrameProps, Locale, StdIn, StdOut, View, RenderOptions, Model, Models, Component, App }
 export { format } from './format.js'
 export { default as Navigation } from './domain/Navigation.js'
 
@@ -24,6 +25,7 @@ export { default as UiMessage } from './core/Message/Message.js'
 export { default as UiStream } from './core/Stream.js'
 export { default as Error, CancelError } from './core/Error/index.js'
 export { default as UiAdapter } from './core/UiAdapter.js'
+export { resolvePositionalArgs } from './core/resolvePositionalArgs.js'
 
 // OLMUI Generator Engine
 /** @typedef {import('./core/Intent.js').LogLevel} LogLevel */

package/src/inspect.js

@@ -1,2 +1,3 @@
 export * from './testing/SnapshotRunner.js'
 export * from './testing/verifySnapshot.js'
+export { SnapshotAuditor } from './domain/app/SnapshotAuditor.js'

package/src/testing/SnapshotRunner.js

@@ -7,11 +7,12 @@ import DBFS from '@nan0web/db-fs'
  */
 export class SnapshotRunner {
 	static async generateAndAudit(options) {
+		/** @type {import('@nan0web/db').DB} */
 		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) {

package/src/testing/SpecRunner.js

@@ -35,6 +35,43 @@ export class SpecRunner extends ModelAsApp {
 		this.registry
 	}
 
+	/**
+	 * Convenience method to load a .nan0 file and run a specific scenario.
+	 * 
+	 * 💡 Note on Expectations:
+	 * You do NOT need to write manual assertions when using this method. 
+	 * The `for await (const _ of runner.run()) {}` loop drives the generator,
+	 * but ALL assertions are handled automatically inside `SpecAdapter.js`.
+	 * 
+	 * Whenever the App yields an intent (`ask`, `show`, `result`), `SpecAdapter`
+	 * intercepts it and compares it strictly against the next step in the `.nan0` file.
+	 * - If it matches, the test continues (and `$value` is injected back into the App).
+	 * - If it mismatches, it throws an `assert.fail()` which fails the Node.js test immediately.
+	 * - If the App finishes early, it throws an `unhandledSteps` error.
+	 * 
+	 * @param {string} fileDir The directory containing the file (e.g., import.meta.dirname)
+	 * @param {string} fileName The name of the .nan0 file
+	 * @param {string} scenarioName The name of the scenario to run
+	 * @param {Record<string, any>} registry The Model Class registry
+	 * @param {Partial<import('../index.js').ModelAsAppOptions>} [options={}] Additional runner context options
+	 * @throws {Error} If the scenario is missing or if expectations fail during execution
+	 */
+	static async executeFile(fileDir, fileName, scenarioName, registry, options = {}) {
+		const DB = (await import('@nan0web/db-fs')).DBFS
+		const db = new DB({ root: fileDir })
+		const doc = await db.loadDocument(fileName)
+		const scenarios = Array.isArray(doc) ? doc : [doc]
+		const scenario = scenarios.find((s) => s.name === scenarioName) || scenarios[0]
+
+		if (!scenario) throw new Error(`Scenario ${scenarioName} not found in ${fileName}`)
+		if (!scenario.story) throw new Error(`Scenario ${scenarioName} has no story array`)
+
+		const runner = new this({ stream: scenario.story, registry }, options)
+		for await (const _ of runner.run()) {
+			// Iterate completely
+		}
+	}
+
 	/**
 	 * @throws {Error}
 	 * @returns {AsyncGenerator<import('../core/Intent.js').Intent, import('../core/Intent.js').ResultIntent, any>}

package/types/Model/index.d.ts

@@ -1,4 +1,4 @@
-export default Model;
+export default Models;
 import User from './User/User.js';
 import { HeaderModel } from '../domain/HeaderModel.js';
 import { FooterModel } from '../domain/FooterModel.js';
@@ -26,7 +26,7 @@ import { TimelineModel } from '../domain/components/index.js';
 import { EmptyStateModel } from '../domain/components/index.js';
 import { BannerModel } from '../domain/components/index.js';
 import { ProfileDropdownModel } from '../domain/components/index.js';
-declare namespace Model {
+declare namespace Models {
     export { User };
     export { HeaderModel };
     export { FooterModel };

package/types/core/resolvePositionalArgs.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Resolves positional CLI arguments into named model fields.
+ *
+ * Scans a Model class for `static` field descriptors with `positional: true`.
+ * The order of positional fields follows the declaration order of static properties
+ * (guaranteed by JavaScript spec for non-integer keys).
+ *
+ * @example
+ * class MyModel {
+ *   static source = { help: 'Source path', default: '.', positional: true }
+ *   static target = { help: 'Target path', default: 'out', positional: true }
+ *   static quiet  = { help: 'Quiet mode', default: false, type: 'boolean' }
+ * }
+ *
+ * const data = resolvePositionalArgs(MyModel, ['src/', 'dist/'])
+ * // → { source: 'src/', target: 'dist/' }
+ *
+ * @param {typeof Model} ModelClass - The Model class with static field descriptors.
+ * @param {string[]} args - Positional arguments from the CLI (e.g., process.argv positionals).
+ * @param {Object} [existing={}] - Existing named options (take priority over positionals).
+ * @returns {Object} Merged data object with positional args resolved to named fields.
+ */
+export function resolvePositionalArgs(ModelClass: typeof Model, args?: string[], existing?: any): any;
+import { Model } from '@nan0web/types';

package/types/docs/README.md.d.ts

@@ -0,0 +1 @@
+export {};

package/types/domain/Content.d.ts

@@ -173,9 +173,9 @@ export class Content extends Model {
     };
     /**
      * @param {ContentData | string} [data={}]
-     * @param {import('@nan0web/types').ModelOptions} [options={}]
+     * @param {Partial<import('@nan0web/types').ModelOptions>} [options={}]
      */
-    constructor(data?: ContentData | string, options?: import("@nan0web/types").ModelOptions);
+    constructor(data?: ContentData | string, options?: Partial<import("@nan0web/types").ModelOptions>);
     /** @type {string|undefined} Content */ content: string | undefined;
     /** @type {Array<Content>|undefined} Children */ children: Array<Content> | undefined;
 }

package/types/domain/Document.d.ts

@@ -26,9 +26,9 @@ export class Document extends Model {
     /**
      *
      * @param {Partial<Document>} [data]
-     * @param {import('@nan0web/types').ModelOptions} [options]
+     * @param {Partial<import('@nan0web/types').ModelOptions>} [options]
      */
-    constructor(data?: Partial<Document>, options?: import("@nan0web/types").ModelOptions);
+    constructor(data?: Partial<Document>, options?: Partial<import("@nan0web/types").ModelOptions>);
     /** @type {string} Title */ title: string;
     /** @type {Array<Content>} Content */ content: Array<Content>;
     /** @type {Array<Content>} Layout configuration */ $content: Array<Content>;

package/types/domain/HeroModel.d.ts

@@ -32,9 +32,9 @@ export class HeroModel extends Model {
     };
     /**
      * @param {Partial<HeroModel | Record<string, any>>} [data={}]
-     * @param {import('@nan0web/types').ModelOptions} [options={}]
+     * @param {Partial<import('@nan0web/types').ModelOptions>} [options={}]
      */
-    constructor(data?: Partial<HeroModel | Record<string, any>>, options?: import("@nan0web/types").ModelOptions);
+    constructor(data?: Partial<HeroModel | Record<string, any>>, options?: Partial<import("@nan0web/types").ModelOptions>);
     /** @type {string} Top small badge text ior icon */ badge: string;
     /** @type {string} Hero heading */ title: string;
     /** @type {string} Hero secondary text */ subtitle: string;

package/types/domain/ModelAsApp.d.ts

@@ -1,23 +1,67 @@
-/** @typedef {import('@nan0web/types').ModelOptions & { adapter: InputAdapter }} ModelAsAppOptions */
+/**
+ * @typedef {Object} AppOptions
+ * @property {InputAdapter} adapter
+ * @property {string} parentPath
+ * @property {boolean} _isExplicit
+ */
+/** @typedef {import('@nan0web/types').ModelOptions & AppOptions} ModelAsAppOptions */
 /**
  * The model with a run generator.
+ * @property {boolean} help Show help
  */
 export class ModelAsApp extends Model {
+    static help: {
+        help: string;
+        default: boolean;
+    };
+    /**
+     * Execute the model programmatically without a UI adapter.
+     * @param {any} [data]
+     * @param {Partial<ModelAsAppOptions>} [options]
+     * @returns {Promise<any>}
+     */
+    static execute(data?: any, options?: Partial<ModelAsAppOptions>): Promise<any>;
     /**
      * @param {Partial<ModelAsApp> | Record<string, any>} [data={}]
      * @param {Partial<ModelAsAppOptions>} [options={}]
      */
     constructor(data?: Partial<ModelAsApp> | Record<string, any>, options?: Partial<ModelAsAppOptions>);
-    /** @returns {ModelAsAppOptions} */
-    get _(): ModelAsAppOptions;
+    /** @type {boolean} Show help */ help: boolean;
+    _: {
+        adapter: InputAdapter;
+        parentPath: string;
+        _isExplicit: boolean;
+        db: import("@nan0web/db").default | null | undefined;
+        plugins: Record<string, any>;
+        t: import("@nan0web/types/src/utils/TFunction").TFunction;
+    };
+    /**
+     * Instantiates a subcommand if the value matches one of the options.
+     * @param {string} key - Field name.
+     * @param {any} val - Current value (string, class, or instance).
+     * @param {any} [data={}] - Data to pass to the new instance.
+     * @returns {any} Instantiated subcommand or original value.
+     */
+    _instantiateSubCommand(key: string, val: any, data?: any): any;
+    /**
+     * Generate help text for the model
+     * @param {string} [parentPath]
+     * @returns {string}
+     */
+    generateHelp(parentPath?: string): string;
     /**
+     * Default execution generator.
+     * Automatically delegates to the first instantiated subcommand field.
+     *
      * @returns {AsyncGenerator<import('@nan0web/ui').Intent, import('@nan0web/ui').ResultIntent, any>}
      */
     run(): AsyncGenerator<import("@nan0web/ui").Intent, import("@nan0web/ui").ResultIntent, any>;
-    #private;
 }
-export type ModelAsAppOptions = import("@nan0web/types").ModelOptions & {
+export type AppOptions = {
     adapter: InputAdapter;
+    parentPath: string;
+    _isExplicit: boolean;
 };
+export type ModelAsAppOptions = import("@nan0web/types").ModelOptions & AppOptions;
 import { Model } from '@nan0web/types';
 import { InputAdapter } from '../core/InputAdapter.js';

package/types/domain/ModelAsApp.story.d.ts

@@ -0,0 +1 @@
+export {};

package/types/domain/app/GalleryCommand.d.ts

@@ -6,50 +6,19 @@ export class GalleryCommand extends ModelAsApp {
     static action: {
         type: string;
         help: string;
-        options: (typeof SnapshotAuditor | typeof GalleryRenderIntent)[];
-        default: string;
+        options: (typeof SnapshotAuditor | typeof GalleryRenderCommand)[];
+        default: typeof SnapshotAuditor;
         positional: boolean;
     };
     /**
      * @param {Partial<GalleryCommand> | Record<string, any>} [data={}]
-     * @param {import('@nan0web/types').ModelOptions} [options={}]
+     * @param {Partial<import('@nan0web/types').ModelOptions>} [options={}]
      */
-    constructor(data?: Partial<GalleryCommand> | Record<string, any>, options?: import("@nan0web/types").ModelOptions);
-    /** @type {string} */ action: string;
+    constructor(data?: Partial<GalleryCommand> | Record<string, any>, options?: Partial<import("@nan0web/types").ModelOptions>);
+    /** @type {typeof SnapshotAuditor | typeof GalleryRenderCommand} */ action: typeof SnapshotAuditor | typeof GalleryRenderCommand;
     /** @type {string[]} */ _positionals: string[];
-    run(): AsyncGenerator<import("../../core/Intent.js").ShowIntent | (import("../../core/Intent.js").AskIntent & {
-        $value?: any;
-        $success?: boolean;
-        $files?: Record<string, string>;
-        $message?: string;
-    }) | (import("../../core/Intent.js").ProgressIntent & {
-        $value?: any;
-        $success?: boolean;
-        $files?: Record<string, string>;
-        $message?: string;
-    }) | (import("../../core/Intent.js").LogIntent & {
-        $value?: any;
-        $success?: boolean;
-        $files?: Record<string, string>;
-        $message?: string;
-    }) | (import("../../core/Intent.js").RenderIntent & {
-        $value?: any;
-        $success?: boolean;
-        $files?: Record<string, string>;
-        $message?: string;
-    }) | (import("../../core/Intent.js").AgentIntent & {
-        $value?: any;
-        $success?: boolean;
-        $files?: Record<string, string>;
-        $message?: string;
-    }) | (import("../../core/Intent.js").ResultIntent & {
-        $value?: any;
-        $success?: boolean;
-        $files?: Record<string, string>;
-        $message?: string;
-    }), any, any>;
 }
 export default GalleryCommand;
 import { ModelAsApp } from '../ModelAsApp.js';
 import SnapshotAuditor from './SnapshotAuditor.js';
-import GalleryRenderIntent from './GalleryRenderIntent.js';
+import GalleryRenderCommand from './GalleryRenderCommand.js';