@tailor-platform/sdk 1.57.0 → 1.59.0

package/dist/mock-B6PI49C_.mjs

@@ -1,844 +0,0 @@
-
-import { r as writeWorkflowTestEnv, t as clearWorkflowTestEnv } from "./test-env-key-CSnK4W1Y.mjs";
-
-//#region src/vitest/mock.ts
-/**
-* Mock implementations for Tailor Platform APIs.
-*
-* Provides singleton mock objects that are automatically injected into
-* globalThis by the tailor-runtime Vitest environment. Tests can configure
-* responses and assert on recorded calls via the exported mock objects.
-*/
-const STATE_KEY = "__tailorMockState";
-const RUNTIME_FLAG_KEY = "__tailorRuntimeActive";
-function getState() {
-	const g = globalThis;
-	if (!g["__tailorMockState"]) g[STATE_KEY] = createDefaultState();
-	return g[STATE_KEY];
-}
-function createDefaultState() {
-	return {
-		queryResolver: () => [],
-		queryResultQueue: [],
-		executedQueries: [],
-		createdClients: [],
-		jobHandler: () => null,
-		jobResultQueue: [],
-		triggeredJobs: [],
-		triggerHandler: "mock-execution-id",
-		waitHandler: null,
-		resolveHandler: null,
-		workflowCalls: [],
-		secretStore: {},
-		secretCalls: [],
-		authTokens: {},
-		authCalls: [],
-		idpResolver: () => null,
-		idpResultQueue: [],
-		idpCalls: [],
-		fileResolver: () => null,
-		fileResultQueue: [],
-		fileCalls: [],
-		iconvResolver: null,
-		iconvCalls: []
-	};
-}
-/**
-* Mock control object for TailorDB operations.
-*
-* Automatically injected into `globalThis.tailordb` by the tailor-runtime environment.
-* Use this object to configure query responses and assert on executed queries.
-* @example
-* ```typescript
-* import { tailordbMock } from "@tailor-platform/sdk/vitest";
-*
-* beforeEach(() => tailordbMock.reset());
-*
-* test("content-based", () => {
-*   tailordbMock.setQueryResolver((query) => {
-*     if (query.includes("SELECT")) return [{ id: "1" }];
-*     return [];
-*   });
-* });
-*
-* test("order-based", () => {
-*   tailordbMock.enqueueResults(
-*     [],            // BEGIN (empty result)
-*     [{ age: 30 }], // SELECT (one row)
-*     [],            // COMMIT (empty result)
-*   );
-* });
-* ```
-*/
-const tailordbMock = {
-	/**
-	* Set a fallback query resolver. Called when the result queue is empty.
-	* @param resolver - Function that returns rows for a given query and params
-	*/
-	setQueryResolver(resolver) {
-		getState().queryResolver = resolver;
-	},
-	/**
-	* Enqueue rows for the next `queryObject` call. Arguments are the row objects returned
-	* by that single query. Call with no arguments for an empty result. Consumed in FIFO
-	* order; when the queue is exhausted, subsequent calls fall back to `setQueryResolver`
-	* (default: empty rows). Use `enqueueResults` to stage rows for multiple queries in one
-	* call.
-	* @param rows - Row objects to return from the next `queryObject` call
-	*/
-	enqueueResult(...rows) {
-		getState().queryResultQueue.push(rows);
-	},
-	/**
-	* Enqueue rows for multiple subsequent `queryObject` calls. Each argument is a rows
-	* array for one query, consumed in FIFO order.
-	* @param rowsList - Rows arrays, one per upcoming query
-	*/
-	enqueueResults(...rowsList) {
-		getState().queryResultQueue.push(...rowsList);
-	},
-	/**
-	* All queries executed via `queryObject`, in order.
-	* @returns Executed queries array
-	*/
-	get executedQueries() {
-		return getState().executedQueries;
-	},
-	/**
-	* All TailorDB clients created, with their namespace and end state.
-	* @returns Created clients array
-	*/
-	get createdClients() {
-		return getState().createdClients;
-	},
-	/** Reset all TailorDB mock state. Call in `beforeEach`. */
-	reset() {
-		const state = getState();
-		state.queryResolver = () => [];
-		state.queryResultQueue.length = 0;
-		state.executedQueries.length = 0;
-		state.createdClients.length = 0;
-	}
-};
-/**
-* Mock control object for workflow operations.
-*
-* Automatically injected into `globalThis.tailor.workflow` by the tailor-runtime environment.
-* @example
-* ```typescript
-* import { workflowMock } from "@tailor-platform/sdk/vitest";
-*
-* beforeEach(() => workflowMock.reset());
-*
-* test("job handler", () => {
-*   workflowMock.setJobHandler((jobName, args) => {
-*     if (jobName === "validate") return { valid: true };
-*     return null;
-*   });
-* });
-*
-* test("wait point", () => {
-*   workflowMock.setWaitHandler(() => ({ approved: true }));
-*   // …
-*   expect(workflowMock.waitCalls).toEqual([{ key: "approval", payload: undefined }]);
-* });
-*
-* test("resolve point", () => {
-*   workflowMock.setResolveHandler((_executionId, _key, callback) =>
-*     callback({ approved: true }),
-*   );
-*   // …
-*   expect(workflowMock.resolveCalls).toEqual([
-*     { executionId: "mock-execution-id", key: "approval" },
-*   ]);
-* });
-* ```
-*/
-const workflowMock = {
-	/**
-	* Set a fallback job handler. Called when the result queue is empty.
-	* @param handler - Function that returns a result for a given job name and args
-	*/
-	setJobHandler(handler) {
-		getState().jobHandler = handler;
-	},
-	/**
-	* Enqueue a single result for the next `triggerJobFunction` call. Consumed in FIFO
-	* order; when the queue is exhausted, subsequent calls fall back to `setJobHandler`
-	* (default: null). Use `enqueueResults` to stage multiple results in one call.
-	* @param result - Result to return from the next `triggerJobFunction` call
-	*/
-	enqueueResult(result) {
-		getState().jobResultQueue.push(result);
-	},
-	/**
-	* Enqueue results for multiple subsequent `triggerJobFunction` calls.
-	* @param results - Results to enqueue, one per upcoming call
-	*/
-	enqueueResults(...results) {
-		const queue = getState().jobResultQueue;
-		for (const result of results) queue.push(result);
-	},
-	/**
-	* All jobs triggered via `triggerJobFunction`, in order.
-	* @returns Triggered jobs array
-	*/
-	get triggeredJobs() {
-		return getState().triggeredJobs;
-	},
-	/**
-	* Configure what `tailor.workflow.triggerWorkflow` returns. Pass a string to return
-	* the same execution ID for every call, or a function `(name, args, options) => string`
-	* to compute one per call. Default: `"mock-execution-id"`.
-	* @param handler - Static execution ID or a function that returns one
-	*/
-	setTriggerHandler(handler) {
-		getState().triggerHandler = handler;
-	},
-	/**
-	* Configure what `tailor.workflow.wait` returns. Pass a function `(key, payload) => unknown`
-	* to compute one per call, or any other value to return it for every call. Default: `null`.
-	* @param handler - Static value or a function that returns one
-	*/
-	setWaitHandler: ((handler) => {
-		getState().waitHandler = handler;
-	}),
-	/**
-	* Set the `env` passed to job bodies invoked via `createWorkflowJob().trigger()`.
-	* Cleared by `workflowMock.reset()`.
-	* @param env - Env passed to job bodies.
-	*/
-	setEnv(env) {
-		writeWorkflowTestEnv({ ...env });
-	},
-	/**
-	* Configure how `tailor.workflow.resolve` runs the user-supplied callback. The handler
-	* receives `(executionId, key, callback)` — invoke `callback(payload)` to drive
-	* resolve→wait wiring in tests. Default: callback is not invoked (records the call only).
-	* @param handler - Function invoked per `resolve` call
-	*/
-	setResolveHandler(handler) {
-		getState().resolveHandler = handler;
-	},
-	/**
-	* Calls to triggerWorkflow, wait, resolve (not triggerJobFunction — use triggeredJobs).
-	* @returns Workflow calls array
-	*/
-	get calls() {
-		return getState().workflowCalls;
-	},
-	/**
-	* `tailor.workflow.wait` calls reshaped as `{ key, payload }` for assertions.
-	* @returns Wait call records
-	*/
-	get waitCalls() {
-		return getState().workflowCalls.filter((c) => c.method === "wait").map((c) => ({
-			key: c.args[0],
-			payload: c.args[1]
-		}));
-	},
-	/**
-	* `tailor.workflow.resolve` calls reshaped as `{ executionId, key }` for assertions.
-	* @returns Resolve call records
-	*/
-	get resolveCalls() {
-		return getState().workflowCalls.filter((c) => c.method === "resolve").map((c) => ({
-			executionId: c.args[0],
-			key: c.args[1]
-		}));
-	},
-	/** Reset all workflow mock state. Call in `beforeEach`. */
-	reset() {
-		const state = getState();
-		state.jobHandler = () => null;
-		state.jobResultQueue.length = 0;
-		state.triggeredJobs.length = 0;
-		state.triggerHandler = "mock-execution-id";
-		state.waitHandler = null;
-		state.resolveHandler = null;
-		state.workflowCalls.length = 0;
-		clearWorkflowTestEnv();
-	}
-};
-/** Mock control for `tailor.secretmanager` — secret store and call recording. */
-const secretmanagerMock = {
-	setSecrets(secrets) {
-		getState().secretStore = secrets;
-	},
-	get calls() {
-		return getState().secretCalls;
-	},
-	reset() {
-		const state = getState();
-		state.secretStore = {};
-		state.secretCalls.length = 0;
-	}
-};
-/** Mock control for `tailor.authconnection` — token store and call recording. */
-const authconnectionMock = {
-	setTokens(tokens) {
-		getState().authTokens = tokens;
-	},
-	get calls() {
-		return getState().authCalls;
-	},
-	reset() {
-		const state = getState();
-		state.authTokens = {};
-		state.authCalls.length = 0;
-	}
-};
-/** Mock control for `tailor.idp` — IDP client responses and call recording. */
-const idpMock = {
-	setResolver(resolver) {
-		getState().idpResolver = resolver;
-	},
-	/**
-	* Enqueue a single result for the next IDP call. Consumed in FIFO order; falls back
-	* to `setResolver` when exhausted. Use `enqueueResults` to stage multiple in one call.
-	* @param result - Result to return from the next IDP call
-	*/
-	enqueueResult(result) {
-		getState().idpResultQueue.push(result);
-	},
-	/**
-	* Enqueue results for multiple subsequent IDP calls.
-	* @param results - Results to enqueue, one per upcoming call
-	*/
-	enqueueResults(...results) {
-		const queue = getState().idpResultQueue;
-		for (const result of results) queue.push(result);
-	},
-	get calls() {
-		return getState().idpCalls;
-	},
-	reset() {
-		const state = getState();
-		state.idpResolver = () => null;
-		state.idpResultQueue.length = 0;
-		state.idpCalls.length = 0;
-	}
-};
-/** Mock control for `tailordb.file` — file operation responses and call recording. */
-const fileMock = {
-	setResolver(resolver) {
-		getState().fileResolver = resolver;
-	},
-	/**
-	* Enqueue a single result for the next `tailordb.file` call. Consumed in FIFO order;
-	* falls back to `setResolver` when exhausted. Use `enqueueResults` to stage multiple
-	* in one call.
-	* @param result - Result to return from the next file call
-	*/
-	enqueueResult(result) {
-		getState().fileResultQueue.push(result);
-	},
-	/**
-	* Enqueue results for multiple subsequent `tailordb.file` calls.
-	* @param results - Results to enqueue, one per upcoming call
-	*/
-	enqueueResults(...results) {
-		const queue = getState().fileResultQueue;
-		for (const result of results) queue.push(result);
-	},
-	get calls() {
-		return getState().fileCalls;
-	},
-	reset() {
-		const state = getState();
-		state.fileResolver = () => null;
-		state.fileResultQueue.length = 0;
-		state.fileCalls.length = 0;
-	}
-};
-/** Mock control for `tailor.iconv` — encoding call recording. */
-const iconvMock = {
-	setResolver(resolver) {
-		getState().iconvResolver = resolver;
-	},
-	get calls() {
-		return getState().iconvCalls;
-	},
-	reset() {
-		const state = getState();
-		state.iconvResolver = null;
-		state.iconvCalls.length = 0;
-	}
-};
-var MockQueryResult = class {
-	command;
-	rowCount;
-	rows;
-	constructor(rows) {
-		this.command = "";
-		this.rowCount = rows.length;
-		this.rows = rows;
-	}
-};
-var MockTransaction = class {
-	async begin() {}
-	async commit() {}
-	async rollback() {}
-	async queryObject(query, params = []) {
-		return resolveQuery(query, params);
-	}
-};
-var MockTailordbClient = class {
-	#record;
-	constructor(config) {
-		this.#record = {
-			namespace: config?.namespace,
-			ended: false
-		};
-		getState().createdClients.push(this.#record);
-	}
-	async connect() {}
-	async end() {
-		this.#record.ended = true;
-	}
-	async queryObject(query, params = []) {
-		return resolveQuery(query, params);
-	}
-	createTransaction(name) {
-		if (!name) throw new Error("Transaction name must be a non-empty string");
-		return new MockTransaction();
-	}
-};
-function resolveQuery(query, params) {
-	const state = getState();
-	state.executedQueries.push({
-		query,
-		params
-	});
-	if (state.queryResultQueue.length > 0) return new MockQueryResult(state.queryResultQueue.shift());
-	return new MockQueryResult(state.queryResolver(query, params) ?? []);
-}
-function mockTriggerJobFunction(jobName, args) {
-	const state = getState();
-	state.triggeredJobs.push({
-		jobName,
-		args
-	});
-	if (state.jobResultQueue.length > 0) return state.jobResultQueue.shift();
-	return state.jobHandler(jobName, args);
-}
-async function mockTriggerWorkflow(workflowName, args, options) {
-	const state = getState();
-	state.workflowCalls.push({
-		method: "triggerWorkflow",
-		args: [
-			workflowName,
-			args,
-			options
-		]
-	});
-	const handler = state.triggerHandler;
-	return typeof handler === "function" ? handler(workflowName, args, options) : handler;
-}
-function mockWait(key, payload) {
-	const state = getState();
-	state.workflowCalls.push({
-		method: "wait",
-		args: [key, payload]
-	});
-	const handler = state.waitHandler;
-	return typeof handler === "function" ? handler(key, payload) : handler;
-}
-async function mockResolve(executionId, key, callback) {
-	const state = getState();
-	state.workflowCalls.push({
-		method: "resolve",
-		args: [
-			executionId,
-			key,
-			callback
-		]
-	});
-	if (state.resolveHandler) await state.resolveHandler(executionId, key, callback);
-}
-function mockGetInvoker() {
-	return null;
-}
-async function mockGetSecrets(vault, names) {
-	const state = getState();
-	state.secretCalls.push({
-		method: "getSecrets",
-		vault,
-		names
-	});
-	const vaultData = state.secretStore[vault] ?? {};
-	const result = {};
-	for (const name of names) if (name in vaultData) result[name] = vaultData[name];
-	return result;
-}
-async function mockGetSecret(vault, name) {
-	const state = getState();
-	state.secretCalls.push({
-		method: "getSecret",
-		vault,
-		name
-	});
-	return state.secretStore[vault]?.[name];
-}
-async function mockGetConnectionToken(connectionName) {
-	const state = getState();
-	state.authCalls.push({ connectionName });
-	return state.authTokens[connectionName] ?? { access_token: "mock-token" };
-}
-const IDP_DEFAULTS = {
-	users: {
-		users: [],
-		nextPageToken: null,
-		totalCount: 0
-	},
-	user: {
-		id: "mock-id",
-		name: "mock-user",
-		disabled: false
-	},
-	userByName: {
-		id: "mock-id",
-		name: "mock-user",
-		disabled: false
-	},
-	createUser: {
-		id: "mock-id",
-		name: "mock-user",
-		disabled: false
-	},
-	updateUser: {
-		id: "mock-id",
-		name: "mock-user",
-		disabled: false
-	},
-	deleteUser: true,
-	sendPasswordResetEmail: true
-};
-function resolveIdpCall(method, args, namespace) {
-	const state = getState();
-	state.idpCalls.push({
-		method,
-		args,
-		namespace
-	});
-	if (state.idpResultQueue.length > 0) return state.idpResultQueue.shift();
-	const resolved = state.idpResolver(method, args, namespace);
-	if (resolved != null) return resolved;
-	const fallback = IDP_DEFAULTS[method];
-	return fallback === void 0 ? void 0 : structuredClone(fallback);
-}
-var MockIdpClient = class {
-	#namespace;
-	constructor(config) {
-		this.#namespace = config.namespace;
-	}
-	async users(options) {
-		return resolveIdpCall("users", [options], this.#namespace);
-	}
-	async user(userId) {
-		return resolveIdpCall("user", [userId], this.#namespace);
-	}
-	async userByName(name) {
-		return resolveIdpCall("userByName", [name], this.#namespace);
-	}
-	async createUser(input) {
-		return resolveIdpCall("createUser", [input], this.#namespace);
-	}
-	async updateUser(input) {
-		return resolveIdpCall("updateUser", [input], this.#namespace);
-	}
-	async deleteUser(userId) {
-		return resolveIdpCall("deleteUser", [userId], this.#namespace);
-	}
-	async sendPasswordResetEmail(input) {
-		return resolveIdpCall("sendPasswordResetEmail", [input], this.#namespace);
-	}
-};
-function isUtf8(encoding) {
-	return encoding === "UTF8" || encoding === "UTF-8";
-}
-function defaultIconvResult(method, args) {
-	switch (method) {
-		case "convert":
-		case "convertBuffer": return isUtf8(args[2]) ? "" : new Uint8Array();
-		case "decode": return "";
-		case "encode": return isUtf8(args[1]) ? "" : new Uint8Array();
-		case "encodings": return [];
-		default: return;
-	}
-}
-function resolveIconvCall(method, args) {
-	const state = getState();
-	state.iconvCalls.push({
-		method,
-		args: [...args]
-	});
-	if (state.iconvResolver) {
-		const result = state.iconvResolver(method, args);
-		if (result != null) return result;
-	}
-	return defaultIconvResult(method, args);
-}
-function mockConvert(str, fromEncoding, toEncoding) {
-	return resolveIconvCall("convert", [
-		str,
-		fromEncoding,
-		toEncoding
-	]);
-}
-function mockConvertBuffer(buffer, fromEncoding, toEncoding) {
-	return resolveIconvCall("convertBuffer", [
-		buffer,
-		fromEncoding,
-		toEncoding
-	]);
-}
-function mockDecode(buffer, encoding) {
-	return resolveIconvCall("decode", [buffer, encoding]);
-}
-function mockEncode(str, encoding) {
-	return resolveIconvCall("encode", [str, encoding]);
-}
-function mockEncodings() {
-	return resolveIconvCall("encodings", []);
-}
-var MockIconv = class {
-	#fromEncoding;
-	#toEncoding;
-	constructor(fromEncoding, toEncoding) {
-		this.#fromEncoding = fromEncoding;
-		this.#toEncoding = toEncoding;
-	}
-	convert(input) {
-		return resolveIconvCall("convert", [
-			input,
-			this.#fromEncoding,
-			this.#toEncoding
-		]);
-	}
-};
-const FILE_DEFAULTS = {
-	upload: { metadata: {
-		fileSize: 0,
-		sha256sum: ""
-	} },
-	download: {
-		data: 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: ""
-	} }
-};
-function resolveFileCall(method, namespace, typeName, fieldName, recordId) {
-	const state = getState();
-	const call = {
-		method,
-		namespace,
-		typeName,
-		fieldName,
-		recordId
-	};
-	state.fileCalls.push(call);
-	if (state.fileResultQueue.length > 0) return state.fileResultQueue.shift();
-	const resolved = state.fileResolver(method, call);
-	if (resolved != null) return resolved;
-	const fallback = FILE_DEFAULTS[method];
-	return fallback === void 0 ? void 0 : structuredClone(fallback);
-}
-const mockTailordbFile = {
-	async upload(namespace, typeName, fieldName, recordId, _data, _options) {
-		return resolveFileCall("upload", namespace, typeName, fieldName, recordId);
-	},
-	async download(namespace, typeName, fieldName, recordId) {
-		return resolveFileCall("download", namespace, typeName, fieldName, recordId);
-	},
-	async downloadAsBase64(namespace, typeName, fieldName, recordId) {
-		return resolveFileCall("downloadAsBase64", namespace, typeName, fieldName, recordId);
-	},
-	async delete(namespace, typeName, fieldName, recordId) {
-		resolveFileCall("delete", namespace, typeName, fieldName, recordId);
-	},
-	async getMetadata(namespace, typeName, fieldName, recordId) {
-		return resolveFileCall("getMetadata", namespace, typeName, fieldName, recordId);
-	},
-	async openDownloadStream(namespace, typeName, fieldName, recordId) {
-		return toFileStream(resolveFileCall("openDownloadStream", namespace, typeName, fieldName, recordId));
-	},
-	async downloadStream(namespace, typeName, fieldName, recordId) {
-		const resolved = resolveFileCall("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, _readableStream, _options) {
-		return resolveFileCall("uploadStream", namespace, typeName, fieldName, recordId);
-	}
-};
-function toFileStream(value) {
-	if (value !== null && typeof value === "object" && Symbol.asyncIterator in value && typeof value.close === "function") return value;
-	if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) throw new TypeError("fileMock.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;
-	}
-	const empty = {
-		async next() {
-			return {
-				done: true,
-				value: void 0
-			};
-		},
-		async close() {},
-		[Symbol.asyncIterator]() {
-			return empty;
-		}
-	};
-	return empty;
-}
-function assertStreamValue(v) {
-	if (v === null || typeof v !== "object") throw new TypeError(`fileMock.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("fileMock.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;
-	if (type !== "metadata" && type !== "chunk" && type !== "complete") throw new TypeError(`fileMock.openDownloadStream expected a StreamValue item with type "metadata" | "chunk" | "complete"; got ${JSON.stringify(type)}.`);
-}
-var TailorErrorsMock = class extends Error {
-	errors;
-	constructor(errors) {
-		if (!Array.isArray(errors)) throw new TypeError("TailorErrors: errors must be an array");
-		const validated = errors.map((e, i) => {
-			if (typeof e.message !== "string") throw new TypeError(`TailorErrors: errors[${i}].message must be a string`);
-			if (!Array.isArray(e.path)) throw new TypeError(`TailorErrors: errors[${i}].path must be an array`);
-			return {
-				message: e.message,
-				path: e.path
-			};
-		});
-		super(`TailorErrors: ${JSON.stringify({ errors: validated })}`);
-		this.name = "TailorErrors";
-		this.errors = validated;
-	}
-};
-var TailorErrorMessageMock = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "TailorErrorMessage";
-	}
-};
-var TailorDBFileErrorMock = class extends Error {
-	code;
-	cause;
-	constructor(message, code, cause) {
-		super(message);
-		this.name = "TailorDBFileError";
-		this.code = code;
-		this.cause = cause;
-	}
-};
-/**
-* Inject all platform API mocks into globalThis.
-* Called by the tailor-runtime Vitest environment during setup.
-* @param global - The global object to inject mocks into
-*/
-function injectMocks(global) {
-	const g = global;
-	g[STATE_KEY] = createDefaultState();
-	g[RUNTIME_FLAG_KEY] = true;
-	g.tailordb = {
-		Client: MockTailordbClient,
-		file: mockTailordbFile
-	};
-	g.tailor = {
-		secretmanager: {
-			getSecrets: mockGetSecrets,
-			getSecret: mockGetSecret
-		},
-		authconnection: { getConnectionToken: mockGetConnectionToken },
-		workflow: {
-			triggerJobFunction: mockTriggerJobFunction,
-			triggerWorkflow: mockTriggerWorkflow,
-			wait: mockWait,
-			resolve: mockResolve
-		},
-		context: { getInvoker: mockGetInvoker },
-		idp: { Client: MockIdpClient },
-		iconv: {
-			convert: mockConvert,
-			convertBuffer: mockConvertBuffer,
-			decode: mockDecode,
-			encode: mockEncode,
-			encodings: mockEncodings,
-			Iconv: MockIconv
-		}
-	};
-	g.TailorErrors = TailorErrorsMock;
-	g.TailorErrorMessage = TailorErrorMessageMock;
-	g.TailorDBFileError = TailorDBFileErrorMock;
-}
-/**
-* Remove all injected mocks from globalThis.
-* Called by the tailor-runtime Vitest environment during teardown.
-* @param global - The global object to clean up mocks from
-*/
-function cleanupMocks(global) {
-	const g = global;
-	delete g.tailordb;
-	delete g.tailor;
-	delete g.TailorErrors;
-	delete g.TailorErrorMessage;
-	delete g.TailorDBFileError;
-	delete g[STATE_KEY];
-	delete g[RUNTIME_FLAG_KEY];
-	clearWorkflowTestEnv();
-}
-
-//#endregion
-export { fileMock as a, injectMocks as c, workflowMock as d, cleanupMocks as i, secretmanagerMock as l, STATE_KEY as n, iconvMock as o, authconnectionMock as r, idpMock as s, RUNTIME_FLAG_KEY as t, tailordbMock as u };
-//# sourceMappingURL=mock-B6PI49C_.mjs.map