@tailor-platform/sdk 2.0.0-next.2 → 2.0.0-next.3

package/dist/vitest/index.mjs

@@ -1,12 +1,13 @@
 import { i as getRegisteredJob, t as TRIGGER_DEFAULT } from "../registry-DH4m7eYo.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 { i as platformSerialize } from "../globals-Cf0sxIt8.mjs";
-import { a as mockSecretmanager, i as mockIdp, n as mockFile, o as mockTailordb, r as mockIconv, s as mockWorkflow, t as mockAuthconnection } from "../mock-FPxmnt-y.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 { builtinModules } from "node:module";
 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";
+import { vi } from "vitest";
 
 //#region src/vitest/blocked-modules.ts
 /**
@@ -52,7 +53,8 @@ function isBlockedModule(specifier) {
 * @returns Error message with optional suggestion for the Web Standard API alternative
 */
 function getBlockedMessage(specifier) {
-	const suggestion = SUGGESTIONS[specifier.startsWith("node:") ? specifier.slice(5) : specifier];
+	const bare = specifier.startsWith("node:") ? specifier.slice(5) : specifier;
+	const suggestion = SUGGESTIONS[bare];
 	const base = `"${specifier}" is not available in the Tailor Platform runtime.`;
 	return suggestion ? `${base} ${suggestion}` : base;
 }
