@tailor-platform/sdk 1.57.0 → 1.59.0

package/dist/mock-Dpu__UeJ.mjs

@@ -0,0 +1,805 @@
+
+import { a as getRegisteredWorkflow, d as buildJobContext, f as clearWorkflowTestEnv, i as getRegisteredJob, m as platformSerialize, p as writeWorkflowTestEnv, t as TRIGGER_DEFAULT } from "./registry-D0uB0OrK.mjs";
+import { vi } from "vitest";
+
+//#region src/vitest/mock.ts
+/**
+* Mock controls for Tailor Platform APIs (vitest).
+*
+* Each `xMock()` factory installs `vi.fn()`-backed mocks for one platform
+* namespace onto `globalThis` when acquired, and restores the previous value
+* when the `using` scope exits. State lives in the per-acquisition vi.fns /
+* closures — there is no shared global state bag — so nested/sequential scopes
+* are isolated and namespaces never interfere with each other.
+*
+* Acquire a mock with a `using` declaration:
+*
+* ```ts
+* test("...", () => {
+*   using wf = mockWorkflow();
+*   wf.setJobHandler(() => ({ ok: true }));
+* }); // previous workflow mock restored here
+* ```
+*
+* The friendly helpers (`setJobHandler`, `enqueueResult`, `triggeredJobs`, …)
+* are thin wrappers over the underlying vi.fns, which are also exposed directly
+* (`wf.triggerJobFunction`) for native matchers like
+* `expect(wf.triggerJobFunction).toHaveBeenCalledWith(...)`.
+*/
+function withDispose(facade, dispose) {
+	Object.defineProperty(facade, Symbol.dispose, {
+		value: dispose,
+		enumerable: false,
+		writable: true,
+		configurable: true
+	});
+	return facade;
+}
+function tailorRoot() {
+	const g = globalThis;
+	if (!g.tailor) g.tailor = { context: { getInvoker: () => null } };
+	return g.tailor;
+}
+function tailordbRoot() {
+	const g = globalThis;
+	if (!g.tailordb) g.tailordb = {};
+	return g.tailordb;
+}
+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;
+	});
+}
+/**
+* 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) => {
+		const body = getRegisteredJob(jobName);
+		return body ? body(args, buildJobContext()) : null;
+	};
+	const defaultTriggerWorkflow = async (workflowName, args, _options) => {
+		const wf = getRegisteredWorkflow(workflowName);
+		if (wf) await installedTriggerJobFunction(wf.mainJobName, args);
+		return TRIGGER_DEFAULT;
+	};
+	const triggerJobFunction = vi.fn(defaultTriggerJob);
+	const triggerWorkflow = vi.fn(defaultTriggerWorkflow);
+	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])),
+		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 `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 `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);
+			wait.mockReset();
+			wait.mockImplementation(() => null);
+			resolve.mockReset();
+			resolve.mockImplementation(async () => {});
+			clearWorkflowTestEnv();
+		}
+	}, () => {
+		root.workflow = prev;
+		clearWorkflowTestEnv();
+	});
+}
+const SECRET_STORE = Symbol("tailorSecretStore");
+/**
+* Acquire a disposable mock for `tailor.secretmanager`. The secret store is
+* inherited (cloned) from the currently-installed mock on acquisition and
+* restored on dispose, so secrets seeded outside the test survive across
+* `using` scopes while per-test `setSecrets()` overrides stay isolated.
+* @returns Disposable SecretManager mock control object
+* @example
+* ```typescript
+* import { mockSecretmanager } from "@tailor-platform/sdk/vitest";
+*
+* test("reads secrets from vault", async () => {
+*   using sm = mockSecretmanager();
+*   sm.setSecrets({ "my-vault": { API_KEY: "sk-123" } });
+*   // …
+* });
+* ```
+*/
+function mockSecretmanager() {
+	const root = tailorRoot();
+	const prev = root.secretmanager;
+	const holder = { store: structuredClone(prev?.[SECRET_STORE]?.store ?? {}) };
+	const getSecret = vi.fn(async (vault, name) => holder.store[vault]?.[name]);
+	const getSecrets = vi.fn(async (vault, names) => {
+		const vaultData = holder.store[vault] ?? {};
+		const result = {};
+		for (const name of names) if (name in vaultData) result[name] = vaultData[name];
+		return result;
+	});
+	root.secretmanager = {
+		getSecret,
+		getSecrets,
+		[SECRET_STORE]: holder
+	};
+	return withDispose({
+		/** The `getSecret` `vi.fn`. */
+		getSecret,
+		/** The `getSecrets` `vi.fn`. */
+		getSecrets,
+		setSecrets(secrets) {
+			holder.store = secrets;
+		},
+		get calls() {
+			return [...getSecret.mock.calls.map((args, i) => ({
+				order: getSecret.mock.invocationCallOrder[i] ?? 0,
+				call: {
+					method: "getSecret",
+					vault: args[0],
+					name: args[1]
+				}
+			})), ...getSecrets.mock.calls.map((args, i) => ({
+				order: getSecrets.mock.invocationCallOrder[i] ?? 0,
+				call: {
+					method: "getSecrets",
+					vault: args[0],
+					names: args[1]
+				}
+			}))].toSorted((a, b) => a.order - b.order).map((e) => e.call);
+		},
+		reset() {
+			holder.store = {};
+			getSecret.mockClear();
+			getSecrets.mockClear();
+		}
+	}, () => {
+		root.secretmanager = prev;
+	});
+}
+/**
+* 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;
+	});
+}
+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
+};
+/**
+* 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);
+	});
+	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;
+	});
+}
+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;
+	}
+}
+/**
+* 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;
+	});
+}
+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 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("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(`openDownloadStream expected a StreamValue item ({ type: "metadata" | "chunk" | "complete", ... }); got ${typeof v === "object" ? "null" : typeof v}.`);
+	if (v instanceof ArrayBuffer || ArrayBuffer.isView(v)) throw new TypeError("openDownloadStream expected a StreamValue item, got raw bytes. Wrap the bytes in a structured chunk first (e.g. { type: \"chunk\", data, position }).");
+	const type = v.type;
+	if (type !== "metadata" && type !== "chunk" && type !== "complete") throw new TypeError(`openDownloadStream expected a StreamValue item with type "metadata" | "chunk" | "complete"; got ${JSON.stringify(type)}.`);
+}
+/**
+* Acquire a disposable mock for `tailordb.file`. Restored on dispose.
+* @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 openDownloadStream(namespace, typeName, fieldName, recordId) {
+			return toFileStream(handle("openDownloadStream", namespace, typeName, fieldName, recordId));
+		},
+		async downloadStream(namespace, typeName, fieldName, recordId) {
+			const resolved = handle("downloadStream", namespace, typeName, fieldName, recordId);
+			if (resolved != null) return resolved;
+			return {
+				body: new ReadableStream({ start(c) {
+					c.close();
+				} }),
+				metadata: {
+					contentType: "",
+					fileSize: 0,
+					sha256sum: "",
+					lastUploadedAt: ""
+				}
+			};
+		},
+		async uploadStream(namespace, typeName, fieldName, recordId) {
+			return handle("uploadStream", namespace, typeName, fieldName, recordId);
+		}
+	};
+	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
+export { mockSecretmanager as a, mockIdp as i, mockFile as n, mockTailordb as o, mockIconv as r, mockWorkflow as s, mockAuthconnection as t };
+//# sourceMappingURL=mock-Dpu__UeJ.mjs.map