vitest-plugin-vis 3.5.1 → 4.1.0

package/src/server/project.ts

@@ -1,13 +1,14 @@
-export function getProjectName(context: {
-	project: { vite: { config: { test?: { name?: { label: string } | string | undefined } } } }
-}) {
-	const name = context.project.vite.config.test?.name
+import type { ExtendedBrowserCommandContext } from './vis_server_context.types.ts'
+
+export function getProjectName(context: ExtendedBrowserCommandContext) {
+	const { runner } = context.project
+	const name = runner.config.name
 	if (typeof name === 'string') {
 		return name
 	}
-	if (typeof name === 'object' && 'label' in name) {
-		return name.label
-	}
+	// if (typeof name === 'object' && 'label' in name) {
+	// 	return (name as { label: string }).label
+	// }
 	return undefined
 }
 

package/src/server/snapshot.ts

@@ -1,13 +1,13 @@
 import { mkdirp } from 'mkdirp'
 import { dirname, resolve } from 'pathe'
-import type { BrowserCommandContext } from 'vitest/node'
 import { isBase64String } from '../shared/base64.ts'
 import type { ImageSnapshotTimeoutOptions, PageImageSnapshotOptions } from '../shared/types.ts'
 import { browserApi } from './browser_provider/browser_api.ts'
 import { snapshotWriter } from './snapshot_writer.ts'
+import type { ExtendedBrowserCommandContext } from './vis_server_context.types.ts'
 
 export async function takeSnapshot(
-	context: BrowserCommandContext,
+	context: ExtendedBrowserCommandContext,
 	projectRoot: string,
 	relativeFilePath: string,
 	subject: string,
@@ -21,7 +21,7 @@ export async function takeSnapshot(
 }
 
 export async function takeSnapshotByBrowser(
-	context: BrowserCommandContext,
+	context: ExtendedBrowserCommandContext,
 	projectRoot: string,
 	relativeFilePath: string,
 	subject: string,
@@ -36,7 +36,7 @@ export async function takeSnapshotByBrowser(
 }
 
 export async function takePageSnapshot(
-	context: BrowserCommandContext,
+	context: ExtendedBrowserCommandContext,
 	projectRoot: string,
 	relativeFilePath: string,
 	options: (PageImageSnapshotOptions & ImageSnapshotTimeoutOptions) | undefined,

package/src/server/snapshot_path.ts

@@ -3,19 +3,20 @@ import { platform } from 'node:process'
 import type { VisOptions } from '../config/types.ts'
 import { SNAPSHOT_ROOT_DIR } from '../shared/constants.ts'
 import { trimCommonFolder } from '../shared/trim_common_folder.ts'
-import type { PartialBrowserCommandContext } from './vis_server_context.types.ts'
+import type { ExtendedBrowserCommandContext } from './vis_server_context.types.ts'
 
-export function resolveSnapshotRootDir(browserCommandContext: PartialBrowserCommandContext, options: VisOptions) {
+export function resolveSnapshotRootDir(browserCommandContext: ExtendedBrowserCommandContext, options: VisOptions) {
 	if (!options.snapshotRootDir) return getSnapshotRootDir(SNAPSHOT_ROOT_DIR)
 	const snapshotRootDir = options.snapshotRootDir
 	if (typeof snapshotRootDir === 'string') return getSnapshotRootDir(snapshotRootDir)
+	const { config } = browserCommandContext.project.browser
 	return snapshotRootDir({
 		ci,
-		browserName: browserCommandContext.provider.browserName,
+		browserName: config.browser.name,
 		providerName: browserCommandContext.provider.name,
 		platform,
-		screenshotFailures: browserCommandContext.provider.options?.screenshotFailures,
-		screenshotDirectory: browserCommandContext.provider.options?.screenshotDirectory,
+		screenshotFailures: config.browser.screenshotFailures,
+		screenshotDirectory: config.browser.screenshotDirectory,
 	})
 }
 

package/src/server/suite.ts

@@ -1,12 +1,11 @@
 import { join, relative } from 'pathe'
-import type { UserConfig } from 'vitest/node'
 import type { VisOptions } from '../config/types.ts'
 import { BASELINE_DIR, DIFF_DIR, RESULT_DIR } from '../shared/constants.ts'
 import { getProjectName, getProjectRoot } from './project.ts'
 import { getSnapshotSubpath, resolveSnapshotRootDir } from './snapshot_path.ts'
 import { getVisOption } from './vis_options.ts'
 import { deps } from './vis_server_context.deps.ts'
-import type { PartialBrowserCommandContext, VisSuite, VisSuites } from './vis_server_context.types.ts'
+import type { ExtendedBrowserCommandContext, VisSuite, VisSuites } from './vis_server_context.types.ts'
 
 const suites: VisSuites = {}
 
@@ -15,7 +14,7 @@ const suites: VisSuites = {}
  * Test files include vitest test files and storybook story files.
  * It needs to make sure there is no race condition between the test files.
  */
-export async function setupSuite(browserContext: PartialBrowserCommandContext) {
+export async function setupSuite(browserContext: ExtendedBrowserCommandContext) {
 	const suiteId = getSuiteId(browserContext)
 	const visOptions = getVisOption(browserContext)
 
@@ -27,7 +26,7 @@ export async function setupSuite(browserContext: PartialBrowserCommandContext) {
 
 	const { taskSubpath, baselineDir, diffDir, resultDir, tasks } = createModule(
 		suite,
-		browserContext.testPath,
+		browserContext.testPath!,
 		visOptions,
 	)
 	suite.modules[taskSubpath] = { baselineDir, diffDir, resultDir, tasks }
@@ -48,19 +47,15 @@ export async function setupSuite(browserContext: PartialBrowserCommandContext) {
  * Suite ID also contains the project name to make it unique
  * across different projects.
  */
-export function getSuiteId(context: {
-	project: {
-		config: { root: string; name: string }
-		vite: { config: { test?: { name?: UserConfig['name'] | undefined } } }
-	}
-}) {
+export function getSuiteId(context: ExtendedBrowserCommandContext) {
 	return `${getProjectName(context)}/${context.project.config.name}`
 }
 
 async function createSuite(
-	browserContext: PartialBrowserCommandContext,
+	browserContext: ExtendedBrowserCommandContext,
 	visOptions: Pick<VisOptions, 'snapshotRootDir' | 'subject'>,
 ) {
+	// console.log('visOptions', visOptions)
 	const snapshotRootDir = resolveSnapshotRootDir(browserContext, visOptions)
 	const projectRoot = getProjectRoot(browserContext)
 
@@ -95,6 +90,6 @@ export function getTaskSubpath(state: VisSuite, testPath: string, options: Pick<
 	return getSnapshotSubpath(relative(state.projectRoot, testPath), options)
 }
 
-export function getSuite(context: PartialBrowserCommandContext) {
+export function getSuite(context: ExtendedBrowserCommandContext) {
 	return suites[getSuiteId(context)]!
 }

package/src/server/testing/stubBrowserCommandContext.ts

@@ -0,0 +1,16 @@
+import '@vitest/browser-playwright'
+import { stub } from 'type-plus'
+import type { ExtendedBrowserCommandContext } from '../vis_server_context.types.ts'
+
+export const stubBrowserCommandContext = stub.build<ExtendedBrowserCommandContext>({})
+
+export function createStubPartialBrowserCommandContext({ root, testPath }: { root: string; testPath: string }) {
+	return stub.build<ExtendedBrowserCommandContext>({
+		project: {
+			config: { root },
+			runner: { config: { name: 'subject' } },
+		} as any,
+		provider: {},
+		testPath,
+	})
+}

package/src/{testing → server/testing}/stubSuite.ts

@@ -1,13 +1,13 @@
 import { resolve } from 'pathe'
 import { requiredDeep, type RecursivePartial } from 'type-plus'
-import type { UserConfig } from 'vite'
-import type { BrowserCommandContext } from 'vitest/node'
+import type { TestUserConfig } from 'vitest/node'
+import type { ExtendedBrowserCommandContext } from '../vis_server_context.types.ts'
 import { stubBrowserCommandContext } from './stubBrowserCommandContext.ts'
 import { stubUserConfig } from './stubUserConfig.ts'
 
 export function stubSuite(
-	partialUserConfig: RecursivePartial<UserConfig> = {},
-	partialBrowserCommandContext: RecursivePartial<BrowserCommandContext> = {},
+	partialUserConfig: RecursivePartial<{ test?: { name?: TestUserConfig['name'] } }> = {},
+	partialBrowserCommandContext: RecursivePartial<ExtendedBrowserCommandContext> = {},
 ) {
 	const root = resolve(import.meta.dirname, '../..')
 	const userConfig = stubUserConfig({
@@ -15,15 +15,13 @@ export function stubSuite(
 		...partialUserConfig,
 	})
 	const browserCommandContext = stubBrowserCommandContext(
-		requiredDeep<RecursivePartial<BrowserCommandContext>>(
+		requiredDeep<RecursivePartial<ExtendedBrowserCommandContext>>(
 			{
 				project: {
 					config: { root },
-					vite: {
+					runner: {
 						config: {
-							test: {
-								name: partialUserConfig.test?.name,
-							},
+							name: partialUserConfig.test?.name as string | undefined,
 						},
 					},
 				},

package/src/server/testing/stubUserConfig.ts

@@ -0,0 +1,6 @@
+import { stub } from 'type-plus'
+import type { ViteUserConfig } from 'vitest/config'
+
+export const stubUserConfig = stub.build<ViteUserConfig>((stub) => ({
+	...stub,
+}))

package/src/server/vis_options.ts

@@ -1,26 +1,25 @@
-import type { UserConfig } from 'vitest/node'
+import type { TestUserConfig } from 'vitest/node'
 import type { VisOptions } from '../config/types.ts'
 import { assertSnapshotKeyWithoutDash } from '../shared/asserts.ts'
 import { getProjectName } from './project.ts'
+import type { ExtendedBrowserCommandContext } from './vis_server_context.types.ts'
 
 const DEFAULT_PROJECT_NAME = '__default'
 
 const visOptions: Record<string, VisOptions<any> | undefined> = {}
 
 export function setVisOption(
-	userConfig: { test?: { name?: UserConfig['name'] | undefined } | undefined },
+	userConfig: { test?: { name?: TestUserConfig['name'] | undefined } },
 	options: VisOptions<any> | undefined,
 ) {
 	assertSnapshotKeyWithoutDash(options?.snapshotKey)
 
 	const name = userConfig.test?.name
 	const id = typeof name === 'string' ? name : typeof name === 'object' ? name?.label : DEFAULT_PROJECT_NAME
-
 	visOptions[id] = options
 }
 
-export function getVisOption(context: { project: { vite: { config: { test?: { name?: UserConfig['name'] } } } } }) {
+export function getVisOption(context: ExtendedBrowserCommandContext) {
 	const id = getProjectName(context) ?? DEFAULT_PROJECT_NAME
-
 	return visOptions[id] ?? {}
 }

package/src/server/vis_server_context.logic.ts

@@ -1,15 +1,15 @@
 import { basename, join, resolve } from 'pathe'
 import { pick } from 'type-plus'
 import type { ImageSnapshotKeyOptions } from '../client-api.ts'
-import type { ImageSnapshotResult } from './commands/load_image_snapshot_results.ts'
+import type { ImageSnapshotResult } from '../shared/commands.types.ts'
 import { file } from './externals/file.ts'
 import { getSuite, getTaskSubpath } from './suite.ts'
 import { getVisOption } from './vis_options.ts'
-import type { PartialBrowserCommandContext } from './vis_server_context.types.ts'
+import type { ExtendedBrowserCommandContext } from './vis_server_context.types.ts'
 
 export function createVisServerContext() {
 	const context = {
-		async getSnapshotResults(browserContext: PartialBrowserCommandContext, taskId: string) {
+		async getSnapshotResults(browserContext: ExtendedBrowserCommandContext, taskId: string) {
 			const suiteInfo = await context.getSuiteInfo(browserContext, taskId)
 			const baselines = await file.glob(join(suiteInfo.projectRoot, suiteInfo.baselineDir, `${suiteInfo.taskId}-*.png`))
 			const results = await file.glob(join(suiteInfo.projectRoot, suiteInfo.resultDir, `${suiteInfo.taskId}-*.png`))
@@ -36,7 +36,7 @@ export function createVisServerContext() {
 			return r
 		},
 		async getSnapshotInfo(
-			browserContext: PartialBrowserCommandContext,
+			browserContext: ExtendedBrowserCommandContext,
 			taskId: string,
 			options?: ImageSnapshotKeyOptions,
 		) {
@@ -65,11 +65,11 @@ export function createVisServerContext() {
 			}
 		},
 
-		async getTaskCount(browserContext: PartialBrowserCommandContext, taskId: string) {
+		async getTaskCount(browserContext: ExtendedBrowserCommandContext, taskId: string) {
 			return (await context.getSuiteInfo(browserContext, taskId)).task.count
 		},
 		async hasImageSnapshot(
-			browserContext: PartialBrowserCommandContext,
+			browserContext: ExtendedBrowserCommandContext,
 			taskId: string,
 			snapshotKey: string | undefined,
 		) {
@@ -80,7 +80,7 @@ export function createVisServerContext() {
 			)
 		},
 		getSnapshotFilename(
-			browserContext: PartialBrowserCommandContext,
+			browserContext: ExtendedBrowserCommandContext,
 			info: { taskId: string; task: { count: number } },
 			snapshotKey: string | undefined,
 		) {
@@ -91,7 +91,7 @@ export function createVisServerContext() {
 			}
 			return `${info.taskId}-${info.task.count}.png`
 		},
-		async getSuiteInfo(browserContext: PartialBrowserCommandContext, taskId: string) {
+		async getSuiteInfo(browserContext: ExtendedBrowserCommandContext, taskId: string) {
 			const projectState = await getSuite(browserContext)
 			const visOptions = getVisOption(browserContext)
 			const moduleId = getTaskSubpath(projectState, browserContext.testPath, visOptions)

package/src/server/vis_server_context.types.ts

@@ -1,4 +1,6 @@
-import type { UserConfig } from 'vitest/node'
+import type { Merge } from 'type-plus'
+import type { BrowserCommandContext } from 'vitest/node'
+import type { Awaitable } from '../shared/types.ts'
 
 export type VisSuites = {
 	[projectPath: string]: Promise<VisSuite>
@@ -30,33 +32,36 @@ export type VisSuite = {
 	>
 }
 
-export type PartialBrowserCommandContext = {
-	project: {
-		config: {
-			name: string
-			root: string
-			snapshotOptions: {
-				updateSnapshot: 'all' | 'new' | 'none'
+export type ExtendedBrowserCommand<Payload extends unknown[] = [], ReturnValue = any> = (
+	context: ExtendedBrowserCommandContext,
+	...payload: Payload
+) => Awaitable<ReturnValue>
+
+export type ExtendedBrowserCommandContext = {
+	page: BrowserCommandContext['page']
+	browser: BrowserCommandContext['browser']
+	iframe: BrowserCommandContext['iframe']
+	testPath: NonNullable<BrowserCommandContext['testPath']>
+	provider: BrowserCommandContext['provider']
+	// project: BrowserCommandContext['project']
+	project: Merge<
+		BrowserCommandContext['project'],
+		{
+			browser: {
+				config: {
+					browser: {
+						name: string
+						screenshotFailures: boolean
+						screenshotDirectory: string
+					}
+				}
 			}
-			testTimeout: number
-			hookTimeout: number
-		}
-		vite: {
-			config: {
-				test?: {
-					name?: UserConfig['name'] | undefined
+			config: BrowserCommandContext['project']['config']
+			runner: {
+				config: {
+					name: string
 				}
 			}
 		}
-	}
-	provider: {
-		name: string
-		browserName?: string | undefined
-		options?: {
-			headless?: boolean | undefined
-			screenshotFailures?: boolean | undefined
-			screenshotDirectory?: string | undefined
-		}
-	}
-	testPath: string
+	>
 }

package/src/{client/setup → setup}/create_vis.ts

@@ -1,12 +1,9 @@
-import dedent from 'dedent'
-import { afterEach, beforeAll } from 'vitest'
-import type { SetupVisSuiteCommand } from '../../server/commands/setup_vis_suite.ts'
-import type { ComparisonMethod } from '../../shared/types.ts'
-import { extractAutoSnapshotOptions, setAutoSnapshotOptions } from '../auto_snapshot_options.ts'
-import { ctx } from '../ctx.ts'
-import { shouldTakeSnapshot } from '../should_take_snapshot.ts'
-import type { SnapshotMeta } from '../snapshot_meta.ts'
-import { toTaskId } from '../task_id.ts'
+import { afterEach, beforeAll, expect } from 'vitest'
+import { autoSnapshotMatcher } from '../client/suite/auto_snapshot_matcher.ts'
+import { setAutoSnapshotOptions } from '../client/task/auto_snapshot_options.ts'
+import type { SnapshotMeta } from '../client/task/snapshot_meta.ts'
+import type { SetupVisSuiteCommand } from '../shared/commands.types.ts'
+import type { ComparisonMethod, SetupVisOptions } from '../shared/types.ts'
 
 /**
  * Visual test configuration on the client side.
@@ -40,20 +37,7 @@ export type VisClientConfigurator<GM extends Record<string, any> | unknown = unk
 	 * })
 	 * ```
 	 */
-	setup(options?: {
-		auto?:
-			| boolean
-			| (<C extends ComparisonMethod, M extends Record<string, any> | unknown = unknown>(
-					options: SnapshotMeta<C> & M & GM,
-			  ) => Promise<boolean> | Promise<void> | boolean | void)
-			| Record<
-					string,
-					| boolean
-					| (<C extends ComparisonMethod, M extends Record<string, any> | unknown = unknown>(
-							options: SnapshotMeta<C> & M & GM,
-					  ) => Promise<boolean> | Promise<void> | boolean | void)
-			  >
-	}): void
+	setup(options?: SetupVisOptions<GM>): void
 	/**
 	 * @deprecated Use `vis.setup()` instead.
 	 */
@@ -122,106 +106,67 @@ export type VisClientConfigurator<GM extends Record<string, any> | unknown = unk
 }
 
 export function createVis<GM extends Record<string, any> | unknown = unknown>(commands: SetupVisSuiteCommand) {
-	let subject: string | undefined
+	const matcher = autoSnapshotMatcher(commands, expect)
 
 	const vis: VisClientConfigurator<GM> = {
 		setup(options) {
 			if (!options || options.auto === false) {
-				beforeAll(vis.beforeAll.setup)
+				beforeAll(matcher.setup)
 			} else {
 				beforeAll(async () => {
-					await vis.beforeAll.setup()
+					await matcher.setup()
 					setAutoSnapshotOptions(true)
 				})
 			}
 
 			if (typeof options?.auto === 'function') {
 				afterEach(
-					vis.afterEach.matchPerTheme({
+					matcher.createMatcher({
 						auto: options.auto,
 					}),
 				)
 			} else if (typeof options?.auto === 'object') {
-				afterEach(vis.afterEach.matchPerTheme(options.auto))
+				afterEach(matcher.createMatcher(options.auto))
 			} else {
-				afterEach(vis.afterEach.matchImageSnapshot)
+				afterEach(matcher.createMatcher({ async auto() {} }))
 			}
 		},
 		presets: {
 			enable() {
-				beforeAll(vis.beforeAll.setup)
-				afterEach(vis.afterEach.matchImageSnapshot)
+				beforeAll(matcher.setup)
+				afterEach(matcher.createMatcher({ async auto() {} }))
 			},
 			manual() {
-				beforeAll(vis.beforeAll.setup)
+				beforeAll(matcher.setup)
 			},
 			auto() {
 				beforeAll(async () => {
-					await vis.beforeAll.setup()
+					await matcher.setup()
 					setAutoSnapshotOptions(true)
 				})
-				afterEach(vis.afterEach.matchImageSnapshot)
+				afterEach(matcher.createMatcher({ async auto() {} }))
 			},
 			theme(themes) {
 				beforeAll(async () => {
-					await vis.beforeAll.setup()
+					await matcher.setup()
 					setAutoSnapshotOptions(true)
 				})
-				afterEach(vis.afterEach.matchPerTheme(themes))
+				afterEach(matcher.createMatcher(themes))
 			},
 		},
 		beforeAll: {
 			async setup() {
-				subject = (await commands.setupVisSuite()).subject
+				await matcher.setup()
 			},
 		},
 		afterEach: {
 			async matchImageSnapshot() {
-				return vis.afterEach.matchPerTheme({ async auto() {} })()
+				return matcher.createMatcher({ async auto() {} })()
 			},
 			matchPerTheme(themes) {
-				return async function matchImageSnapshot() {
-					const test = ctx.getCurrentTest()
-					if ((test?.result?.errors?.length ?? 0) > 0) return
-
-					const meta = extractAutoSnapshotOptions(test)
-					if (!shouldTakeSnapshot(meta)) return
-					const errors: Array<[string, Error]> = []
-					for (const themeId in themes) {
-						try {
-							await new Promise((a) => setTimeout(a, 10))
-							const theme = themes[themeId]
-							const r = typeof theme === 'function' ? await theme(meta! as any) : theme
-							if (r === false) continue
-							await test!.context.expect(getSubject(meta?.subject ?? subject)).toMatchImageSnapshot({
-								...meta,
-								snapshotKey: meta?.snapshotKey ?? themeId,
-							})
-						} catch (error) {
-							errors.push([themeId, error as Error])
-						}
-					}
-					if (errors.length > 0) {
-						if (errors.length === 1) throw errors[0]![1]
-						const taskId = toTaskId(test!)
-						throw new AggregateError(
-							errors,
-							dedent`Snapshot \`${taskId}\` mismatched
-
-						${errors
-							.map(([themeId, error]) => {
-								return `Theme \`${themeId}\` failed: ${error.message}`
-							})
-							.join('\n\n')}`,
-						)
-					}
-				}
+				return matcher.createMatcher(themes)
 			},
 		},
 	}
 	return vis
 }
-
-function getSubject(selectors: string | undefined) {
-	return selectors ? (document.querySelector(selectors) ?? document.body) : document.body
-}

package/src/setup/readme.md

@@ -0,0 +1,5 @@
+# setup
+
+Code in this directory is used to setup the plugin in `vitest.setup.ts`.
+
+The code is executed in a NodeJS main thread.

package/src/{client/setup → setup}/vis.ts

@@ -1,4 +1,4 @@
-import { commands } from '@vitest/browser/context'
+import { commands } from 'vitest/browser'
 import { createVis } from './create_vis.ts'
 
 /**

package/src/setup.ts

@@ -2,5 +2,5 @@
 import './client/expect/extend.ts'
 import './client/page/extend.ts'
 
-export * from './client/setup/create_vis.ts'
-export * from './client/setup/vis.ts'
+export * from './setup/create_vis.ts'
+export * from './setup/vis.ts'

package/src/shared/commands.types.ts

@@ -0,0 +1,71 @@
+import type { Pick } from 'type-plus'
+import type { VisOptions } from '../config/types.ts'
+import type { ImageSnapshotComparisonInfo, MatchImageSnapshotOptions } from './types.ts'
+
+export interface PrepareImageSnapshotComparisonCommand {
+	prepareImageSnapshotComparison: (
+		taskId: string,
+		subject: string,
+		options?: MatchImageSnapshotOptions | undefined,
+	) => Promise<ImageSnapshotComparisonInfo | undefined>
+}
+
+export interface PreparePageImageSnapshotComparisonCommand {
+	preparePageImageSnapshotComparison: (
+		taskId: string,
+		options?: MatchImageSnapshotOptions | undefined,
+	) => Promise<ImageSnapshotComparisonInfo | undefined>
+}
+
+export interface SetupVisSuiteCommand {
+	/**
+	 * Sets up the visual testing suite by cleaning up previous snapshot and diff output directories.
+	 * When this command is run for the first time,
+	 * it will remove the results and diffs directory of all suites.
+	 *
+	 * In subsequent runs, it will only remove the results and diffs directory of the current suite.
+	 */
+	setupVisSuite: () => Promise<
+		Pick<
+			VisOptions,
+			| 'comparisonMethod'
+			| 'diffOptions'
+			| 'failureThreshold'
+			| 'failureThresholdType'
+			| 'snapshotKey'
+			| 'subject'
+			| 'timeout'
+		>
+	>
+}
+
+export interface LoadImageSnapshotResultsCommand {
+	loadImageSnapshotResults(taskId: string): Promise<ImageSnapshotResult[]>
+}
+
+export interface ImageSnapshotResult {
+	filename: string
+	/**
+	 * The base64 encoded image of the baseline snapshot.
+	 */
+	baseline?: string | undefined
+	/**
+	 * The base64 encoded image of the result snapshot.
+	 */
+	result?: string | undefined
+	/**
+	 * The base64 encoded image of the diff snapshot.
+	 */
+	diff?: string | undefined
+}
+
+export interface HasImageSnapshotCommand {
+	hasImageSnapshot(taskId: string, snapshotKey: string | undefined): Promise<boolean>
+}
+
+export interface ImageSnapshotNextIndexCommand {
+	/**
+	 * Get the index of the snapshot image to be created.
+	 */
+	imageSnapshotNextIndex(taskId: string): Promise<number>
+}