@tailor-platform/sdk 2.0.0-next.5 → 2.0.0-next.7

package/dist/vitest/index.mjs

@@ -1,9 +1,10 @@
-import { i as getRegisteredJob, t as TRIGGER_DEFAULT } from "../registry-BSbq6SPo.mjs";
+import { i as getRegisteredJob, t as START_DEFAULT } from "../registry-i7EdJ-D5.mjs";
 import { a as writeWorkflowTestEnv, n as clearWorkflowTestEnv, r as readWorkflowTestEnv, t as buildJobContext } from "../test-env-key-D7UkZp99.mjs";
 import { t as assertDefined } from "../assert-DBxo8jPo.mjs";
 import { t as platformSerialize } from "../platform-serialize-RoRtBS0v.mjs";
-import { i as withDispose, n as tailorRoot, r as tailordbRoot, t as mockSecretmanager } from "../secretmanager-Bd45j7an.mjs";
+import { i as withDispose, n as tailorRoot, r as tailordbRoot, t as mockSecretmanager } from "../secretmanager-IY4UvinW.mjs";
 import { builtinModules } from "node:module";
+import { isEqual } from "es-toolkit";
 import { fileURLToPath } from "node:url";
 import { dirname, isAbsolute, matchesGlob, relative, resolve } from "node:path";
 import { ColumnNode, InsertQueryNode, Kysely, PostgresAdapter, PostgresIntrospector, PostgresQueryCompiler, PrimitiveValueListNode, ReferenceNode, UpdateQueryNode, ValueListNode, ValueNode, ValuesNode } from "kysely";