@@ -60,12 +62,12 @@ function getBlockedMessage(specifier) {
 //#endregion
 //#region src/vitest/plugin.ts
 const DEFAULT_TEST_INCLUDE = ["**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"];
-const IMPORT_LIKE_TYPES = new Set([
+const IMPORT_LIKE_TYPES = /* @__PURE__ */ new Set([
 	"ImportDeclaration",
 	"ExportNamedDeclaration",
 	"ExportAllDeclaration"
 ]);
-const UNSAFE_BINDING_NAMES = new Set([
+const UNSAFE_BINDING_NAMES = /* @__PURE__ */ new Set([
 	"break",
 	"case",
 	"catch",
@@ -185,7 +187,7 @@ function createBlockPlugin() {
 			const testConfig = config.test;
 			const root = testConfig?.root ?? config.root;
 			const toAbsolutePaths = (value, baseRoot) => (Array.isArray(value) ? value : value ? [value] : []).map((f) => resolve(baseRoot, f));
-			const exemptHostFiles = new Set([...toAbsolutePaths(testConfig?.setupFiles, root), ...toAbsolutePaths(testConfig?.globalSetup, root)]);
+			const exemptHostFiles = /* @__PURE__ */ new Set([...toAbsolutePaths(testConfig?.setupFiles, root), ...toAbsolutePaths(testConfig?.globalSetup, root)]);
 			const includePairs = [{
 				root,
 				patterns: testConfig?.include ?? DEFAULT_TEST_INCLUDE
@@ -291,6 +293,731 @@ function createEnvironmentPlugin(options) {
 	};
 }
 
+//#endregion
+//#region src/vitest/mocks/aigateway.ts
+/**
+* Acquire a disposable mock for `tailor.aigateway`. Restored on dispose.
+* @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" });
+*   // …
+* });
+* ```
+*/
+function mockAigateway() {
+	const root = tailorRoot();
+	const prev = root.aigateway;
+	let urls = {};
+	const get = vi.fn(async (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 };
+	});
+	root.aigateway = { get };
+	return withDispose({
+		/** The `get` `vi.fn`. */
+		get,
+		setUrls(value) {
+			urls = value;
+		},
+		get calls() {
+			return get.mock.calls.map(([name]) => ({ name }));
+		},
+		reset() {
+			urls = {};
+			get.mockClear();
+		}
+	}, () => {
+		root.aigateway = prev;
+	});
+}
+
+//#endregion
+//#region src/vitest/mocks/authconnection.ts
+/**
+* Acquire a disposable mock for `tailor.authconnection`. Restored on dispose.
+* @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" } });
+*   // …
+* });
+* ```
+*/
+function mockAuthconnection() {
+	const root = tailorRoot();
+	const prev = root.authconnection;
+	let tokens = {};
+	const getConnectionToken = vi.fn(async (connectionName) => tokens[connectionName] ?? { access_token: "mock-token" });
+	root.authconnection = { getConnectionToken };
+	return withDispose({
+		/** The `getConnectionToken` `vi.fn`. */
+		getConnectionToken,
+		setTokens(value) {
+			tokens = value;
+		},
+		get calls() {
+			return getConnectionToken.mock.calls.map(([connectionName]) => ({ connectionName }));
+		},
+		reset() {
+			tokens = {};
+			getConnectionToken.mockClear();
+		}
+	}, () => {
+		root.authconnection = prev;
+	});
+}
+
+//#endregion
+//#region src/vitest/mocks/file.ts
+const FILE_DEFAULTS = {
+	upload: { metadata: {
+		fileSize: 0,
+		sha256sum: ""
+	} },
+	download: {
+		data: /* @__PURE__ */ new Uint8Array(),
+		metadata: {
+			contentType: "",
+			fileSize: 0,
+			sha256sum: "",
+			lastUploadedAt: ""
+		}
+	},
+	downloadAsBase64: {
+		data: "",
+		metadata: {
+			contentType: "",
+			fileSize: 0,
+			sha256sum: "",
+			lastUploadedAt: ""
+		}
+	},
+	delete: void 0,
+	getMetadata: {
+		contentType: "",
+		fileSize: 0,
+		sha256sum: "",
+		urlPath: ""
+	},
+	downloadStream: null,
+	uploadStream: { metadata: {
+		fileSize: 0,
+		sha256sum: ""
+	} }
+};
+/**
+* Acquire a disposable mock for `tailordb.file`. Restored on dispose.
+* @returns Disposable File mock control object
+* @example
+* ```typescript
+* import { mockFile } from "@tailor-platform/sdk/vitest";
+*
+* test("mock file download", async () => {
+*   using file = mockFile();
+*   file.enqueueResult({ data: new Uint8Array([1, 2, 3]), metadata: { ... } });
+*   // …
+* });
+* ```
+*/
+function mockFile() {
+	const root = tailordbRoot();
+	const prev = root.file;
+	const queue = [];
+	let resolver = () => null;
+	const calls = [];
+	function handle(method, namespace, typeName, fieldName, recordId) {
+		const call = {
+			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;
+		const fallback = FILE_DEFAULTS[method];
+		return fallback === void 0 ? void 0 : structuredClone(fallback);
+	}
+	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);
+		}
+	};
+	return withDispose({
+		setResolver(value) {
+			resolver = value;
+		},
+		/**
+		* Enqueue a single result for the next `tailordb.file` call (FIFO; falls
+		* back to `setResolver` when exhausted).
+		* @param result - Result to return from the next file call
+		*/
+		enqueueResult(result) {
+			queue.push(result);
+		},
+		/**
+		* Enqueue results for multiple subsequent `tailordb.file` calls.
+		* @param results - Results to enqueue, one per upcoming call
+		*/
+		enqueueResults(...results) {
+			queue.push(...results);
+		},
+		get calls() {
+			return calls;
+		},
+		reset() {
+			queue.length = 0;
+			resolver = () => null;
+			calls.length = 0;
+		}
+	}, () => {
+		root.file = prev;
+	});
+}
+
+//#endregion
+//#region src/vitest/mocks/iconv.ts
+function isUtf8(encoding) {
+	return encoding === "UTF8" || encoding === "UTF-8";
+}
+function defaultIconvResult(method, args) {
+	switch (method) {
+		case "convert":
+		case "convertBuffer": return isUtf8(args[2]) ? "" : /* @__PURE__ */ new Uint8Array();
+		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.
+* @returns Disposable Iconv mock control object
+* @example
+* ```typescript
+* import { mockIconv } from "@tailor-platform/sdk/vitest";
+*
+* test("mock encoding conversion", () => {
+*   using iconv = mockIconv();
+*   iconv.setResolver((method) => (method === "decode" ? "decoded-text" : null));
+*   // …
+* });
+* ```
+*/
+function mockIconv() {
+	const root = tailorRoot();
+	const prev = root.iconv;
+	let resolver = null;
+	const calls = [];
+	function handle(method, args) {
+		calls.push({
+			method,
+			args: [...args]
+		});
+		if (resolver) {
+			const result = resolver(method, args);
+			if (result != null) return result;
+		}
+		return defaultIconvResult(method, args);
+	}
+	class MockIconv {
+		#fromEncoding;
+		#toEncoding;
+		constructor(fromEncoding, toEncoding) {
+			this.#fromEncoding = fromEncoding;
+			this.#toEncoding = toEncoding;
+		}
+		convert(input) {
+			return handle("convert", [
+				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", []),
+		Iconv: MockIconv
+	};
+	return withDispose({
+		setResolver(value) {
+			resolver = value;
+		},
+		get calls() {
+			return calls;
+		},
+		reset() {
+			resolver = null;
+			calls.length = 0;
+		}
+	}, () => {
+		root.iconv = prev;
+	});
+}
+
+//#endregion
+//#region src/vitest/mocks/idp.ts
+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: []
+	},
+	deleteUser: true,
+	sendPasswordResetEmail: true,
+	unenrollMfa: true
+};
+/**
+* Acquire a disposable mock for `tailor.idp`. Restored on dispose.
+* @returns Disposable IDP mock control object
+* @example
+* ```typescript
+* import { mockIdp } from "@tailor-platform/sdk/vitest";
+*
+* test("resolver-based", async () => {
+*   using idp = mockIdp();
+*   idp.setResolver((method) =>
+*     method === "user" ? { id: "u-1", name: "alice", disabled: false } : null,
+*   );
+*   // …
+* });
+* ```
+*/
+function mockIdp() {
+	const root = tailorRoot();
+	const prev = root.idp;
+	const queue = [];
+	let resolver = () => null;
+	const calls = [];
+	function handle(method, args, namespace) {
+		calls.push({
+			method,
+			args,
+			namespace
+		});
+		if (queue.length > 0) return queue.shift();
+		const resolved = resolver(method, args, namespace);
+		if (resolved != null) return resolved;
+		const fallback = IDP_DEFAULTS[method];
+		return fallback === void 0 ? void 0 : structuredClone(fallback);
+	}
+	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);
+	});
+	root.idp = { Client };
+	return withDispose({
+		/** The mock IDP `Client` constructor (`vi.fn`). */
+		Client,
+		setResolver(value) {
+			resolver = value;
+		},
+		/**
+		* Enqueue a single result for the next IDP call (FIFO; falls back to
+		* `setResolver` when exhausted).
+		* @param result - Result to return from the next IDP call
+		*/
+		enqueueResult(result) {
+			queue.push(result);
+		},
+		/**
+		* Enqueue results for multiple subsequent IDP calls.
+		* @param results - Results to enqueue, one per upcoming call
+		*/
+		enqueueResults(...results) {
+			queue.push(...results);
+		},
+		get calls() {
+			return calls;
+		},
+		reset() {
+			queue.length = 0;
+			resolver = () => null;
+			calls.length = 0;
+		}
+	}, () => {
+		root.idp = prev;
+	});
+}
+
+//#endregion
+//#region src/vitest/mocks/tailordb.ts
+var MockQueryResult = class {
+	command;
+	rowCount;
+	rows;
+	constructor(rows) {
+		this.command = "";
+		this.rowCount = rows.length;
+		this.rows = rows;
+	}
+};
+/**
+* Acquire a disposable mock for TailorDB operations. Installs a mock
+* `tailordb.Client` whose `queryObject` is a shared `vi.fn()` (so query
+* responses can be staged before the client is constructed). Restored on
+* dispose.
+* @returns Disposable TailorDB mock control object
+* @example
+* ```typescript
+* import { mockTailordb } from "@tailor-platform/sdk/vitest";
+*
+* test("order-based", async () => {
+*   using db = mockTailordb();
+*   db.enqueueResults([], [{ age: 30 }], []); // BEGIN / SELECT / COMMIT
+*   // …
+*   expect(db.queryObject).toHaveBeenCalledTimes(3);
+*   expect(db.Client).toHaveBeenCalledWith({ namespace: "tailordb" });
+* });
+* ```
+*/
+function mockTailordb() {
+	const root = tailordbRoot();
+	const prevClient = root.Client;
+	const queryObject = vi.fn(async (_query, _params = []) => new MockQueryResult([]));
+	const connect = vi.fn(async () => {});
+	const createdClients = [];
+	const Client = vi.fn(function(config) {
+		const record = {
+			namespace: config?.namespace,
+			ended: false
+		};
+		createdClients.push(record);
+		this.connect = connect;
+		this.end = vi.fn(async () => {
+			record.ended = true;
+		});
+		this.queryObject = queryObject;
+		this.createTransaction = (name) => {
+			if (!name) throw new Error("Transaction name must be a non-empty string");
+			return {
+				begin: async () => {},
+				commit: async () => {},
+				rollback: async () => {},
+				queryObject
+			};
+		};
+	});
+	root.Client = Client;
+	return withDispose({
+		/** The mock `tailordb.Client` constructor (`vi.fn`). */
+		Client,
+		/** The shared `queryObject` `vi.fn` used by every client and transaction. */
+		queryObject,
+		/**
+		* Set a fallback query resolver. Called when the enqueue queue is empty.
+		* @param resolver - Function that returns rows for a given query and params
+		*/
+		setQueryResolver(resolver) {
+			queryObject.mockImplementation(async (query, params = []) => new MockQueryResult(resolver(query, params) ?? []));
+		},
+		/**
+		* Enqueue rows for the next `queryObject` call (FIFO; takes priority over
+		* `setQueryResolver`). Call with no arguments for an empty result.
+		* @param rows - Row objects to return from the next `queryObject` call
+		*/
+		enqueueResult(...rows) {
+			queryObject.mockImplementationOnce(async () => new MockQueryResult(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));
+		},
+		/**
+		* All queries executed via `queryObject`, in order, derived from the vi.fn
+		* call records.
+		* @returns Executed queries array
+		*/
+		get executedQueries() {
+			return queryObject.mock.calls.map(([query, params]) => ({
+				query,
+				params: params ?? []
+			}));
+		},
+		/**
+		* All TailorDB clients created, with their namespace and end state.
+		* @returns Created clients array
+		*/
+		get createdClients() {
+			return createdClients;
+		},
+		/** Reset query responses and recorded calls (keeps the mock installed). */
+		reset() {
+			queryObject.mockReset();
+			queryObject.mockImplementation(async () => new MockQueryResult([]));
+			connect.mockClear();
+			Client.mockClear();
+			createdClients.length = 0;
+		}
+	}, () => {
+		root.Client = prevClient;
+	});
+}
+
+//#endregion
+//#region src/vitest/mocks/workflow.ts
+/**
+* Acquire a disposable mock for workflow operations (`tailor.workflow`).
+* Restored on dispose.
+* @returns Disposable workflow mock control object
+* @example
+* ```typescript
+* import { mockWorkflow } from "@tailor-platform/sdk/vitest";
+*
+* test("job handler", async () => {
+*   using wf = mockWorkflow();
+*   wf.setJobHandler((name) => (name === "validate" ? { valid: true } : null));
+*   await runWorkflowUnderTest(); // calls tailor.workflow.triggerJobFunction("validate", {})
+*   expect(wf.triggerJobFunction).toHaveBeenCalledWith("validate", {});
+* });
+* ```
+*/
+function mockWorkflow() {
+	const root = tailorRoot();
+	const prev = root.workflow;
+	const defaultTriggerJob = (jobName, _args) => {
+		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 defaultResumeWorkflow = async (executionId) => executionId;
+	const triggerJobFunction = vi.fn(defaultTriggerJob);
+	const triggerWorkflow = vi.fn(defaultTriggerWorkflow);
+	const resumeWorkflow = vi.fn(defaultResumeWorkflow);
+	const wait = vi.fn((_key, _payload) => null);
+	const resolve = vi.fn(async (_executionId, _key, _callback) => {});
+	const installedTriggerJobFunction = (jobName, args) => {
+		const out = triggerJobFunction(jobName, platformSerialize(args));
+		return out instanceof Promise ? out.then((v) => platformSerialize(v)) : platformSerialize(out);
+	};
+	root.workflow = {
+		triggerJobFunction: installedTriggerJobFunction,
+		triggerWorkflow: (...call) => call.length >= 3 ? triggerWorkflow(call[0], platformSerialize(call[1]), call[2]) : triggerWorkflow(call[0], platformSerialize(call[1])),
+		resumeWorkflow: (executionId) => resumeWorkflow(executionId),
+		wait: (key, payload) => wait(key, platformSerialize(payload)),
+		resolve: (executionId, key, callback) => resolve(executionId, key, (payload) => {
+			const out = callback(payload);
+			return out instanceof Promise ? out.then((v) => platformSerialize(v)) : platformSerialize(out);
+		})
+	};
+	return withDispose({
+		/** The `triggerJobFunction` `vi.fn`. */
+		triggerJobFunction,
+		/** The `triggerWorkflow` `vi.fn`. */
+		triggerWorkflow,
+		/** The `resumeWorkflow` `vi.fn`. */
+		resumeWorkflow,
+		/** The `wait` `vi.fn`. */
+		wait,
+		/** The `resolve` `vi.fn`. */
+		resolve,
+		/**
+		* Set a fallback job handler. Called when the enqueue queue is empty.
+		* @param handler - Function returning a result for a job name and args
+		*/
+		setJobHandler(handler) {
+			triggerJobFunction.mockImplementation((name, args) => handler(name, args));
+		},
+		/**
+		* Enqueue a single result for the next `triggerJobFunction` call (FIFO;
+		* takes priority over `setJobHandler`).
+		* @param result - Result to return from the next call
+		*/
+		enqueueResult(result) {
+			triggerJobFunction.mockImplementationOnce(() => result);
+		},
+		/**
+		* Enqueue results for multiple subsequent `triggerJobFunction` calls (FIFO).
+		* @param results - Results to enqueue, one per upcoming call
+		*/
+		enqueueResults(...results) {
+			for (const result of results) triggerJobFunction.mockImplementationOnce(() => result);
+		},
+		/**
+		* All jobs triggered via `triggerJobFunction`, in order.
+		* @returns Triggered jobs array
+		*/
+		get triggeredJobs() {
+			return triggerJobFunction.mock.calls.map(([jobName, args]) => ({
+				jobName,
+				args
+			}));
+		},
+		/**
+		* Configure what `triggerWorkflow` 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);
+		},
+		/**
+		* Configure what `resumeWorkflow` 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);
+		},
+		/**
+		* Configure what `wait` returns. Pass `(key, payload) => unknown` or any
+		* other value to return it for every call. Default: `null`.
+		* @param handler - Static value or a function returning one
+		*/
+		setWaitHandler: ((handler) => {
+			wait.mockImplementation(typeof handler === "function" ? (key, payload) => handler(key, payload) : () => handler);
+		}),
+		/**
+		* Set the `env` passed to job bodies invoked via `createWorkflowJob().trigger()`.
+		* Cleared on dispose / reset.
+		* @param env - Env passed to job bodies.
+		*/
+		setEnv(env) {
+			writeWorkflowTestEnv({ ...env });
+		},
+		/**
+		* Configure how `resolve` runs the user-supplied callback. Default: callback
+		* is not invoked (records the call only).
+		* @param handler - Function invoked per `resolve` call
+		*/
+		setResolveHandler(handler) {
+			resolve.mockImplementation(async (executionId, key, callback) => {
+				await handler(executionId, key, callback);
+			});
+		},
+		/**
+		* `wait` calls reshaped as `{ key, payload }` for assertions.
+		* @returns Wait call records
+		*/
+		get waitCalls() {
+			return wait.mock.calls.map(([key, payload]) => ({
+				key,
+				payload
+			}));
+		},
+		/**
+		* `resolve` calls reshaped as `{ executionId, key }` for assertions.
+		* @returns Resolve call records
+		*/
+		get resolveCalls() {
+			return resolve.mock.calls.map(([executionId, key]) => ({
+				executionId,
+				key
+			}));
+		},
+		/** 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);
+			wait.mockReset();
+			wait.mockImplementation(() => null);
+			resolve.mockReset();
+			resolve.mockImplementation(async () => {});
+			clearWorkflowTestEnv();
+		}
+	}, () => {
+		root.workflow = prev;
+		clearWorkflowTestEnv();
+	});
+}
+
 //#endregion
 //#region src/vitest/workflow-local.ts
 var PendingTrigger = class {
@@ -404,6 +1131,10 @@ function createLocalWorkflowRuntime(previous, triggerJobFunction) {
 			platformSerialize(args);
 			return TRIGGER_DEFAULT;
 		},
+		resumeWorkflow: async (executionId) => {
+			if (previous) return await previous.resumeWorkflow(executionId);
+			return executionId;
+		},
 		wait: (key, payload) => {
 			if (previous) return previous.wait(key, payload);
 			throw new Error(`No wait handler for "${key}". Acquire mockWorkflow() and call setWaitHandler(...).`);
@@ -608,7 +1339,7 @@ function createKyselyMock() {
 *
 * 3. **Platform API mocks** (environment) — All platform APIs are auto-injected with
 *    control objects: `mockTailordb`, `mockWorkflow`, `mockSecretmanager`,
-*    `mockAuthconnection`, `mockIdp`, `mockFile`, `mockIconv`. Each
+*    `mockAuthconnection`, `mockIdp`, `mockFile`, `mockIconv`, `mockAigateway`. Each
 *    provides response configuration, call recording, and reset.
 *
 * 4. **Environment resolution** — Rewrites `environment: "tailor-runtime"` to the
@@ -646,5 +1377,5 @@ function tailorRuntime(options) {
 }
 
 //#endregion
-export { createKyselyMock, mockAuthconnection, mockFile, mockIconv, mockIdp, mockSecretmanager, mockTailordb, mockWorkflow, runWorkflowLocally, tailorRuntime };
+export { createKyselyMock, mockAigateway, mockAuthconnection, mockFile, mockIconv, mockIdp, mockSecretmanager, mockTailordb, mockWorkflow, runWorkflowLocally, tailorRuntime };
 //# sourceMappingURL=index.mjs.map