@tailor-platform/sdk 1.46.0 → 1.47.1

package/dist/vitest/index.d.mts

@@ -0,0 +1,345 @@
+/// <reference types="@tailor-platform/function-types" />
+import { Plugin } from "vitest/config";
+
+//#region src/vitest/mock.d.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.
+ */
+type QueryResolver = (query: string, params: unknown[]) => unknown[];
+type JobHandler = (jobName: string, args: unknown) => unknown;
+type IdpResolver = (method: string, args: unknown[], namespace: string) => unknown;
+type FileResolver = (method: string, call: FileCall) => unknown;
+type IconvResolver = (method: string, args: unknown[]) => unknown;
+type TriggerWorkflowOptions = {
+  authInvoker?: {
+    namespace: string;
+    machineUserName: string;
+  };
+};
+type TriggerHandlerFn = (workflowName: string, args: unknown, options?: TriggerWorkflowOptions) => string;
+type WaitHandlerFn = (key: string, payload: unknown) => unknown;
+type ResolveHandler = (executionId: string, key: string, callback: (payload: unknown) => unknown) => unknown | Promise<unknown>;
+type SetWaitHandler = {
+  (handler: WaitHandlerFn): void;
+  (handler: unknown): void;
+};
+interface ExecutedQuery {
+  query: string;
+  params: unknown[];
+}
+interface CreatedClient {
+  namespace: string | undefined;
+  ended: boolean;
+}
+interface TriggeredJob {
+  jobName: string;
+  args: unknown;
+}
+interface SecretCall {
+  method: "getSecret" | "getSecrets";
+  vault: string;
+  name?: string;
+  names?: readonly string[];
+}
+interface AuthConnectionCall {
+  connectionName: string;
+}
+interface IdpCall {
+  method: string;
+  args: unknown[];
+  namespace: string;
+}
+interface FileCall {
+  method: string;
+  namespace: string;
+  typeName: string;
+  fieldName: string;
+  recordId: string;
+}
+interface IconvCall {
+  method: string;
+  args: unknown[];
+}
+interface WorkflowCall {
+  method: "triggerWorkflow" | "wait" | "resolve";
+  args: unknown[];
+}
+/**
+ * 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)
+ *   );
+ * });
+ * ```
+ */
+declare 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: QueryResolver): void;
+  /**
+   * 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: unknown[]): void;
+  /**
+   * 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: unknown[][]): void;
+  /**
+   * All queries executed via `queryObject`, in order.
+   * @returns Executed queries array
+   */
+  readonly executedQueries: ExecutedQuery[];
+  /**
+   * All TailorDB clients created, with their namespace and end state.
+   * @returns Created clients array
+   */
+  readonly createdClients: CreatedClient[]; /** Reset all TailorDB mock state. Call in `beforeEach`. */
+  reset(): void;
+};
+/**
+ * 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" },
+ *   ]);
+ * });
+ * ```
+ */
+declare 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: JobHandler): void;
+  /**
+   * 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: unknown): void;
+  /**
+   * Enqueue results for multiple subsequent `triggerJobFunction` calls.
+   * @param results - Results to enqueue, one per upcoming call
+   */
+  enqueueResults(...results: unknown[]): void;
+  /**
+   * All jobs triggered via `triggerJobFunction`, in order.
+   * @returns Triggered jobs array
+   */
+  readonly triggeredJobs: TriggeredJob[];
+  /**
+   * 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: string | TriggerHandlerFn): void;
+  /**
+   * 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: SetWaitHandler;
+  /**
+   * 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: ResolveHandler): void;
+  /**
+   * Calls to triggerWorkflow, wait, resolve (not triggerJobFunction — use triggeredJobs).
+   * @returns Workflow calls array
+   */
+  readonly calls: WorkflowCall[];
+  /**
+   * `tailor.workflow.wait` calls reshaped as `{ key, payload }` for assertions.
+   * @returns Wait call records
+   */
+  readonly waitCalls: {
+    key: string;
+    payload: unknown;
+  }[];
+  /**
+   * `tailor.workflow.resolve` calls reshaped as `{ executionId, key }` for assertions.
+   * @returns Resolve call records
+   */
+  readonly resolveCalls: {
+    executionId: string;
+    key: string;
+  }[]; /** Reset all workflow mock state. Call in `beforeEach`. */
+  reset(): void;
+};
+/** Mock control for `tailor.secretmanager` — secret store and call recording. */
+declare const secretmanagerMock: {
+  setSecrets(secrets: Record<string, Record<string, string>>): void;
+  readonly calls: SecretCall[];
+  reset(): void;
+};
+/** Mock control for `tailor.authconnection` — token store and call recording. */
+declare const authconnectionMock: {
+  setTokens(tokens: Record<string, unknown>): void;
+  readonly calls: AuthConnectionCall[];
+  reset(): void;
+};
+/** Mock control for `tailor.idp` — IDP client responses and call recording. */
+declare const idpMock: {
+  setResolver(resolver: IdpResolver): void;
+  /**
+   * 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: unknown): void;
+  /**
+   * Enqueue results for multiple subsequent IDP calls.
+   * @param results - Results to enqueue, one per upcoming call
+   */
+  enqueueResults(...results: unknown[]): void;
+  readonly calls: IdpCall[];
+  reset(): void;
+};
+/** Mock control for `tailordb.file` — file operation responses and call recording. */
+declare const fileMock: {
+  setResolver(resolver: FileResolver): void;
+  /**
+   * 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: unknown): void;
+  /**
+   * Enqueue results for multiple subsequent `tailordb.file` calls.
+   * @param results - Results to enqueue, one per upcoming call
+   */
+  enqueueResults(...results: unknown[]): void;
+  readonly calls: FileCall[];
+  reset(): void;
+};
+/** Mock control for `tailor.iconv` — encoding call recording. */
+declare const iconvMock: {
+  setResolver(resolver: IconvResolver): void;
+  readonly calls: IconvCall[];
+  reset(): void;
+};
+//#endregion
+//#region src/vitest/index.d.ts
+/**
+ * Creates Vitest plugins that emulate the Tailor Platform function runtime environment.
+ *
+ * **Beta:** This API may change in future releases.
+ *
+ * ## What it does
+ *
+ * 1. **Node.js module blocking** (transform hook) — Imports of `node:*` modules
+ *    (and bare builtins like `crypto`, `fs`) in non-test source files are replaced
+ *    with code that throws an error with a suggestion for the Web Standard API alternative.
+ *    Test files are exempt and can use `node:*` freely. Test file patterns are read
+ *    from the resolved Vitest config (`test.include`).
+ *
+ * 2. **Node.js globals removal** (environment + setup) — Only globals available in the
+ *    Tailor Platform runtime are kept (whitelist: ECMAScript standard, Web Standard APIs
+ *    from bootstrap.js, platform mocks). All others (`Buffer`, `global`, `setImmediate`,
+ *    `__dirname`, `__filename`, etc.) are removed. `performance` is removed per-test
+ *    via beforeEach/afterEach since Vitest needs it during initialization.
+ *
+ * 3. **Platform API mocks** (environment) — All platform APIs are auto-injected with
+ *    control objects: `tailordbMock`, `workflowMock`, `secretmanagerMock`,
+ *    `authconnectionMock`, `idpMock`, `fileMock`, `iconvMock`. Each provides response
+ *    configuration, call recording, and reset.
+ *
+ * 4. **Environment resolution** — Rewrites `environment: "tailor-runtime"` to the
+ *    absolute path of the bundled environment module via the config hook.
+ *
+ * ## Known limitations
+ *
+ * - **`process`** and **`require`** are NOT removed or blocked. Vitest's internal
+ *   runner depends on them. On the real Tailor Platform runtime, they do not exist.
+ * - **Dynamic `import()`** of bundled files (via `createImportMain()`) bypasses
+ *   the transform hook since those files are loaded through Node.js native loader.
+ * ## Options
+ *
+ * - **`config`** — Path to `tailor.config.ts`. Loads `defineSecretManager()` values
+ *   into `secretmanagerMock` so `getSecret()` returns the configured values.
+ * @example
+ * ```typescript
+ * // vitest.config.ts
+ * import { defineConfig } from "vitest/config";
+ * import { tailorRuntime } from "@tailor-platform/sdk/vitest";
+ *
+ * export default defineConfig({
+ *   plugins: [tailorRuntime({ config: "./tailor.config.ts" })],
+ *   test: {
+ *     environment: "tailor-runtime",
+ *   },
+ * });
+ * ```
+ * @param options - Optional configuration
+ * @param options.config - Path to tailor.config.ts to load SecretManager values into mock
+ * @returns Array of Vite plugins
+ */
+declare function tailorRuntime(options?: {
+  config?: string;
+}): Plugin[];
+//#endregion
+export { authconnectionMock, fileMock, iconvMock, idpMock, secretmanagerMock, tailorRuntime, tailordbMock, workflowMock };
+//# sourceMappingURL=index.d.mts.map