@@ -297,27 +298,31 @@ function createEnvironmentPlugin(options) {
 //#region src/vitest/mocks/aigateway.ts
 /**
 * Acquire a disposable mock for `tailor.aigateway`. Restored on dispose.
+* @param options - Initial AI Gateway URL fixtures
 * @returns Disposable AI Gateway mock control object
 * @example
 * ```typescript
 * import { mockAigateway } from "@tailor-platform/sdk/vitest";
 *
 * test("resolves an AI Gateway URL", async () => {
-*   using aigateway = mockAigateway();
-*   aigateway.setUrls({ "my-aigateway": "https://my-aigateway.example.com" });
+*   using aigateway = mockAigateway({
+*     urls: { "my-aigateway": "https://my-aigateway.example.com" },
+*   });
+*   aigateway.setUrl("my-aigateway", "https://replacement.example.com");
 *   // …
 * });
 * ```
 */
-function mockAigateway() {
+function mockAigateway(options = {}) {
 	const root = tailorRoot();
 	const prev = root.aigateway;
-	let urls = {};
-	const get = vi.fn(async (name) => {
+	let urls = { ...options.urls };
+	async function defaultGet(name) {
 		const url = urls[name];
 		if (url === void 0) throw new Error(`No AI Gateway registered for "${name}". Acquire mockAigateway() and call setUrls(...).`);
 		return { url };
-	});
+	}
+	const get = vi.fn(defaultGet);
 	root.aigateway = { get };
 	return withDispose({
 		/** The `get` `vi.fn`. */
@@ -325,12 +330,22 @@ function mockAigateway() {
 		setUrls(value) {
 			urls = value;
 		},
+		setUrl(name, url) {
+			urls = {
+				...urls,
+				[name]: url
+			};
+		},
 		get calls() {
 			return get.mock.calls.map(([name]) => ({ name }));
 		},
+		clear() {
+			get.mockClear();
+		},
 		reset() {
 			urls = {};
-			get.mockClear();
+			get.mockReset();
+			get.mockImplementation(defaultGet);
 		}
 	}, () => {
 		root.aigateway = prev;
@@ -341,23 +356,30 @@ function mockAigateway() {
 //#region src/vitest/mocks/authconnection.ts
 /**
 * Acquire a disposable mock for `tailor.authconnection`. Restored on dispose.
+* @param options - Initial token fixtures and fallback behavior
 * @returns Disposable AuthConnection mock control object
 * @example
 * ```typescript
 * import { mockAuthconnection } from "@tailor-platform/sdk/vitest";
 *
 * test("returns configured token", async () => {
-*   using ac = mockAuthconnection();
-*   ac.setTokens({ google: { access_token: "ya29.xxx" } });
+*   using ac = mockAuthconnection({ tokens: { google: { access_token: "ya29.xxx" } } });
+*   ac.setToken("google", { access_token: "replacement" });
 *   // …
 * });
 * ```
 */
-function mockAuthconnection() {
+function mockAuthconnection(options = {}) {
 	const root = tailorRoot();
 	const prev = root.authconnection;
-	let tokens = {};
-	const getConnectionToken = vi.fn(async (connectionName) => tokens[connectionName] ?? { access_token: "mock-token" });
+	let tokens = { ...options.tokens };
+	async function defaultGetConnectionToken(connectionName) {
+		const token = tokens[connectionName];
+		if (token) return token;
+		if (options.onUnhandled === "error") throw new Error(`No AuthConnection token configured for "${connectionName}"`);
+		return { access_token: "mock-token" };
+	}
+	const getConnectionToken = vi.fn(defaultGetConnectionToken);
 	root.authconnection = { getConnectionToken };
 	return withDispose({
 		/** The `getConnectionToken` `vi.fn`. */
@@ -365,12 +387,22 @@ function mockAuthconnection() {
 		setTokens(value) {
 			tokens = value;
 		},
+		setToken(connectionName, token) {
+			tokens = {
+				...tokens,
+				[connectionName]: token
+			};
+		},
 		get calls() {
 			return getConnectionToken.mock.calls.map(([connectionName]) => ({ connectionName }));
 		},
+		clear() {
+			getConnectionToken.mockClear();
+		},
 		reset() {
 			tokens = {};
-			getConnectionToken.mockClear();
+			getConnectionToken.mockReset();
+			getConnectionToken.mockImplementation(defaultGetConnectionToken);
 		}
 	}, () => {
 		root.authconnection = prev;
@@ -379,6 +411,15 @@ function mockAuthconnection() {
 
 //#endregion
 //#region src/vitest/mocks/file.ts
+const FILE_METHODS = [
+	"upload",
+	"download",
+	"downloadAsBase64",
+	"delete",
+	"getMetadata",
+	"downloadStream",
+	"uploadStream"
+];
 const FILE_DEFAULTS = {
 	upload: { metadata: {
 		fileSize: 0,
@@ -402,7 +443,6 @@ const FILE_DEFAULTS = {
 			lastUploadedAt: ""
 		}
 	},
-	delete: void 0,
 	getMetadata: {
 		contentType: "",
 		fileSize: 0,
@@ -417,6 +457,7 @@ const FILE_DEFAULTS = {
 };
 /**
 * Acquire a disposable mock for `tailordb.file`. Restored on dispose.
+* @param options - Controls behavior for calls without a configured result
 * @returns Disposable File mock control object
 * @example
 * ```typescript
@@ -424,74 +465,102 @@ const FILE_DEFAULTS = {
 *
 * test("mock file download", async () => {
 *   using file = mockFile();
-*   file.enqueueResult({ data: new Uint8Array([1, 2, 3]), metadata: { ... } });
+*   file.download.mockResolvedValue({ data: new Uint8Array(), metadata: { ... } });
 *   // …
 * });
 * ```
 */
-function mockFile() {
+function mockFile(options = {}) {
 	const root = tailordbRoot();
 	const prev = root.file;
+	const { onUnhandled = "fallback" } = options;
 	const queue = [];
-	let resolver = () => null;
 	const calls = [];
+	let resolver = () => null;
 	function handle(method, namespace, typeName, fieldName, recordId) {
-		const call = {
+		if (queue.length > 0) return queue.shift();
+		const resolved = resolver(method, {
 			method,
 			namespace,
 			typeName,
 			fieldName,
 			recordId
-		};
-		calls.push(call);
-		if (queue.length > 0) return queue.shift();
-		const resolved = resolver(method, call);
+		});
 		if (resolved != null) return resolved;
+		if (onUnhandled === "error") throw new Error(`No File mock configured for "${method}"`);
 		const fallback = FILE_DEFAULTS[method];
 		return fallback === void 0 ? void 0 : structuredClone(fallback);
 	}
+	const upload = vi.fn(async (...args) => {
+		const [namespace, typeName, fieldName, recordId] = args;
+		return handle("upload", namespace, typeName, fieldName, recordId);
+	});
+	const download = vi.fn(async (...args) => handle("download", ...args));
+	const downloadAsBase64 = vi.fn(async (...args) => handle("downloadAsBase64", ...args));
+	const deleteFile = vi.fn(async (...args) => {
+		handle("delete", ...args);
+	});
+	const getMetadata = vi.fn(async (...args) => handle("getMetadata", ...args));
+	const downloadStream = vi.fn(async (...args) => {
+		const resolved = handle("downloadStream", ...args);
+		if (resolved != null) return resolved;
+		return {
+			body: new ReadableStream({ start(controller) {
+				controller.close();
+			} }),
+			metadata: {
+				contentType: "",
+				fileSize: 0,
+				sha256sum: "",
+				lastUploadedAt: ""
+			}
+		};
+	});
+	const uploadStream = vi.fn(async (...args) => {
+		const [namespace, typeName, fieldName, recordId] = args;
+		return handle("uploadStream", namespace, typeName, fieldName, recordId);
+	});
+	const mocks = {
+		upload,
+		download,
+		downloadAsBase64,
+		delete: deleteFile,
+		getMetadata,
+		downloadStream,
+		uploadStream
+	};
+	function track(method, operation) {
+		return function(...args) {
+			calls.push({
+				method,
+				namespace: args[0],
+				typeName: args[1],
+				fieldName: args[2],
+				recordId: args[3]
+			});
+			return operation.apply(this, args);
+		};
+	}
 	root.file = {
-		async upload(namespace, typeName, fieldName, recordId) {
-			return handle("upload", namespace, typeName, fieldName, recordId);
-		},
-		async download(namespace, typeName, fieldName, recordId) {
-			return handle("download", namespace, typeName, fieldName, recordId);
-		},
-		async downloadAsBase64(namespace, typeName, fieldName, recordId) {
-			return handle("downloadAsBase64", namespace, typeName, fieldName, recordId);
-		},
-		async delete(namespace, typeName, fieldName, recordId) {
-			handle("delete", namespace, typeName, fieldName, recordId);
-		},
-		async getMetadata(namespace, typeName, fieldName, recordId) {
-			return handle("getMetadata", namespace, typeName, fieldName, recordId);
-		},
-		async downloadStream(namespace, typeName, fieldName, recordId) {
-			const resolved = handle("downloadStream", namespace, typeName, fieldName, recordId);
-			if (resolved != null) return resolved;
-			return {
-				body: new ReadableStream({ start(c) {
-					c.close();
-				} }),
-				metadata: {
-					contentType: "",
-					fileSize: 0,
-					sha256sum: "",
-					lastUploadedAt: ""
-				}
-			};
-		},
-		async uploadStream(namespace, typeName, fieldName, recordId) {
-			return handle("uploadStream", namespace, typeName, fieldName, recordId);
-		}
+		upload: track("upload", upload),
+		download: track("download", download),
+		downloadAsBase64: track("downloadAsBase64", downloadAsBase64),
+		delete: track("delete", deleteFile),
+		getMetadata: track("getMetadata", getMetadata),
+		downloadStream: track("downloadStream", downloadStream),
+		uploadStream: track("uploadStream", uploadStream)
 	};
+	function allMocks() {
+		return FILE_METHODS.map((method) => mocks[method]);
+	}
 	return withDispose({
+		...mocks,
 		setResolver(value) {
 			resolver = value;
 		},
 		/**
-		* Enqueue a single result for the next `tailordb.file` call (FIFO; falls
-		* back to `setResolver` when exhausted).
+		* Enqueue a single result for the next `tailordb.file` call.
+		* The queue is shared across all methods and namespaces.
 		* @param result - Result to return from the next file call
 		*/
 		enqueueResult(result) {
@@ -499,6 +568,7 @@ function mockFile() {
 		},
 		/**
 		* Enqueue results for multiple subsequent `tailordb.file` calls.
+		* The queue is shared across all methods and namespaces.
 		* @param results - Results to enqueue, one per upcoming call
 		*/
 		enqueueResults(...results) {
@@ -507,10 +577,15 @@ function mockFile() {
 		get calls() {
 			return calls;
 		},
+		clear() {
+			calls.length = 0;
+			for (const mock of allMocks()) mock.mockClear();
+		},
 		reset() {
 			queue.length = 0;
-			resolver = () => null;
 			calls.length = 0;
+			resolver = () => null;
+			for (const mock of allMocks()) mock.mockReset();
 		}
 	}, () => {
 		root.file = prev;
@@ -529,11 +604,11 @@ function defaultIconvResult(method, args) {
 		case "decode": return "";
 		case "encode": return isUtf8(args[1]) ? "" : /* @__PURE__ */ new Uint8Array();
 		case "encodings": return [];
-		default: return;
 	}
 }
 /**
 * Acquire a disposable mock for `tailor.iconv`. Restored on dispose.
+* @param options - Fallback behavior for unconfigured operations
 * @returns Disposable Iconv mock control object
 * @example
 * ```typescript
@@ -541,27 +616,66 @@ function defaultIconvResult(method, args) {
 *
 * test("mock encoding conversion", () => {
 *   using iconv = mockIconv();
-*   iconv.setResolver((method) => (method === "decode" ? "decoded-text" : null));
+*   iconv.decode.mockReturnValue("decoded-text");
 *   // …
 * });
 * ```
 */
-function mockIconv() {
+function mockIconv(options = {}) {
 	const root = tailorRoot();
 	const prev = root.iconv;
 	let resolver = null;
 	const calls = [];
-	function handle(method, args) {
-		calls.push({
-			method,
-			args: [...args]
-		});
+	function resolve(method, args) {
 		if (resolver) {
 			const result = resolver(method, args);
 			if (result != null) return result;
 		}
+		if (options.onUnhandled === "error") throw new Error(`No Iconv mock behavior configured for "${method}"`);
 		return defaultIconvResult(method, args);
 	}
+	function defaultConvert(input, fromEncoding, toEncoding) {
+		return resolve("convert", [
+			input,
+			fromEncoding,
+			toEncoding
+		]);
+	}
+	function defaultConvertBuffer(input, fromEncoding, toEncoding) {
+		return resolve("convertBuffer", [
+			input,
+			fromEncoding,
+			toEncoding
+		]);
+	}
+	function defaultDecode(input, encoding) {
+		return resolve("decode", [input, encoding]);
+	}
+	function defaultEncode(input, encoding) {
+		return resolve("encode", [input, encoding]);
+	}
+	function defaultEncodings() {
+		return resolve("encodings", []);
+	}
+	const convert = vi.fn(defaultConvert);
+	const convertBuffer = vi.fn(defaultConvertBuffer);
+	const decode = vi.fn(defaultDecode);
+	const encode = vi.fn(defaultEncode);
+	const encodings = vi.fn(defaultEncodings);
+	function track(method, operation) {
+		return function(...args) {
+			calls.push({
+				method,
+				args: [...args]
+			});
+			return operation.apply(this, args);
+		};
+	}
+	const trackedConvert = track("convert", convert);
+	const trackedConvertBuffer = track("convertBuffer", convertBuffer);
+	const trackedDecode = track("decode", decode);
+	const trackedEncode = track("encode", encode);
+	const trackedEncodings = track("encodings", encodings);
 	class MockIconv {
 		#fromEncoding;
 		#toEncoding;
@@ -570,39 +684,56 @@ function mockIconv() {
 			this.#toEncoding = toEncoding;
 		}
 		convert(input) {
-			return handle("convert", [
-				input,
-				this.#fromEncoding,
-				this.#toEncoding
-			]);
+			return trackedConvert.call(this, input, this.#fromEncoding, this.#toEncoding);
 		}
 	}
 	root.iconv = {
-		convert: (str, from, to) => handle("convert", [
-			str,
-			from,
-			to
-		]),
-		convertBuffer: (buf, from, to) => handle("convertBuffer", [
-			buf,
-			from,
-			to
-		]),
-		decode: (buf, encoding) => handle("decode", [buf, encoding]),
-		encode: (str, encoding) => handle("encode", [str, encoding]),
-		encodings: () => handle("encodings", []),
+		convert: trackedConvert,
+		convertBuffer: trackedConvertBuffer,
+		decode: trackedDecode,
+		encode: trackedEncode,
+		encodings: trackedEncodings,
 		Iconv: MockIconv
 	};
+	function clear() {
+		calls.length = 0;
+		convert.mockClear();
+		convertBuffer.mockClear();
+		decode.mockClear();
+		encode.mockClear();
+		encodings.mockClear();
+	}
 	return withDispose({
+		/** The `convert` `vi.fn`. */
+		convert,
+		/** The `convertBuffer` `vi.fn`. */
+		convertBuffer,
+		/** The `decode` `vi.fn`. */
+		decode,
+		/** The `encode` `vi.fn`. */
+		encode,
+		/** The `encodings` `vi.fn`. */
+		encodings,
 		setResolver(value) {
 			resolver = value;
 		},
 		get calls() {
 			return calls;
 		},
+		clear,
 		reset() {
 			resolver = null;
 			calls.length = 0;
+			convert.mockReset();
+			convert.mockImplementation(defaultConvert);
+			convertBuffer.mockReset();
+			convertBuffer.mockImplementation(defaultConvertBuffer);
+			decode.mockReset();
+			decode.mockImplementation(defaultDecode);
+			encode.mockReset();
+			encode.mockImplementation(defaultEncode);
+			encodings.mockReset();
+			encodings.mockImplementation(defaultEncodings);
 		}
 	}, () => {
 		root.iconv = prev;
@@ -611,99 +742,131 @@ function mockIconv() {
 
 //#endregion
 //#region src/vitest/mocks/idp.ts
+const IDP_METHODS = [
+	"users",
+	"user",
+	"userByName",
+	"createUser",
+	"updateUser",
+	"deleteUser",
+	"sendPasswordResetEmail",
+	"unenrollMfa"
+];
+const IDP_USER_DEFAULT = {
+	id: "mock-id",
+	name: "mock-user",
+	disabled: false,
+	mfaEnrolled: false,
+	mfaFactorIds: []
+};
 const IDP_DEFAULTS = {
 	users: {
 		users: [],
 		nextPageToken: null,
 		totalCount: 0
 	},
-	user: {
-		id: "mock-id",
-		name: "mock-user",
-		disabled: false,
-		mfaEnrolled: false,
-		mfaFactorIds: []
-	},
-	userByName: {
-		id: "mock-id",
-		name: "mock-user",
-		disabled: false,
-		mfaEnrolled: false,
-		mfaFactorIds: []
-	},
-	createUser: {
-		id: "mock-id",
-		name: "mock-user",
-		disabled: false,
-		mfaEnrolled: false,
-		mfaFactorIds: []
-	},
-	updateUser: {
-		id: "mock-id",
-		name: "mock-user",
-		disabled: false,
-		mfaEnrolled: false,
-		mfaFactorIds: []
-	},
+	user: IDP_USER_DEFAULT,
+	userByName: IDP_USER_DEFAULT,
+	createUser: IDP_USER_DEFAULT,
+	updateUser: IDP_USER_DEFAULT,
 	deleteUser: true,
 	sendPasswordResetEmail: true,
 	unenrollMfa: true
 };
 /**
 * Acquire a disposable mock for `tailor.idp`. Restored on dispose.
+* @param options - Controls behavior for calls without a configured result
 * @returns Disposable IDP mock control object
 * @example
 * ```typescript
 * import { mockIdp } from "@tailor-platform/sdk/vitest";
 *
-* test("resolver-based", async () => {
+* test("returns a user", async () => {
 *   using idp = mockIdp();
-*   idp.setResolver((method) =>
-*     method === "user" ? { id: "u-1", name: "alice", disabled: false } : null,
-*   );
+*   idp.namespace("my-idp").user.mockResolvedValue({
+*     id: "u-1",
+*     name: "alice",
+*     disabled: false,
+*     mfaEnrolled: false,
+*     mfaFactorIds: [],
+*   });
 *   // …
 * });
 * ```
 */
-function mockIdp() {
+function mockIdp(options = {}) {
 	const root = tailorRoot();
 	const prev = root.idp;
+	const { onUnhandled = "fallback" } = options;
 	const queue = [];
-	let resolver = () => null;
 	const calls = [];
+	let resolver = () => null;
+	const namespaces = /* @__PURE__ */ new Map();
+	function compatibilityArgs(method, args) {
+		return method === "users" && args.length === 0 ? [void 0] : args;
+	}
 	function handle(method, args, namespace) {
-		calls.push({
-			method,
-			args,
-			namespace
-		});
 		if (queue.length > 0) return queue.shift();
-		const resolved = resolver(method, args, namespace);
+		const resolved = resolver(method, compatibilityArgs(method, args), namespace);
 		if (resolved != null) return resolved;
-		const fallback = IDP_DEFAULTS[method];
-		return fallback === void 0 ? void 0 : structuredClone(fallback);
+		if (onUnhandled === "error") throw new Error(`No IdP mock configured for "${namespace}.${method}"`);
+		return structuredClone(IDP_DEFAULTS[method]);
 	}
-	const Client = vi.fn(function(config) {
-		const namespace = config.namespace;
-		this.users = async (options) => handle("users", [options], namespace);
-		this.user = async (userId) => handle("user", [userId], namespace);
-		this.userByName = async (name) => handle("userByName", [name], namespace);
-		this.createUser = async (input) => handle("createUser", [input], namespace);
-		this.updateUser = async (input) => handle("updateUser", [input], namespace);
-		this.deleteUser = async (userId) => handle("deleteUser", [userId], namespace);
-		this.sendPasswordResetEmail = async (input) => handle("sendPasswordResetEmail", [input], namespace);
-		this.unenrollMfa = async (input) => handle("unenrollMfa", [input], namespace);
-	});
+	function createNamespaceMocks(namespace) {
+		return {
+			users: vi.fn(async (...args) => handle("users", args, namespace)),
+			user: vi.fn(async (...args) => handle("user", args, namespace)),
+			userByName: vi.fn(async (...args) => handle("userByName", args, namespace)),
+			createUser: vi.fn(async (...args) => handle("createUser", args, namespace)),
+			updateUser: vi.fn(async (...args) => handle("updateUser", args, namespace)),
+			deleteUser: vi.fn(async (...args) => handle("deleteUser", args, namespace)),
+			sendPasswordResetEmail: vi.fn(async (...args) => handle("sendPasswordResetEmail", args, namespace)),
+			unenrollMfa: vi.fn(async (...args) => handle("unenrollMfa", args, namespace))
+		};
+	}
+	function namespace(name) {
+		const existing = namespaces.get(name);
+		if (existing) return existing;
+		const mocks = createNamespaceMocks(name);
+		namespaces.set(name, mocks);
+		return mocks;
+	}
+	function track(method, mock, namespaceName) {
+		return function(...args) {
+			calls.push({
+				method,
+				args: [...compatibilityArgs(method, args)],
+				namespace: namespaceName
+			});
+			return mock.apply(this, args);
+		};
+	}
+	const defaultClient = function(config) {
+		const mocks = namespace(config.namespace);
+		this.users = track("users", mocks.users, config.namespace);
+		this.user = track("user", mocks.user, config.namespace);
+		this.userByName = track("userByName", mocks.userByName, config.namespace);
+		this.createUser = track("createUser", mocks.createUser, config.namespace);
+		this.updateUser = track("updateUser", mocks.updateUser, config.namespace);
+		this.deleteUser = track("deleteUser", mocks.deleteUser, config.namespace);
+		this.sendPasswordResetEmail = track("sendPasswordResetEmail", mocks.sendPasswordResetEmail, config.namespace);
+		this.unenrollMfa = track("unenrollMfa", mocks.unenrollMfa, config.namespace);
+	};
+	const Client = vi.fn(defaultClient);
 	root.idp = { Client };
+	function allMocks() {
+		return [...namespaces.values()].flatMap((mocks) => IDP_METHODS.map((method) => mocks[method]));
+	}
 	return withDispose({
 		/** The mock IDP `Client` constructor (`vi.fn`). */
 		Client,
+		namespace,
 		setResolver(value) {
 			resolver = value;
 		},
 		/**
-		* Enqueue a single result for the next IDP call (FIFO; falls back to
-		* `setResolver` when exhausted).
+		* Enqueue a single result for the next IDP call.
+		* The queue is shared across all methods and namespaces.
 		* @param result - Result to return from the next IDP call
 		*/
 		enqueueResult(result) {
@@ -711,6 +874,7 @@ function mockIdp() {
 		},
 		/**
 		* Enqueue results for multiple subsequent IDP calls.
+		* The queue is shared across all methods and namespaces.
 		* @param results - Results to enqueue, one per upcoming call
 		*/
 		enqueueResults(...results) {
@@ -719,10 +883,18 @@ function mockIdp() {
 		get calls() {
 			return calls;
 		},
+		clear() {
+			calls.length = 0;
+			Client.mockClear();
+			for (const mock of allMocks()) mock.mockClear();
+		},
 		reset() {
 			queue.length = 0;
-			resolver = () => null;
 			calls.length = 0;
+			resolver = () => null;
+			Client.mockReset();
+			Client.mockImplementation(defaultClient);
+			for (const mock of allMocks()) mock.mockReset();
 		}
 	}, () => {
 		root.idp = prev;
@@ -731,6 +903,15 @@ function mockIdp() {
 
 //#endregion
 //#region src/vitest/mocks/tailordb.ts
+function testRegex(regex, value) {
+	const lastIndex = regex.lastIndex;
+	regex.lastIndex = 0;
+	try {
+		return regex.test(value);
+	} finally {
+		regex.lastIndex = lastIndex;
+	}
+}
 var MockQueryResult = class {
 	command;
 	rowCount;
@@ -746,27 +927,62 @@ var MockQueryResult = class {
 * `tailordb.Client` whose `queryObject` is a shared `vi.fn()` (so query
 * responses can be staged before the client is constructed). Restored on
 * dispose.
+* @param options - Query fallback behavior
 * @returns Disposable TailorDB mock control object
 * @example
 * ```typescript
 * import { mockTailordb } from "@tailor-platform/sdk/vitest";
 *
-* test("order-based", async () => {
+* test("query-based", async () => {
 *   using db = mockTailordb();
-*   db.enqueueResults([], [{ age: 30 }], []); // BEGIN / SELECT / COMMIT
+*   db.onQuery({ sql: /FROM users/, params: ["u-1"] }).returnsRows([{ age: 30 }]);
 *   // …
-*   expect(db.queryObject).toHaveBeenCalledTimes(3);
+*   expect(db.queryObject).toHaveBeenCalled();
 *   expect(db.Client).toHaveBeenCalledWith({ namespace: "tailordb" });
 * });
 * ```
 */
-function mockTailordb() {
+function mockTailordb(options = {}) {
 	const root = tailordbRoot();
 	const prevClient = root.Client;
-	const queryObject = vi.fn(async (_query, _params = []) => new MockQueryResult([]));
-	const connect = vi.fn(async () => {});
+	const rules = [];
+	let queryResolver;
+	function matchesQuery(matcher, query, params) {
+		if (typeof matcher === "function") return matcher(query, params);
+		if (typeof matcher === "string") return query === matcher;
+		if (matcher instanceof RegExp) return testRegex(matcher, query);
+		let sqlMatches;
+		if (typeof matcher.sql === "string") sqlMatches = query === matcher.sql;
+		else sqlMatches = testRegex(matcher.sql, query);
+		if (!sqlMatches || matcher.params === void 0) return sqlMatches;
+		if (typeof matcher.params === "function") return matcher.params(params);
+		const expectedParams = matcher.params;
+		return params.length === expectedParams.length && params.every((value, index) => isEqual(value, expectedParams[index]));
+	}
+	function queryResponse(response) {
+		if (response.type === "error") throw response.error;
+		return new MockQueryResult(response.rows);
+	}
+	async function defaultQuery(query, params = []) {
+		for (let i = rules.length - 1; i >= 0; i -= 1) {
+			const rule = rules[i];
+			if (!rule || !matchesQuery(rule.matcher, query, params)) continue;
+			const once = rule.once.shift();
+			if (once) return queryResponse(once);
+			if (rule.fallback) return queryResponse(rule.fallback);
+		}
+		if (queryResolver) return new MockQueryResult(queryResolver(query, params) ?? []);
+		if (options.onUnhandled === "error") throw new Error(`No TailorDB query behavior matched: ${query}`);
+		return new MockQueryResult([]);
+	}
+	const queryObject = vi.fn(defaultQuery);
+	const defaultConnect = async () => {};
+	const connect = vi.fn(defaultConnect);
 	const createdClients = [];
-	const Client = vi.fn(function(config) {
+	function enqueueRowsList(rowsList) {
+		for (const rows of rowsList) queryObject.mockImplementationOnce(async () => new MockQueryResult(rows));
+	}
+	const defaultClient = function(config) {
 		const record = {
 			namespace: config?.namespace,
 			ended: false
@@ -786,7 +1002,8 @@ function mockTailordb() {
 				queryObject
 			};
 		};
-	});
+	};
+	const Client = vi.fn(defaultClient);
 	root.Client = Client;
 	return withDispose({
 		/** The mock `tailordb.Client` constructor (`vi.fn`). */
@@ -798,7 +1015,53 @@ function mockTailordb() {
 		* @param resolver - Function that returns rows for a given query and params
 		*/
 		setQueryResolver(resolver) {
-			queryObject.mockImplementation(async (query, params = []) => new MockQueryResult(resolver(query, params) ?? []));
+			queryResolver = resolver;
+			queryObject.mockImplementation(defaultQuery);
+		},
+		/**
+		* Configure responses for queries matching SQL text, parameters, or a predicate.
+		* More recently registered matchers take precedence.
+		* Do not combine matchers with a direct `queryObject.mockImplementation()` override.
+		* @param matcher - Query matcher
+		* @returns Chainable query behavior
+		*/
+		onQuery(matcher) {
+			const rule = {
+				matcher,
+				once: []
+			};
+			rules.push(rule);
+			const behavior = {
+				returnsRows(rows) {
+					rule.fallback = {
+						type: "rows",
+						rows
+					};
+					return behavior;
+				},
+				returnsRowsOnce(rows) {
+					rule.once.push({
+						type: "rows",
+						rows
+					});
+					return behavior;
+				},
+				rejects(error) {
+					rule.fallback = {
+						type: "error",
+						error
+					};
+					return behavior;
+				},
+				rejectsOnce(error) {
+					rule.once.push({
+						type: "error",
+						error
+					});
+					return behavior;
+				}
+			};
+			return behavior;
 		},
 		/**
 		* Enqueue rows for the next `queryObject` call (FIFO; takes priority over
@@ -806,14 +1069,21 @@ function mockTailordb() {
 		* @param rows - Row objects to return from the next `queryObject` call
 		*/
 		enqueueResult(...rows) {
-			queryObject.mockImplementationOnce(async () => new MockQueryResult(rows));
+			enqueueRowsList([rows]);
 		},
 		/**
 		* Enqueue rows for multiple subsequent `queryObject` calls (FIFO).
 		* @param rowsList - Rows arrays, one per upcoming query
 		*/
 		enqueueResults(...rowsList) {
-			for (const rows of rowsList) queryObject.mockImplementationOnce(async () => new MockQueryResult(rows));
+			enqueueRowsList(rowsList);
+		},
+		/**
+		* Enqueue row arrays for subsequent queries whose exact order is under test.
+		* @param rowsList - Rows arrays, one per upcoming query
+		*/
+		enqueueRows(...rowsList) {
+			enqueueRowsList(rowsList);
 		},
 		/**
 		* All queries executed via `queryObject`, in order, derived from the vi.fn
@@ -833,13 +1103,24 @@ function mockTailordb() {
 		get createdClients() {
 			return createdClients;
 		},
+		/** Clear recorded calls while preserving configured query behavior. */
+		clear() {
+			queryObject.mockClear();
+			connect.mockClear();
+			Client.mockClear();
+			createdClients.length = 0;
+		},
 		/** Reset query responses and recorded calls (keeps the mock installed). */
 		reset() {
 			queryObject.mockReset();
-			queryObject.mockImplementation(async () => new MockQueryResult([]));
-			connect.mockClear();
-			Client.mockClear();
+			queryObject.mockImplementation(defaultQuery);
+			connect.mockReset();
+			connect.mockImplementation(defaultConnect);
+			Client.mockReset();
+			Client.mockImplementation(defaultClient);
 			createdClients.length = 0;
+			rules.length = 0;
+			queryResolver = void 0;
 		}
 	}, () => {
 		root.Client = prevClient;
@@ -848,6 +1129,30 @@ function mockTailordb() {
 
 //#endregion
 //#region src/vitest/mocks/workflow.ts
+const originalProcedures = /* @__PURE__ */ new WeakMap();
+function replaceProcedure(target, key, current) {
+	const original = originalProcedures.get(current) ?? current;
+	const defaultImplementation = function(...args) {
+		return Reflect.apply(original, this, args);
+	};
+	const mock = vi.fn(defaultImplementation);
+	originalProcedures.set(mock, original);
+	const record = target;
+	record[key] = mock;
+	return {
+		mock,
+		scoped: {
+			mockClear: () => mock.mockClear(),
+			mockReset: () => mock.mockReset(),
+			restore: () => {
+				if (record[key] === mock) record[key] = current;
+			}
+		}
+	};
+}
+function replaceStart(definition) {
+	return replaceProcedure(definition, "start", definition.start);
+}
 /**
 * Acquire a disposable mock for workflow operations (`tailor.workflow`).
 * Restored on dispose.
@@ -856,36 +1161,45 @@ function mockTailordb() {
 * ```typescript
 * import { mockWorkflow } from "@tailor-platform/sdk/vitest";
 *
-* test("job handler", async () => {
+* test("job start", async () => {
 *   using wf = mockWorkflow();
-*   wf.setJobHandler((name) => (name === "validate" ? { valid: true } : null));
-*   await runWorkflowUnderTest(); // calls tailor.workflow.triggerJobFunction("validate", {})
-*   expect(wf.triggerJobFunction).toHaveBeenCalledWith("validate", {});
+*   const job = wf.job(validateOrder);
+*   job.mockResolvedValue({ valid: true });
+*   await runWorkflowUnderTest();
+*   expect(job).toHaveBeenCalled();
 * });
 * ```
 */
 function mockWorkflow() {
 	const root = tailorRoot();
 	const prev = root.workflow;
-	const defaultTriggerJob = (jobName, _args, _options) => {
+	const prevEnv = readWorkflowTestEnv();
+	const jobSpies = /* @__PURE__ */ new Map();
+	const workflowSpies = /* @__PURE__ */ new Map();
+	const waitPointMocks = /* @__PURE__ */ new Map();
+	const scopedMocks = /* @__PURE__ */ new Set();
+	const defaultStartJob = (jobName, _args, _options) => {
 		throw new Error(`No workflow job mock for "${jobName}". Call mockWorkflow().setJobHandler(...) or enqueueResult(...), or use runWorkflowLocally() for local workflow execution.`);
 	};
-	const defaultTriggerWorkflow = async (_workflowName, _args, _options) => {
-		return TRIGGER_DEFAULT;
+	const defaultStartWorkflow = async (_workflowName, _args, _options) => {
+		return START_DEFAULT;
 	};
-	const defaultResumeWorkflow = async (executionId) => executionId;
-	const triggerJobFunction = vi.fn(defaultTriggerJob);
-	const triggerWorkflow = vi.fn(defaultTriggerWorkflow);
-	const resumeWorkflow = vi.fn(defaultResumeWorkflow);
+	const defaultResumeWorkflowExecution = async (executionId) => executionId;
+	const startJobFunction = vi.fn(defaultStartJob);
+	const startWorkflow = vi.fn(defaultStartWorkflow);
+	const resumeWorkflowExecution = vi.fn(defaultResumeWorkflowExecution);
 	const wait = vi.fn((_key, _payload) => null);
 	const resolve = vi.fn(async (_executionId, _key, _callback) => {});
+	const jobFunctionShim = (...call) => {
+		const out = call.length >= 3 ? startJobFunction(call[0], platformSerialize(call[1]), call[2]) : startJobFunction(call[0], platformSerialize(call[1]));
+		return out instanceof Promise ? out.then((v) => platformSerialize(v)) : platformSerialize(out);
+	};
+	const workflowShim = (...call) => call.length >= 3 ? startWorkflow(call[0], platformSerialize(call[1]), call[2]) : startWorkflow(call[0], platformSerialize(call[1]));
+	const resumeShim = (executionId) => resumeWorkflowExecution(executionId);
 	root.workflow = {
-		triggerJobFunction: (...call) => {
-			const out = call.length >= 3 ? triggerJobFunction(call[0], platformSerialize(call[1]), call[2]) : triggerJobFunction(call[0], platformSerialize(call[1]));
-			return out instanceof Promise ? out.then((v) => platformSerialize(v)) : platformSerialize(out);
-		},
-		triggerWorkflow: (...call) => call.length >= 3 ? triggerWorkflow(call[0], platformSerialize(call[1]), call[2]) : triggerWorkflow(call[0], platformSerialize(call[1])),
-		resumeWorkflow: (executionId) => resumeWorkflow(executionId),
+		startJobFunction: jobFunctionShim,
+		startWorkflow: workflowShim,
+		resumeWorkflowExecution: resumeShim,
 		wait: (key, payload) => wait(key, platformSerialize(payload)),
 		resolve: (executionId, key, callback) => resolve(executionId, key, (payload) => {
 			const out = callback(payload);
@@ -893,64 +1207,122 @@ function mockWorkflow() {
 		})
 	};
 	return withDispose({
-		/** The `triggerJobFunction` `vi.fn`. */
-		triggerJobFunction,
-		/** The `triggerWorkflow` `vi.fn`. */
-		triggerWorkflow,
-		/** The `resumeWorkflow` `vi.fn`. */
-		resumeWorkflow,
+		/** The `startJobFunction` `vi.fn`. */
+		startJobFunction,
+		/** The `startWorkflow` `vi.fn`. */
+		startWorkflow,
+		/** The `resumeWorkflowExecution` `vi.fn`. */
+		resumeWorkflowExecution,
 		/** The `wait` `vi.fn`. */
 		wait,
 		/** The `resolve` `vi.fn`. */
 		resolve,
 		/**
+		* Get a stable, typed mock for a workflow job's `start` method.
+		* The real start behavior is used until an implementation or result is configured.
+		* @param definition - Workflow job definition to mock
+		* @returns Typed `start` mock for the definition
+		*/
+		job(definition) {
+			const existing = jobSpies.get(definition);
+			if (existing) return existing;
+			const { mock, scoped } = replaceStart(definition);
+			scopedMocks.add(scoped);
+			jobSpies.set(definition, mock);
+			return mock;
+		},
+		/**
+		* Get a stable, typed mock for a workflow definition's `start` method.
+		* The real start behavior is used until an implementation or result is configured.
+		* @param definition - Workflow definition to mock
+		* @returns Typed `start` mock for the definition
+		*/
+		workflow(definition) {
+			const existing = workflowSpies.get(definition);
+			if (existing) return existing;
+			const { mock, scoped } = replaceStart(definition);
+			workflowSpies.set(definition, mock);
+			scopedMocks.add(scoped);
+			return mock;
+		},
+		/**
+		* Get stable, typed mocks for a wait point's `wait` and `resolve` methods.
+		* @param definition - Wait point definition to mock
+		* @returns Typed wait point mock control object
+		*/
+		waitPoint(definition) {
+			const existing = waitPointMocks.get(definition);
+			if (existing) return existing;
+			const waitReplacement = replaceProcedure(definition, "wait", definition.wait);
+			const resolveReplacement = replaceProcedure(definition, "resolve", definition.resolve);
+			const waitSpy = waitReplacement.mock;
+			const resolveSpy = resolveReplacement.mock;
+			scopedMocks.add(waitReplacement.scoped);
+			scopedMocks.add(resolveReplacement.scoped);
+			const waitPointMock = {
+				wait: waitSpy,
+				resolve: resolveSpy,
+				/**
+				* Invoke the next and subsequent resolve callbacks with a wait payload.
+				* @param payload - Payload originally supplied to the wait point
+				*/
+				setResolvePayload(payload) {
+					resolveSpy.mockImplementation(async (_executionId, callback) => {
+						platformSerialize(await callback(platformSerialize(payload)));
+					});
+				}
+			};
+			waitPointMocks.set(definition, waitPointMock);
+			return waitPointMock;
+		},
+		/**
 		* Set a fallback job handler. Called when the enqueue queue is empty.
 		* @param handler - Function returning a result for a job name, args, and options
 		*/
 		setJobHandler(handler) {
-			triggerJobFunction.mockImplementation((name, args, options) => handler(name, args, options));
+			startJobFunction.mockImplementation((name, args, options) => handler(name, args, options));
 		},
 		/**
-		* Enqueue a single result for the next `triggerJobFunction` call (FIFO;
+		* Enqueue a single result for the next `startJobFunction` call (FIFO;
 		* takes priority over `setJobHandler`).
 		* @param result - Result to return from the next call
 		*/
 		enqueueResult(result) {
-			triggerJobFunction.mockImplementationOnce(() => result);
+			startJobFunction.mockImplementationOnce(() => result);
 		},
 		/**
-		* Enqueue results for multiple subsequent `triggerJobFunction` calls (FIFO).
+		* Enqueue results for multiple subsequent `startJobFunction` calls (FIFO).
 		* @param results - Results to enqueue, one per upcoming call
 		*/
 		enqueueResults(...results) {
-			for (const result of results) triggerJobFunction.mockImplementationOnce(() => result);
+			for (const result of results) startJobFunction.mockImplementationOnce(() => result);
 		},
 		/**
-		* All jobs triggered via `triggerJobFunction`, in order.
-		* @returns Triggered jobs array
+		* All jobs started via `startJobFunction`, in order.
+		* @returns Started jobs array
 		*/
-		get triggeredJobs() {
-			return triggerJobFunction.mock.calls.map(([jobName, args, options]) => ({
+		get startedJobs() {
+			return startJobFunction.mock.calls.map(([jobName, args, options]) => ({
 				jobName,
 				args,
 				...options !== void 0 && { options }
 			}));
 		},
 		/**
-		* Configure what `triggerWorkflow` returns. Pass a string (same id every
+		* Configure what `startWorkflow` returns. Pass a string (same id every
 		* call) or `(name, args, options) => string`. Default: a placeholder UUID.
 		* @param handler - Static execution ID or a function returning one
 		*/
-		setTriggerHandler(handler) {
-			triggerWorkflow.mockImplementation(typeof handler === "function" ? async (name, args, options) => handler(name, args, options) : async () => handler);
+		setStartHandler(handler) {
+			startWorkflow.mockImplementation(typeof handler === "function" ? async (name, args, options) => handler(name, args, options) : async () => handler);
 		},
 		/**
-		* Configure what `resumeWorkflow` returns. Pass a string (same id every
-		* call) or `(executionId) => string`. Default: echoes the input executionId.
+		* Configure what `resumeWorkflowExecution` returns. Pass a string (same id
+		* every call) or `(executionId) => string`. Default: echoes the input executionId.
 		* @param handler - Static execution ID or a function returning one
 		*/
 		setResumeHandler(handler) {
-			resumeWorkflow.mockImplementation(typeof handler === "function" ? async (executionId) => handler(executionId) : async () => handler);
+			resumeWorkflowExecution.mockImplementation(typeof handler === "function" ? async (executionId) => handler(executionId) : async () => handler);
 		},
 		/**
 		* Configure what `wait` returns. Pass `(key, payload) => unknown` or any
@@ -961,7 +1333,7 @@ function mockWorkflow() {
 			wait.mockImplementation(typeof handler === "function" ? (key, payload) => handler(key, payload) : () => handler);
 		}),
 		/**
-		* Set the `env` passed to job bodies invoked via `createWorkflowJob().trigger()`.
+		* Set the `env` passed to job bodies invoked via `createWorkflowJob().start()`.
 		* Cleared on dispose / reset.
 		* @param env - Env passed to job bodies.
 		*/
@@ -998,29 +1370,41 @@ function mockWorkflow() {
 				key
 			}));
 		},
+		/** Clear recorded calls while preserving configured responses. */
+		clear() {
+			startJobFunction.mockClear();
+			startWorkflow.mockClear();
+			resumeWorkflowExecution.mockClear();
+			wait.mockClear();
+			resolve.mockClear();
+			for (const mock of scopedMocks) mock.mockClear();
+		},
 		/** Reset all workflow responses and recorded calls (keeps the mock installed). */
 		reset() {
-			triggerJobFunction.mockReset();
-			triggerJobFunction.mockImplementation(defaultTriggerJob);
-			triggerWorkflow.mockReset();
-			triggerWorkflow.mockImplementation(defaultTriggerWorkflow);
-			resumeWorkflow.mockReset();
-			resumeWorkflow.mockImplementation(defaultResumeWorkflow);
+			startJobFunction.mockReset();
+			startJobFunction.mockImplementation(defaultStartJob);
+			startWorkflow.mockReset();
+			startWorkflow.mockImplementation(defaultStartWorkflow);
+			resumeWorkflowExecution.mockReset();
+			resumeWorkflowExecution.mockImplementation(defaultResumeWorkflowExecution);
 			wait.mockReset();
 			wait.mockImplementation(() => null);
 			resolve.mockReset();
 			resolve.mockImplementation(async () => {});
+			for (const mock of scopedMocks) mock.mockReset();
 			clearWorkflowTestEnv();
 		}
 	}, () => {
+		for (const mock of scopedMocks) mock.restore();
 		root.workflow = prev;
-		clearWorkflowTestEnv();
+		if (prevEnv !== void 0) writeWorkflowTestEnv(prevEnv);
+		else clearWorkflowTestEnv();
 	});
 }
 
 //#endregion
 //#region src/vitest/workflow-local.ts
-var PendingTrigger = class {
+var PendingStart = class {
 	jobName;
 	args;
 	constructor(jobName, args) {
@@ -1037,7 +1421,7 @@ async function runWorkflowLocally(workflow, args, options) {
 	if (options?.env !== void 0) writeWorkflowTestEnv({ ...options.env });
 	root.tailor = {
 		...previousTailor,
-		workflow: createLocalWorkflowRuntime(previousTailor?.workflow, runner.triggerJobFunction)
+		workflow: createLocalWorkflowRuntime(previousTailor?.workflow, runner.startJobFunction)
 	};
 	try {
 		return await runner.runJob(workflow.mainJob.name, args);
@@ -1050,19 +1434,19 @@ async function runWorkflowLocally(workflow, args, options) {
 }
 function createLocalJobRunner() {
 	let activeExecution;
-	const triggerJobFunction = (jobName, args) => {
-		if (!activeExecution) throw new Error(`Cannot trigger workflow job "${jobName}" outside runWorkflowLocally() job execution.`);
+	const startJobFunction = (jobName, args) => {
+		if (!activeExecution) throw new Error(`Cannot start workflow job "${jobName}" outside runWorkflowLocally() job execution.`);
 		if (activeExecution.pending) throw activeExecution.pending;
 		const serializedArgs = platformSerialize(args);
 		const index = activeExecution.cursor;
 		activeExecution.cursor += 1;
 		const cached = activeExecution.records[index];
 		if (cached) {
-			assertSameTrigger(cached, jobName, serializedArgs);
+			assertSameStart(cached, jobName, serializedArgs);
 			if (cached.status === "rejected") throw cached.error;
 			return platformSerialize(cached.result);
 		}
-		const pending = new PendingTrigger(jobName, serializedArgs);
+		const pending = new PendingStart(jobName, serializedArgs);
 		activeExecution.pending = pending;
 		throw pending;
 	};
@@ -1080,15 +1464,15 @@ function createLocalJobRunner() {
 			try {
 				const out = await body(platformSerialize(args), buildJobContext());
 				if (execution.pending) {
-					await settlePendingTrigger(records, execution.pending, runJob);
+					await settlePendingStart(records, execution.pending, runJob);
 					continue;
 				}
-				if (execution.cursor !== records.length) throw new Error(`Workflow job trigger sequence changed while replaying "${name}". Expected ${records.length} trigger(s), but replay reached ${execution.cursor}.`);
+				if (execution.cursor !== records.length) throw new Error(`Workflow job start sequence changed while replaying "${name}". Expected ${records.length} start(s), but replay reached ${execution.cursor}.`);
 				return platformSerialize(out);
 			} catch (cause) {
-				const pending = cause instanceof PendingTrigger ? cause : execution.pending;
+				const pending = cause instanceof PendingStart ? cause : execution.pending;
 				if (pending) {
-					await settlePendingTrigger(records, pending, runJob);
+					await settlePendingStart(records, pending, runJob);
 					continue;
 				}
 				throw cause;
@@ -1099,10 +1483,10 @@ function createLocalJobRunner() {
 	};
 	return {
 		runJob,
-		triggerJobFunction
+		startJobFunction
 	};
 }
-async function settlePendingTrigger(records, pending, runJob) {
+async function settlePendingStart(records, pending, runJob) {
 	try {
 		records.push({
 			jobName: pending.jobName,
@@ -1119,22 +1503,24 @@ async function settlePendingTrigger(records, pending, runJob) {
 		});
 	}
 }
-function assertSameTrigger(record, jobName, args) {
+function assertSameStart(record, jobName, args) {
 	if (record.jobName === jobName && JSON.stringify(record.args) === JSON.stringify(args)) return;
-	throw new Error(`Workflow job trigger sequence changed while replaying. Expected ${record.jobName}(${JSON.stringify(record.args)}), but got ${jobName}(${JSON.stringify(args)}).`);
+	throw new Error(`Workflow job start sequence changed while replaying. Expected ${record.jobName}(${JSON.stringify(record.args)}), but got ${jobName}(${JSON.stringify(args)}).`);
 }
-function createLocalWorkflowRuntime(previous, triggerJobFunction) {
+function createLocalWorkflowRuntime(previous, startJobFunction) {
+	const startWorkflow = async (name, args, options) => {
+		if (previous) return await previous.startWorkflow(name, args, options);
+		platformSerialize(args);
+		return START_DEFAULT;
+	};
+	const resumeWorkflowExecution = async (executionId) => {
+		if (previous) return await previous.resumeWorkflowExecution(executionId);
+		return executionId;
+	};
 	return {
-		triggerJobFunction,
-		triggerWorkflow: async (name, args, options) => {
-			if (previous) return await previous.triggerWorkflow(name, args, options);
-			platformSerialize(args);
-			return TRIGGER_DEFAULT;
-		},
-		resumeWorkflow: async (executionId) => {
-			if (previous) return await previous.resumeWorkflow(executionId);
-			return executionId;
-		},
+		startJobFunction,
+		startWorkflow,
+		resumeWorkflowExecution,
 		wait: (key, payload) => {
 			if (previous) return previous.wait(key, payload);
 			throw new Error(`No wait handler for "${key}". Acquire mockWorkflow() and call setWaitHandler(...).`);