@tailor-platform/sdk 1.76.1 → 1.78.0

package/dist/vitest/index.mjs

@@ -1,7 +1,9 @@
-import { a as getRegisteredWorkflow, d as buildJobContext, f as clearWorkflowTestEnv, i as getRegisteredJob, m as platformSerialize, p as writeWorkflowTestEnv, t as TRIGGER_DEFAULT } from "../registry-NfSW0BRo.mjs";
+import { a as getRegisteredWorkflow, i as getRegisteredJob, t as TRIGGER_DEFAULT, u as platformSerialize } from "../registry-CYBRvfaU.mjs";
+import { a as writeWorkflowTestEnv, i as readWorkflowTestEnv, n as buildJobContext, r as clearWorkflowTestEnv } from "../test-env-key-DuZycyWM.mjs";
 import { t as assertDefined } from "../assert-DBxo8jPo.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";
@@ -295,27 +297,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`. */
@@ -323,12 +329,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;
@@ -339,23 +355,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`. */
@@ -363,12 +386,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;
@@ -377,6 +410,16 @@ function mockAuthconnection() {
 
 //#endregion
 //#region src/vitest/mocks/file.ts
+const FILE_METHODS = [
+	"upload",
+	"download",
+	"downloadAsBase64",
+	"delete",
+	"getMetadata",
+	"openDownloadStream",
+	"downloadStream",
+	"uploadStream"
+];
 const FILE_DEFAULTS = {
 	upload: { metadata: {
 		fileSize: 0,
@@ -400,7 +443,6 @@ const FILE_DEFAULTS = {
 			lastUploadedAt: ""
 		}
 	},
-	delete: void 0,
 	getMetadata: {
 		contentType: "",
 		fileSize: 0,
@@ -413,27 +455,59 @@ const FILE_DEFAULTS = {
 		sha256sum: ""
 	} }
 };
+function wrapFileIterator(inner, closeSource) {
+	let closePromise;
+	const closeSourceOnce = () => closePromise ??= Promise.resolve(closeSource());
+	const close = async () => {
+		try {
+			await inner.return?.();
+		} finally {
+			await closeSourceOnce();
+		}
+	};
+	const stream = {
+		async next() {
+			const result = await inner.next();
+			if (!result.done) assertStreamValue(result.value);
+			return result.done ? {
+				done: true,
+				value: void 0
+			} : result;
+		},
+		close,
+		async return(value) {
+			try {
+				return inner.return ? await inner.return(value) : {
+					done: true,
+					value
+				};
+			} finally {
+				await closeSourceOnce();
+			}
+		},
+		async throw(error) {
+			try {
+				if (inner.throw) return await inner.throw(error);
+				throw error;
+			} finally {
+				await closeSourceOnce();
+			}
+		},
+		[Symbol.asyncIterator]() {
+			return stream;
+		}
+	};
+	return stream;
+}
 function toFileStream(value) {
-	if (value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value.close === "function") return value;
+	if (value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value.close === "function") {
+		const source = value;
+		return wrapFileIterator(source[Symbol.asyncIterator](), () => source.close());
+	}
 	if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) throw new TypeError("openDownloadStream expects an iterable of StreamValue items (e.g. [{ type: \"chunk\", data, position }, { type: \"complete\" }]); got raw bytes. Wrap the bytes in a structured chunk first.");
 	if (value !== null && typeof value === "object" && (Symbol.iterator in value || Symbol.asyncIterator in value)) {
 		const source = value;
-		const inner = Symbol.asyncIterator in source ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
-		const stream = {
-			async next() {
-				const r = await inner.next();
-				if (!r.done) assertStreamValue(r.value);
-				return r.done ? {
-					done: true,
-					value: void 0
-				} : r;
-			},
-			async close() {},
-			[Symbol.asyncIterator]() {
-				return stream;
-			}
-		};
-		return stream;
+		return wrapFileIterator(Symbol.asyncIterator in source ? source[Symbol.asyncIterator]() : source[Symbol.iterator](), () => {});
 	}
 	const empty = {
 		async next() {
@@ -449,14 +523,15 @@ function toFileStream(value) {
 	};
 	return empty;
 }
-function assertStreamValue(v) {
-	if (v === null || typeof v !== "object") throw new TypeError(`openDownloadStream expected a StreamValue item ({ type: "metadata" | "chunk" | "complete", ... }); got ${typeof v === "object" ? "null" : typeof v}.`);
-	if (v instanceof ArrayBuffer || ArrayBuffer.isView(v)) throw new TypeError("openDownloadStream expected a StreamValue item, got raw bytes. Wrap the bytes in a structured chunk first (e.g. { type: \"chunk\", data, position }).");
-	const type = v.type;
+function assertStreamValue(value) {
+	if (value === null || typeof value !== "object") throw new TypeError(`openDownloadStream expected a StreamValue item ({ type: "metadata" | "chunk" | "complete", ... }); got ${typeof value === "object" ? "null" : typeof value}.`);
+	if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) throw new TypeError("openDownloadStream expected a StreamValue item, got raw bytes. Wrap the bytes in a structured chunk first (e.g. { type: \"chunk\", data, position }).");
+	const type = value.type;
 	if (type !== "metadata" && type !== "chunk" && type !== "complete") throw new TypeError(`openDownloadStream expected a StreamValue item with type "metadata" | "chunk" | "complete"; got ${JSON.stringify(type)}.`);
 }
 /**
 * 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
@@ -464,77 +539,105 @@ function assertStreamValue(v) {
 *
 * 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 openDownloadStream = vi.fn(async (...args) => toFileStream(handle("openDownloadStream", ...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,
+		openDownloadStream,
+		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 openDownloadStream(namespace, typeName, fieldName, recordId) {
-			return toFileStream(handle("openDownloadStream", 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),
+		openDownloadStream: track("openDownloadStream", openDownloadStream),
+		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) {
@@ -542,6 +645,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) {
@@ -550,10 +654,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;
@@ -572,11 +681,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
@@ -584,27 +693,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;
@@ -613,39 +761,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;
@@ -654,99 +819,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) {
@@ -754,6 +951,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) {
@@ -762,10 +960,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;
@@ -774,6 +980,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;
@@ -789,27 +1004,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
@@ -829,7 +1079,8 @@ function mockTailordb() {
 				queryObject
 			};
 		};
-	});
+	};
+	const Client = vi.fn(defaultClient);
 	root.Client = Client;
 	return withDispose({
 		/** The mock `tailordb.Client` constructor (`vi.fn`). */
@@ -841,7 +1092,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
@@ -849,14 +1146,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
@@ -876,13 +1180,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;
@@ -891,6 +1206,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 replaceTrigger(definition) {
+	return replaceProcedure(definition, "trigger", definition.trigger);
+}
 /**
 * Acquire a disposable mock for workflow operations (`tailor.workflow`).
 * Restored on dispose.
@@ -899,17 +1238,23 @@ function mockTailordb() {
 * ```typescript
 * import { mockWorkflow } from "@tailor-platform/sdk/vitest";
 *
-* test("job handler", async () => {
+* test("job trigger", 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 prevEnv = readWorkflowTestEnv();
+	const jobSpies = /* @__PURE__ */ new Map();
+	const workflowSpies = /* @__PURE__ */ new Map();
+	const waitPointMocks = /* @__PURE__ */ new Map();
+	const scopedMocks = /* @__PURE__ */ new Set();
 	const defaultTriggerJob = (jobName, args, _options) => {
 		const body = getRegisteredJob(jobName);
 		return body ? body(args, buildJobContext()) : null;
@@ -953,6 +1298,64 @@ function mockWorkflow() {
 		/** The `resolve` `vi.fn`. */
 		resolve,
 		/**
+		* Get a stable, typed mock for a workflow job's `trigger` method.
+		* The real trigger behavior is used until an implementation or result is configured.
+		* @param definition - Workflow job definition to mock
+		* @returns Typed `trigger` mock for the definition
+		*/
+		job(definition) {
+			const existing = jobSpies.get(definition);
+			if (existing) return existing;
+			const { mock, scoped } = replaceTrigger(definition);
+			scopedMocks.add(scoped);
+			jobSpies.set(definition, mock);
+			return mock;
+		},
+		/**
+		* Get a stable, typed mock for a workflow definition's `trigger` method.
+		* The real trigger behavior is used until an implementation or result is configured.
+		* @param definition - Workflow definition to mock
+		* @returns Typed `trigger` mock for the definition
+		*/
+		workflow(definition) {
+			const existing = workflowSpies.get(definition);
+			if (existing) return existing;
+			const { mock, scoped } = replaceTrigger(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
 		*/
@@ -1047,6 +1450,15 @@ function mockWorkflow() {
 				key
 			}));
 		},
+		/** Clear recorded calls while preserving configured responses. */
+		clear() {
+			triggerJobFunction.mockClear();
+			triggerWorkflow.mockClear();
+			resumeWorkflow.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();
@@ -1059,11 +1471,14 @@ function mockWorkflow() {
 			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();
 	});
 }