package/dist/vitest/index.mjs

@@ -0,0 +1,350 @@
+
+import { a as fileMock, d as workflowMock, l as secretmanagerMock, o as iconvMock, r as authconnectionMock, s as idpMock, u as tailordbMock } from "../mock-BP-9O5On.mjs";
+import { builtinModules } from "node:module";
+import { fileURLToPath } from "node:url";
+import { dirname, isAbsolute, matchesGlob, relative, resolve } from "node:path";
+
+//#region src/vitest/blocked-modules.ts
+/**
+* Blocked Node.js built-in modules and their Web Standard API alternatives.
+*
+* The Tailor Platform runtime only provides Web Standard APIs.
+* These Node.js modules are not available and should be replaced with
+* the suggested alternatives.
+*/
+const SUGGESTIONS = {
+	crypto: "Use the Web Crypto API (globalThis.crypto) instead.",
+	buffer: "Use Uint8Array or ArrayBuffer instead.",
+	fs: "File system access is not available in the Tailor Platform runtime.",
+	"fs/promises": "File system access is not available in the Tailor Platform runtime.",
+	path: "Use URL or URLPattern for path manipulation.",
+	http: "Use the Fetch API (globalThis.fetch) for HTTP requests instead.",
+	https: "Use the Fetch API (globalThis.fetch) for HTTPS requests instead.",
+	url: "Use the URL and URLSearchParams Web APIs instead.",
+	util: "Use Web Standard APIs instead.",
+	stream: "Use Web Streams API (ReadableStream, WritableStream, TransformStream) instead.",
+	"stream/web": "Use Web Streams API (ReadableStream, WritableStream, TransformStream) instead.",
+	events: "Use EventTarget instead.",
+	zlib: "Use CompressionStream and DecompressionStream Web APIs instead.",
+	querystring: "Use URLSearchParams instead.",
+	string_decoder: "Use TextDecoder instead."
+};
+const BLOCKED_MODULES = /* @__PURE__ */ new Set();
+for (const mod of builtinModules) {
+	BLOCKED_MODULES.add(mod);
+	BLOCKED_MODULES.add(`node:${mod}`);
+}
+/**
+* Check if a module specifier is a blocked Node.js built-in.
+* @param specifier - Module specifier to check (e.g. "node:crypto", "fs")
+* @returns Whether the specifier is blocked
+*/
+function isBlockedModule(specifier) {
+	return BLOCKED_MODULES.has(specifier);
+}
+/**
+* Get the error message for a blocked module import.
+* @param specifier - Module specifier that was blocked
+* @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 base = `"${specifier}" is not available in the Tailor Platform runtime.`;
+	return suggestion ? `${base} ${suggestion}` : base;
+}
+
+//#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([
+	"ImportDeclaration",
+	"ExportNamedDeclaration",
+	"ExportAllDeclaration"
+]);
+const UNSAFE_BINDING_NAMES = new Set([
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"null",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield",
+	"let",
+	"static",
+	"implements",
+	"interface",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"await",
+	"arguments",
+	"eval"
+]);
+const ID_START = /^[A-Za-z_$]/;
+const ID_CONT = /^[A-Za-z0-9_$]*$/;
+function isSafeBindingName(name) {
+	if (UNSAFE_BINDING_NAMES.has(name)) return false;
+	if (name.length === 0) return false;
+	return ID_START.test(name[0] ?? "") && ID_CONT.test(name.slice(1));
+}
+function buildBlockedReplacement(node, message) {
+	const literal = JSON.stringify(message);
+	const throwStmt = `throw new Error(${literal});`;
+	const throwExpr = `(() => { throw new Error(${literal}); })()`;
+	if (node.type === "ExportNamedDeclaration") {
+		const specs = node.specifiers ?? [];
+		const stubs = [];
+		for (const spec of specs) {
+			const exportedName = spec.exported?.name;
+			if (typeof exportedName !== "string") continue;
+			if (exportedName === "default") {
+				stubs.push(`export default ${throwExpr};`);
+				continue;
+			}
+			if (!isSafeBindingName(exportedName)) return throwStmt;
+			stubs.push(`export const ${exportedName} = ${throwExpr};`);
+		}
+		return stubs.length > 0 ? stubs.join(" ") : throwStmt;
+	}
+	if (node.type === "ExportAllDeclaration") {
+		const exportedName = node.exported?.name;
+		if (typeof exportedName === "string" && isSafeBindingName(exportedName)) return `export const ${exportedName} = ${throwExpr};`;
+		return throwStmt;
+	}
+	return throwStmt;
+}
+/**
+* Vite plugin that blocks Node.js built-in module imports from production code.
+*
+* Uses the `transform` hook to walk the Rollup-provided AST of non-test source
+* files for static `node:*` imports and re-exports.
+* `ImportDeclaration` and bare `export * from "..."` are replaced with a
+* `throw new Error(...)` statement so the failure surfaces at evaluation time.
+* `ExportNamedDeclaration` (`export { x, y as z } from "..."`) and namespaced
+* `export * as ns from "..."` are rewritten to per-binding stub exports
+* (`export const x = (() => { throw new Error(...) })();`). The IIFE throws
+* eagerly during module evaluation (same timing as a top-level `throw`), but
+* preserving the declared export bindings ensures the surfaced error is the
+* actual "node:* not available" message rather than an opaque
+* "missing export" raised by the loader.
+* Vitest treats `node:*` as external SSR modules (skipping `resolveId`), so
+* source-level transformation is the only reliable interception point.
+* Runs in the default phase (no `enforce: "pre"`) so esbuild's TypeScript
+* transform strips `import type` first; only runtime imports reach this hook.
+* Node.js globals not in the platform runtime are removed by the environment (whitelist-based).
+* Test file patterns are read from the resolved Vitest config (`test.include`).
+* Vitest setup files (`test.setupFiles`) and global-setup files
+* (`test.globalSetup`) are also exempted: they run in the test runner host,
+* not in the emulated platform runtime, so they may freely use `node:*`
+* modules (e.g. `node:url` for `pathToFileURL`).
+* @returns Vite plugin
+*/
+function createBlockPlugin() {
+	let isTestFile = () => false;
+	let isUserSourceFile = () => false;
+	return {
+		name: "tailor-runtime-block-node",
+		configResolved(config) {
+			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 includePairs = [{
+				root,
+				patterns: testConfig?.include ?? DEFAULT_TEST_INCLUDE
+			}];
+			for (const project of testConfig?.projects ?? []) {
+				const projectTest = project?.test;
+				if (!projectTest) continue;
+				const projectRoot = projectTest.root ?? root;
+				for (const f of toAbsolutePaths(projectTest.setupFiles, projectRoot)) exemptHostFiles.add(f);
+				for (const f of toAbsolutePaths(projectTest.globalSetup, projectRoot)) exemptHostFiles.add(f);
+				includePairs.push({
+					root: projectRoot,
+					patterns: projectTest.include ?? DEFAULT_TEST_INCLUDE
+				});
+			}
+			isTestFile = (id) => {
+				if (exemptHostFiles.has(id)) return true;
+				return includePairs.some(({ root: r, patterns }) => {
+					const candidate = isAbsolute(id) ? relative(r, id) : id;
+					return patterns.some((pattern) => matchesGlob(candidate, pattern));
+				});
+			};
+			isUserSourceFile = (id) => {
+				if (!isAbsolute(id)) return false;
+				const rel = relative(root, id);
+				return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+			};
+		},
+		transform(code, id) {
+			const queryIdx = id.search(/[?#]/);
+			const cleanId = queryIdx === -1 ? id : id.slice(0, queryIdx);
+			if (isTestFile(cleanId)) return void 0;
+			if (cleanId.includes("node_modules")) return void 0;
+			if (!isUserSourceFile(cleanId)) return void 0;
+			let ast;
+			try {
+				ast = this.parse(code);
+			} catch {
+				return;
+			}
+			const replacements = [];
+			for (const node of ast.body) {
+				if (!IMPORT_LIKE_TYPES.has(node.type)) continue;
+				const specifier = node.source?.value;
+				if (typeof specifier !== "string") continue;
+				if (isBlockedModule(specifier)) replacements.push({
+					start: node.start,
+					end: node.end,
+					replacement: buildBlockedReplacement(node, getBlockedMessage(specifier))
+				});
+			}
+			if (replacements.length === 0) return void 0;
+			let transformed = code;
+			for (const r of replacements.sort((a, b) => b.start - a.start)) transformed = transformed.slice(0, r.start) + r.replacement + transformed.slice(r.end);
+			return {
+				code: transformed,
+				map: null
+			};
+		}
+	};
+}
+const ENVIRONMENT_NAME = "tailor-runtime";
+/**
+* Vite plugin that resolves the tailor-runtime environment and injects setup files.
+*
+* Vitest resolves environments starting with "." or "/" as file paths.
+* This plugin rewrites `environment: "tailor-runtime"` to the absolute path
+* of the bundled environment module, both at the top-level and per-project.
+* It also injects the setup file that removes Vitest-dependent globals
+* (like `performance`) per-test via beforeEach/afterEach hooks.
+* @param options - Optional configuration
+* @param options.config - Path to tailor.config.ts to load SecretManager values into mock
+* @returns Vite plugin
+*/
+function createEnvironmentPlugin(options) {
+	const currentDir = dirname(fileURLToPath(import.meta.url));
+	const environmentPath = resolve(currentDir, "environment.mjs");
+	const setupPath = resolve(currentDir, "setup.mjs");
+	return {
+		name: "tailor-runtime-environment",
+		config(config) {
+			const testConfig = config.test;
+			let usesTailorRuntime = false;
+			if (testConfig?.environment === ENVIRONMENT_NAME) {
+				testConfig.environment = environmentPath;
+				usesTailorRuntime = true;
+			}
+			if (testConfig?.projects) for (const project of testConfig.projects) {
+				const projectTest = project.test;
+				if (projectTest?.environment === ENVIRONMENT_NAME) {
+					projectTest.environment = environmentPath;
+					usesTailorRuntime = true;
+				}
+			}
+			delete process.env.__TAILOR_RUNTIME_CONFIG;
+			if (options?.config && usesTailorRuntime) {
+				const configAbsPath = resolve(config.root ?? process.cwd(), options.config);
+				process.env.__TAILOR_RUNTIME_CONFIG = configAbsPath;
+			}
+			if (testConfig && typeof testConfig.setupFiles === "string") testConfig.setupFiles = [testConfig.setupFiles];
+			return { test: { setupFiles: [setupPath] } };
+		}
+	};
+}
+
+//#endregion
+//#region src/vitest/index.ts
+/**
+* Creates Vitest plugins that emulate the Tailor Platform function runtime environment.
+*
+* **Beta:** This API may change in future releases.
+*
+* ## What it does
+*
+* 1. **Node.js module blocking** (transform hook) — Imports of `node:*` modules
+*    (and bare builtins like `crypto`, `fs`) in non-test source files are replaced
+*    with code that throws an error with a suggestion for the Web Standard API alternative.
+*    Test files are exempt and can use `node:*` freely. Test file patterns are read
+*    from the resolved Vitest config (`test.include`).
+*
+* 2. **Node.js globals removal** (environment + setup) — Only globals available in the
+*    Tailor Platform runtime are kept (whitelist: ECMAScript standard, Web Standard APIs
+*    from bootstrap.js, platform mocks). All others (`Buffer`, `global`, `setImmediate`,
+*    `__dirname`, `__filename`, etc.) are removed. `performance` is removed per-test
+*    via beforeEach/afterEach since Vitest needs it during initialization.
+*
+* 3. **Platform API mocks** (environment) — All platform APIs are auto-injected with
+*    control objects: `tailordbMock`, `workflowMock`, `secretmanagerMock`,
+*    `authconnectionMock`, `idpMock`, `fileMock`, `iconvMock`. Each provides response
+*    configuration, call recording, and reset.
+*
+* 4. **Environment resolution** — Rewrites `environment: "tailor-runtime"` to the
+*    absolute path of the bundled environment module via the config hook.
+*
+* ## Known limitations
+*
+* - **`process`** and **`require`** are NOT removed or blocked. Vitest's internal
+*   runner depends on them. On the real Tailor Platform runtime, they do not exist.
+* - **Dynamic `import()`** of bundled files (via `createImportMain()`) bypasses
+*   the transform hook since those files are loaded through Node.js native loader.
+* ## Options
+*
+* - **`config`** — Path to `tailor.config.ts`. Loads `defineSecretManager()` values
+*   into `secretmanagerMock` so `getSecret()` returns the configured values.
+* @example
+* ```typescript
+* // vitest.config.ts
+* import { defineConfig } from "vitest/config";
+* import { tailorRuntime } from "@tailor-platform/sdk/vitest";
+*
+* export default defineConfig({
+*   plugins: [tailorRuntime({ config: "./tailor.config.ts" })],
+*   test: {
+*     environment: "tailor-runtime",
+*   },
+* });
+* ```
+* @param options - Optional configuration
+* @param options.config - Path to tailor.config.ts to load SecretManager values into mock
+* @returns Array of Vite plugins
+*/
+function tailorRuntime(options) {
+	return [createBlockPlugin(), createEnvironmentPlugin(options)];
+}
+
+//#endregion
+export { authconnectionMock, fileMock, iconvMock, idpMock, secretmanagerMock, tailorRuntime, tailordbMock, workflowMock };
+//# sourceMappingURL=index.mjs.map