@tailor-platform/sdk 2.0.0-next.0 → 2.0.0-next.10

package/dist/vitest/index.mjs

@@ -1,10 +1,14 @@
-
-import { t as assertDefined } from "../assert-CKfwrmCV.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-DMgIygjE.mjs";
+import { i as getRegisteredJob, t as START_DEFAULT } from "../registry-BIGVUrMB.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-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";
+import { vi } from "vitest";
 
 //#region src/vitest/blocked-modules.ts
 /**
@@ -50,7 +54,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;
 }
@@ -58,12 +63,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",
@@ -183,7 +188,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
@@ -289,6 +294,1338 @@ function createEnvironmentPlugin(options) {
 	};
 }
 
+//#endregion
+//#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({
+*     urls: { "my-aigateway": "https://my-aigateway.example.com" },
+*   });
+*   aigateway.setUrl("my-aigateway", "https://replacement.example.com");
+*   // …
+* });
+* ```
+*/
+function mockAigateway(options = {}) {
+	const root = tailorRoot();
+	const prev = root.aigateway;
+	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`. */
+		get,
+		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.mockReset();
+			get.mockImplementation(defaultGet);
+		}
+	}, () => {
+		root.aigateway = prev;
+	});
+}
+
+//#endregion
+//#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({ tokens: { google: { access_token: "ya29.xxx" } } });
+*   ac.setToken("google", { access_token: "replacement" });
+*   // …
+* });
+* ```
+*/
+function mockAuthconnection(options = {}) {
+	const root = tailorRoot();
+	const prev = root.authconnection;
+	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`. */
+		getConnectionToken,
+		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.mockReset();
+			getConnectionToken.mockImplementation(defaultGetConnectionToken);
+		}
+	}, () => {
+		root.authconnection = prev;
+	});
+}
+
+//#endregion
+//#region src/vitest/mocks/file.ts
+const FILE_METHODS = [
+	"upload",
+	"download",
+	"downloadAsBase64",
+	"delete",
+	"getMetadata",
+	"downloadStream",
+	"uploadStream"
+];
+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: ""
+		}
+	},
+	getMetadata: {
+		contentType: "",
+		fileSize: 0,
+		sha256sum: "",
+		urlPath: ""
+	},
+	downloadStream: null,
+	uploadStream: { metadata: {
+		fileSize: 0,
+		sha256sum: ""
+	} }
+};
+/**
+* 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
+* import { mockFile } from "@tailor-platform/sdk/vitest";
+*
+* test("mock file download", async () => {
+*   using file = mockFile();
+*   file.download.mockResolvedValue({ data: new Uint8Array(), metadata: { ... } });
+*   // …
+* });
+* ```
+*/
+function mockFile(options = {}) {
+	const root = tailordbRoot();
+	const prev = root.file;
+	const { onUnhandled = "fallback" } = options;
+	const queue = [];
+	const calls = [];
+	let resolver = () => null;
+	function handle(method, namespace, typeName, fieldName, recordId) {
+		if (queue.length > 0) return queue.shift();
+		const resolved = resolver(method, {
+			method,
+			namespace,
+			typeName,
+			fieldName,
+			recordId
+		});
+		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 = {
+		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.
+		* The queue is shared across all methods and namespaces.
+		* @param result - Result to return from the next file call
+		*/
+		enqueueResult(result) {
+			queue.push(result);
+		},
+		/**
+		* 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) {
+			queue.push(...results);
+		},
+		get calls() {
+			return calls;
+		},
+		clear() {
+			calls.length = 0;
+			for (const mock of allMocks()) mock.mockClear();
+		},
+		reset() {
+			queue.length = 0;
+			calls.length = 0;
+			resolver = () => null;
+			for (const mock of allMocks()) mock.mockReset();
+		}
+	}, () => {
+		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 [];
+	}
+}
+/**
+* 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
+* import { mockIconv } from "@tailor-platform/sdk/vitest";
+*
+* test("mock encoding conversion", () => {
+*   using iconv = mockIconv();
+*   iconv.decode.mockReturnValue("decoded-text");
+*   // …
+* });
+* ```
+*/
+function mockIconv(options = {}) {
+	const root = tailorRoot();
+	const prev = root.iconv;
+	let resolver = null;
+	const calls = [];
+	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;
+		constructor(fromEncoding, toEncoding) {
+			this.#fromEncoding = fromEncoding;
+			this.#toEncoding = toEncoding;
+		}
+		convert(input) {
+			return trackedConvert.call(this, input, this.#fromEncoding, this.#toEncoding);
+		}
+	}
+	root.iconv = {
+		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;
+	});
+}
+
+//#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: 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("returns a user", async () => {
+*   using idp = mockIdp();
+*   idp.namespace("my-idp").user.mockResolvedValue({
+*     id: "u-1",
+*     name: "alice",
+*     disabled: false,
+*     mfaEnrolled: false,
+*     mfaFactorIds: [],
+*   });
+*   // …
+* });
+* ```
+*/
+function mockIdp(options = {}) {
+	const root = tailorRoot();
+	const prev = root.idp;
+	const { onUnhandled = "fallback" } = options;
+	const queue = [];
+	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) {
+		if (queue.length > 0) return queue.shift();
+		const resolved = resolver(method, compatibilityArgs(method, args), namespace);
+		if (resolved != null) return resolved;
+		if (onUnhandled === "error") throw new Error(`No IdP mock configured for "${namespace}.${method}"`);
+		return structuredClone(IDP_DEFAULTS[method]);
+	}
+	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.
+		* The queue is shared across all methods and namespaces.
+		* @param result - Result to return from the next IDP call
+		*/
+		enqueueResult(result) {
+			queue.push(result);
+		},
+		/**
+		* 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) {
+			queue.push(...results);
+		},
+		get calls() {
+			return calls;
+		},
+		clear() {
+			calls.length = 0;
+			Client.mockClear();
+			for (const mock of allMocks()) mock.mockClear();
+		},
+		reset() {
+			queue.length = 0;
+			calls.length = 0;
+			resolver = () => null;
+			Client.mockReset();
+			Client.mockImplementation(defaultClient);
+			for (const mock of allMocks()) mock.mockReset();
+		}
+	}, () => {
+		root.idp = prev;
+	});
+}
+
+//#endregion
+//#region src/vitest/mocks/logger.ts
+/**
+* Acquire a disposable mock for `tailor.logger`. Each method is a `vi.fn`, so
+* calls can be asserted directly; `calls` returns the `debug`/`info`/`warn`/
+* `error` entries in the order they were emitted. Restored on dispose.
+* @param _options - Reserved for future initial fixtures
+* @returns Disposable logger mock control object
+* @example
+* ```typescript
+* import { mockLogger } from "@tailor-platform/sdk/vitest";
+*
+* test("logs the processed order", () => {
+*   using logger = mockLogger();
+*   // …run code that calls tailor.logger.info…
+*   expect(logger.info).toHaveBeenCalledWith("order processed", { orderId: "o-1" });
+* });
+* ```
+*/
+function mockLogger(_options = {}) {
+	const root = tailorRoot();
+	const prev = root.logger;
+	const debug = vi.fn((_message, _attributes) => {});
+	const info = vi.fn((_message, _attributes) => {});
+	const warn = vi.fn((_message, _attributes) => {});
+	const error = vi.fn((_message, _attributes) => {});
+	const setAttributes = vi.fn((_attributes) => {});
+	root.logger = {
+		debug,
+		info,
+		warn,
+		error,
+		setAttributes
+	};
+	const severityFns = {
+		debug,
+		info,
+		warn,
+		error
+	};
+	return withDispose({
+		/** The `debug` `vi.fn`. */
+		debug,
+		/** The `info` `vi.fn`. */
+		info,
+		/** The `warn` `vi.fn`. */
+		warn,
+		/** The `error` `vi.fn`. */
+		error,
+		/** The `setAttributes` `vi.fn`. */
+		setAttributes,
+		get calls() {
+			return Object.entries(severityFns).flatMap(([severity, fn]) => fn.mock.calls.map((args, i) => ({
+				order: fn.mock.invocationCallOrder[i] ?? 0,
+				call: {
+					severity,
+					message: args[0],
+					attributes: args[1]
+				}
+			}))).toSorted((a, b) => a.order - b.order).map((e) => e.call);
+		},
+		clear() {
+			debug.mockClear();
+			info.mockClear();
+			warn.mockClear();
+			error.mockClear();
+			setAttributes.mockClear();
+		},
+		reset() {
+			debug.mockReset();
+			info.mockReset();
+			warn.mockReset();
+			error.mockReset();
+			setAttributes.mockReset();
+		}
+	}, () => {
+		root.logger = prev;
+	});
+}
+
+//#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;
+	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.
+* @param options - Query fallback behavior
+* @returns Disposable TailorDB mock control object
+* @example
+* ```typescript
+* import { mockTailordb } from "@tailor-platform/sdk/vitest";
+*
+* test("query-based", async () => {
+*   using db = mockTailordb();
+*   db.onQuery({ sql: /FROM users/, params: ["u-1"] }).returnsRows([{ age: 30 }]);
+*   // …
+*   expect(db.queryObject).toHaveBeenCalled();
+*   expect(db.Client).toHaveBeenCalledWith({ namespace: "tailordb" });
+* });
+* ```
+*/
+function mockTailordb(options = {}) {
+	const root = tailordbRoot();
+	const prevClient = root.Client;
+	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 = [];
+	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
+		};
+		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
+			};
+		};
+	};
+	const Client = vi.fn(defaultClient);
+	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) {
+			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
+		* `setQueryResolver`). Call with no arguments for an empty result.
+		* @param rows - Row objects to return from the next `queryObject` call
+		*/
+		enqueueResult(...rows) {
+			enqueueRowsList([rows]);
+		},
+		/**
+		* Enqueue rows for multiple subsequent `queryObject` calls (FIFO).
+		* @param rowsList - Rows arrays, one per upcoming query
+		*/
+		enqueueResults(...rowsList) {
+			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
+		* 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;
+		},
+		/** 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(defaultQuery);
+			connect.mockReset();
+			connect.mockImplementation(defaultConnect);
+			Client.mockReset();
+			Client.mockImplementation(defaultClient);
+			createdClients.length = 0;
+			rules.length = 0;
+			queryResolver = void 0;
+		}
+	}, () => {
+		root.Client = prevClient;
+	});
+}
+
+//#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.
+*
+* The canonical `execJobFunction` and its `startJobFunction` alias share the
+* same underlying `vi.fn`, so calls through either name are recorded once and
+* handlers configured on either name apply to both.
+* @returns Disposable workflow mock control object
+* @example
+* ```typescript
+* import { mockWorkflow } from "@tailor-platform/sdk/vitest";
+*
+* test("job start", async () => {
+*   using wf = mockWorkflow();
+*   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 defaultExecJob = (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 defaultStartWorkflow = async (_workflowName, _args, _options) => {
+		return START_DEFAULT;
+	};
+	const defaultResumeWorkflowExecution = async (executionId) => executionId;
+	const execJobFunction = vi.fn(defaultExecJob);
+	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 ? execJobFunction(call[0], platformSerialize(call[1]), call[2]) : execJobFunction(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 = {
+		execJobFunction: jobFunctionShim,
+		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);
+			return out instanceof Promise ? out.then((v) => platformSerialize(v)) : platformSerialize(out);
+		})
+	};
+	return withDispose({
+		/** The `execJobFunction` `vi.fn`. */
+		execJobFunction,
+		/**
+		* Alias of `execJobFunction` (same `vi.fn` reference).
+		* @deprecated Use `execJobFunction` instead.
+		*/
+		startJobFunction: execJobFunction,
+		/** 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) {
+			execJobFunction.mockImplementation((name, args, options) => handler(name, args, options));
+		},
+		/**
+		* Enqueue a single result for the next `execJobFunction` call (FIFO;
+		* takes priority over `setJobHandler`).
+		* @param result - Result to return from the next call
+		*/
+		enqueueResult(result) {
+			execJobFunction.mockImplementationOnce(() => result);
+		},
+		/**
+		* Enqueue results for multiple subsequent `execJobFunction` calls (FIFO).
+		* @param results - Results to enqueue, one per upcoming call
+		*/
+		enqueueResults(...results) {
+			for (const result of results) execJobFunction.mockImplementationOnce(() => result);
+		},
+		/**
+		* All jobs executed via `execJobFunction`, in order.
+		* @returns Started jobs array
+		*/
+		get startedJobs() {
+			return execJobFunction.mock.calls.map(([jobName, args, options]) => ({
+				jobName,
+				args,
+				...options !== void 0 && { options }
+			}));
+		},
+		/**
+		* 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
+		*/
+		setStartHandler(handler) {
+			startWorkflow.mockImplementation(typeof handler === "function" ? async (name, args, options) => handler(name, args, options) : async () => handler);
+		},
+		/**
+		* 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) {
+			resumeWorkflowExecution.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().start()`.
+		* 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
+			}));
+		},
+		/** Clear recorded calls while preserving configured responses. */
+		clear() {
+			execJobFunction.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() {
+			execJobFunction.mockReset();
+			execJobFunction.mockImplementation(defaultExecJob);
+			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;
+		if (prevEnv !== void 0) writeWorkflowTestEnv(prevEnv);
+		else clearWorkflowTestEnv();
+	});
+}
+
+//#endregion
+//#region src/vitest/workflow-local.ts
+var PendingStart = class {
+	jobName;
+	args;
+	constructor(jobName, args) {
+		this.jobName = jobName;
+		this.args = args;
+	}
+};
+async function runWorkflowLocally(workflow, args, options) {
+	const root = globalThis;
+	const previousTailor = root.tailor;
+	const previousEnv = readWorkflowTestEnv();
+	const hasPreviousEnv = previousEnv !== void 0;
+	const runner = createLocalJobRunner();
+	if (options?.env !== void 0) writeWorkflowTestEnv({ ...options.env });
+	root.tailor = {
+		...previousTailor,
+		workflow: createLocalWorkflowRuntime(previousTailor?.workflow, runner.startJobFunction)
+	};
+	try {
+		return await runner.runJob(workflow.mainJob.name, args);
+	} finally {
+		if (previousTailor) root.tailor = previousTailor;
+		else delete root.tailor;
+		if (options?.env !== void 0) if (hasPreviousEnv) writeWorkflowTestEnv(previousEnv);
+		else clearWorkflowTestEnv();
+	}
+}
+function createLocalJobRunner() {
+	let activeExecution;
+	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) {
+			assertSameStart(cached, jobName, serializedArgs);
+			if (cached.status === "rejected") throw cached.error;
+			return platformSerialize(cached.result);
+		}
+		const pending = new PendingStart(jobName, serializedArgs);
+		activeExecution.pending = pending;
+		throw pending;
+	};
+	const runJob = async (name, args) => {
+		const body = getRegisteredJob(name);
+		if (!body) return null;
+		const records = [];
+		for (;;) {
+			const execution = {
+				records,
+				cursor: 0
+			};
+			const previousExecution = activeExecution;
+			activeExecution = execution;
+			try {
+				const out = await body(platformSerialize(args), buildJobContext());
+				if (execution.pending) {
+					await settlePendingStart(records, execution.pending, runJob);
+					continue;
+				}
+				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 PendingStart ? cause : execution.pending;
+				if (pending) {
+					await settlePendingStart(records, pending, runJob);
+					continue;
+				}
+				throw cause;
+			} finally {
+				activeExecution = previousExecution;
+			}
+		}
+	};
+	return {
+		runJob,
+		startJobFunction
+	};
+}
+async function settlePendingStart(records, pending, runJob) {
+	try {
+		records.push({
+			jobName: pending.jobName,
+			args: pending.args,
+			status: "fulfilled",
+			result: await runJob(pending.jobName, pending.args)
+		});
+	} catch (error) {
+		records.push({
+			jobName: pending.jobName,
+			args: pending.args,
+			status: "rejected",
+			error
+		});
+	}
+}
+function assertSameStart(record, jobName, args) {
+	if (record.jobName === jobName && JSON.stringify(record.args) === JSON.stringify(args)) return;
+	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, execJobFunction) {
+	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 {
+		execJobFunction,
+		startJobFunction: execJobFunction,
+		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(...).`);
+		},
+		resolve: async (executionId, key, callback) => {
+			if (previous) {
+				await previous.resolve(executionId, key, callback);
+				return;
+			}
+			throw new Error("No resolve handler. Acquire mockWorkflow() and call setResolveHandler(...).");
+		}
+	};
+}
+
 //#endregion
 //#region src/vitest/mock-kysely.ts
 /**
@@ -479,7 +1816,8 @@ 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`,
+*    `mockLogger`. Each
 *    provides response configuration, call recording, and reset.
 *
 * 4. **Environment resolution** — Rewrites `environment: "tailor-runtime"` to the
@@ -517,5 +1855,5 @@ function tailorRuntime(options) {
 }
 
 //#endregion
-export { createKyselyMock, mockAuthconnection, mockFile, mockIconv, mockIdp, mockSecretmanager, mockTailordb, mockWorkflow, tailorRuntime };
+export { createKyselyMock, mockAigateway, mockAuthconnection, mockFile, mockIconv, mockIdp, mockLogger, mockSecretmanager, mockTailordb, mockWorkflow, runWorkflowLocally, tailorRuntime };
 //# sourceMappingURL=index.mjs.map