definitely-fine 0.1.0

package/dist/index.js

@@ -0,0 +1,729 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, parse, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+
+//#region src/runtime-scenario-context.ts
+const runtimeScenarioContextStorage = new AsyncLocalStorage();
+/**
+* Runs a callback inside a request-scoped runtime scenario context.
+* @public
+*
+* @example
+* ```ts
+* runWithRuntimeScenarioContext({ scenarioId: "checkout" }, () => {
+*   return getRuntimeScenarioId();
+* });
+* ```
+*/
+function runWithRuntimeScenarioContext(context, callback) {
+	return runtimeScenarioContextStorage.run(context, callback);
+}
+/**
+* Returns the active runtime scenario id for the current async scope.
+* @public
+*
+* @example
+* ```ts
+* const scenarioId = getRuntimeScenarioId();
+* ```
+*/
+function getRuntimeScenarioId() {
+	return runtimeScenarioContextStorage.getStore()?.scenarioId;
+}
+
+//#endregion
+//#region src/services/utils/get-scenario-file-path.ts
+/**
+* Builds the persisted JSON file path for a scenario id.
+* @internal
+*/
+function getScenarioFilePath(directory, scenarioId) {
+	return join(directory, `${scenarioId}.json`);
+}
+
+//#endregion
+//#region src/services/impls/JsonScenarioStorageAdapter.ts
+function createJsonScenarioStorageAdapterError(message, cause) {
+	return new Error(message, { cause });
+}
+function findNodeModulesDirectory(startPath) {
+	let currentPath = dirname(startPath);
+	const { root } = parse(currentPath);
+	while (currentPath !== root) {
+		if (basename(currentPath) === "node_modules") return currentPath;
+		currentPath = dirname(currentPath);
+	}
+	if (basename(currentPath) === "node_modules") return currentPath;
+	return void 0;
+}
+function isDirectory(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch (_error) {
+		return false;
+	}
+}
+function findInstalledPackageNodeModulesDirectory(packageRootPath) {
+	let currentPath = process.cwd();
+	const { root } = parse(currentPath);
+	while (currentPath !== root) {
+		const nodeModulesDirectory$1 = join(currentPath, "node_modules");
+		const installedPackageDirectory$1 = join(nodeModulesDirectory$1, "definitely-fine");
+		if (isDirectory(installedPackageDirectory$1) && realpathSync(installedPackageDirectory$1) === packageRootPath) return nodeModulesDirectory$1;
+		currentPath = dirname(currentPath);
+	}
+	const nodeModulesDirectory = join(currentPath, "node_modules");
+	const installedPackageDirectory = join(nodeModulesDirectory, "definitely-fine");
+	if (isDirectory(installedPackageDirectory) && realpathSync(installedPackageDirectory) === packageRootPath) return nodeModulesDirectory;
+	return void 0;
+}
+function isPathInsideDirectory(path, directory) {
+	const relativePath = relative(directory, path);
+	return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+/**
+* Resolves the default directory used by the built-in JSON scenario adapter.
+* @public
+*
+* @example
+* ```ts
+* import { resolveJsonScenarioStorageAdapterDirectory } from "definitely-fine";
+*
+* const directory = resolveJsonScenarioStorageAdapterDirectory({
+*   directory: ".definitely-fine",
+* });
+* ```
+*/
+function resolveJsonScenarioStorageAdapterDirectory(options) {
+	if (options.directory !== void 0) return options.directory;
+	const unresolvedModuleFilePath = fileURLToPath(options.moduleUrl ?? import.meta.url);
+	const symlinkedNodeModulesDirectory = findNodeModulesDirectory(unresolvedModuleFilePath);
+	if (symlinkedNodeModulesDirectory !== void 0) return join(symlinkedNodeModulesDirectory, ".cache", "definitely-fine", "scenarios");
+	const moduleFilePath = realpathSync(unresolvedModuleFilePath);
+	const nodeModulesDirectory = findNodeModulesDirectory(moduleFilePath);
+	if (nodeModulesDirectory !== void 0) return join(nodeModulesDirectory, ".cache", "definitely-fine", "scenarios");
+	if (options.moduleUrl === void 0 && !isPathInsideDirectory(moduleFilePath, process.cwd())) {
+		const workingDirectoryNodeModulesDirectory = findInstalledPackageNodeModulesDirectory(dirname(dirname(moduleFilePath)));
+		if (workingDirectoryNodeModulesDirectory !== void 0) return join(workingDirectoryNodeModulesDirectory, ".cache", "definitely-fine", "scenarios");
+	}
+	throw new Error(`Could not infer the default file scenario adapter directory from ${moduleFilePath}. Provide an explicit directory instead.`);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isValidIsoTimestamp(value) {
+	if (typeof value !== "string") return false;
+	const parsed = new Date(value);
+	return !Number.isNaN(parsed.valueOf()) && parsed.toISOString() === value;
+}
+function isSerializedTarget(value) {
+	if (!isRecord(value) || typeof value.kind !== "string") return false;
+	if (value.kind === "function") return typeof value.function === "string";
+	if (value.kind === "service-method") return typeof value.service === "string" && typeof value.method === "string";
+	return false;
+}
+function isSerializedAction(value) {
+	if (!isRecord(value) || typeof value.kind !== "string") return false;
+	if (value.kind === "return") return "value" in value;
+	if (value.kind === "throw-message") return typeof value.message === "string";
+	if (value.kind === "throw-factory") return typeof value.factory === "string";
+	return false;
+}
+function isSerializedRule(value) {
+	return isRecord(value) && typeof value.callNumber === "number" && Number.isInteger(value.callNumber) && value.callNumber > 0 && isSerializedTarget(value.target) && isSerializedAction(value.action);
+}
+function isSerializedScenario(value) {
+	return isRecord(value) && typeof value.id === "string" && value.version === 1 && isValidIsoTimestamp(value.createdAt) && Array.isArray(value.rules) && value.rules.every((rule) => isSerializedRule(rule));
+}
+function loadSerializedScenario(scenarioId, scenarioFilePath) {
+	let serializedScenarioText;
+	try {
+		serializedScenarioText = readFileSync(scenarioFilePath, "utf8");
+	} catch (error) {
+		if (isRecord(error) && "code" in error && error.code === "ENOENT") return void 0;
+		throw error;
+	}
+	try {
+		const parsedValue = JSON.parse(serializedScenarioText);
+		if (!isSerializedScenario(parsedValue) || parsedValue.id !== scenarioId) throw new Error(`Invalid persisted scenario data in ${scenarioFilePath}.`);
+		return parsedValue;
+	} catch (error) {
+		if (error instanceof Error && error.message === `Invalid persisted scenario data in ${scenarioFilePath}.`) throw error;
+		throw new Error(`Invalid persisted scenario data in ${scenarioFilePath}.`, { cause: error });
+	}
+}
+/**
+* Persists scenarios as JSON files in a local directory.
+*
+* @example
+* ```ts
+* import { JsonScenarioStorageAdapter } from "definitely-fine";
+*
+* const adapter = new JsonScenarioStorageAdapter({
+*   directory: ".definitely-fine",
+* });
+* ```
+* @public
+*/
+var JsonScenarioStorageAdapter = class {
+	directory;
+	constructor(options = {}) {
+		this.directory = resolveJsonScenarioStorageAdapterDirectory(options);
+	}
+	async deleteScenario(scenarioId) {
+		await rm(getScenarioFilePath(this.directory, scenarioId), { force: true });
+	}
+	describeScenarioLocation(scenarioId) {
+		return getScenarioFilePath(this.directory, scenarioId);
+	}
+	loadScenario(scenarioId) {
+		return loadSerializedScenario(scenarioId, getScenarioFilePath(this.directory, scenarioId));
+	}
+	async saveScenario(scenario) {
+		try {
+			await mkdir(this.directory, { recursive: true });
+		} catch (error) {
+			throw createJsonScenarioStorageAdapterError(`Could not create the file scenario adapter directory at ${this.directory}.`, error);
+		}
+		const scenarioFilePath = getScenarioFilePath(this.directory, scenario.id);
+		try {
+			await writeFile(scenarioFilePath, JSON.stringify(scenario, null, 2));
+		} catch (error) {
+			throw createJsonScenarioStorageAdapterError(`Could not write the file scenario adapter payload to ${scenarioFilePath}.`, error);
+		}
+	}
+};
+
+//#endregion
+//#region src/runtime-errors.ts
+/**
+* Signals that runtime setup is missing required configuration.
+* @public
+*
+* @example
+* ```ts
+* import { RuntimeConfigurationError } from "definitely-fine";
+*
+* throw new RuntimeConfigurationError("A scenario adapter is required.");
+* ```
+*/
+var RuntimeConfigurationError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "RuntimeConfigurationError";
+	}
+};
+
+//#endregion
+//#region src/adapter-resolution.ts
+/**
+* Normalizes storage options into an adapter, directory, or missing state.
+* @internal
+*/
+function resolveScenarioStorageSelection(options) {
+	if (options.adapter !== void 0 && options.directory !== void 0) throw new RuntimeConfigurationError("A storage adapter and directory cannot be used together.");
+	if (options.adapter) return {
+		kind: "adapter",
+		adapter: options.adapter
+	};
+	if (options.directory !== void 0) return {
+		kind: "directory",
+		directory: options.directory
+	};
+	return { kind: "default" };
+}
+
+//#endregion
+//#region src/services/impls/RuntimeErrorFactory.ts
+function hasRuntimeFactory(errorFactories, factoryName) {
+	return factoryName in errorFactories;
+}
+/**
+* Default runtime factory-error resolver implementation.
+* @internal
+*/
+var RuntimeErrorFactory = class {
+	errorFactories;
+	constructor(errorFactories) {
+		this.errorFactories = errorFactories ?? {};
+	}
+	create(factoryName, ...input) {
+		if (!hasRuntimeFactory(this.errorFactories, factoryName)) throw new RuntimeConfigurationError(`No runtime error factory registered for "${factoryName}".`);
+		const factory = this.errorFactories[factoryName];
+		if (typeof factory !== "function") throw new RuntimeConfigurationError(`No runtime error factory registered for "${factoryName}".`);
+		return Reflect.apply(factory, void 0, input);
+	}
+};
+
+//#endregion
+//#region src/services/impls/RuntimeScenarioCacheService.ts
+const DEFAULT_RUNTIME_SCENARIO_CACHE_TTL_MS = 6e4;
+function scheduleEntryEviction(cacheEntries, scenarioId, ttlMs) {
+	const evictionTimer = setTimeout(() => {
+		cacheEntries.delete(scenarioId);
+	}, ttlMs);
+	evictionTimer.unref?.();
+	return evictionTimer;
+}
+/**
+* Default runtime scenario cache with inactivity-based eviction.
+* @internal
+*/
+var RuntimeScenarioCacheService = class {
+	ttlMs;
+	cacheEntries = new Map();
+	constructor(options = {}) {
+		this.ttlMs = options.ttlMs ?? DEFAULT_RUNTIME_SCENARIO_CACHE_TTL_MS;
+	}
+	has(scenarioId) {
+		return this.cacheEntries.has(scenarioId);
+	}
+	get(scenarioId) {
+		const cacheEntry = this.cacheEntries.get(scenarioId);
+		if (cacheEntry) {
+			clearTimeout(cacheEntry.evictionTimer);
+			cacheEntry.evictionTimer = scheduleEntryEviction(this.cacheEntries, scenarioId, this.ttlMs);
+			return cacheEntry.runtimeScenario;
+		}
+		return void 0;
+	}
+	set(scenarioId, runtimeScenario) {
+		const cacheEntry = this.cacheEntries.get(scenarioId);
+		if (cacheEntry) clearTimeout(cacheEntry.evictionTimer);
+		this.cacheEntries.set(scenarioId, {
+			runtimeScenario,
+			evictionTimer: scheduleEntryEviction(this.cacheEntries, scenarioId, this.ttlMs)
+		});
+	}
+};
+
+//#endregion
+//#region src/runtime-matcher.ts
+/**
+* Reusable runtime scenario state bound to a single scenario id.
+* @internal
+*/
+var RuntimeScenario = class {
+	/**
+	* Stable identifier for the runtime scenario state.
+	*/
+	id;
+	#scenario;
+	#targetCounters = new Map();
+	constructor(scenarioId, scenario) {
+		this.id = scenarioId;
+		this.#scenario = scenario;
+	}
+	/**
+	* Replaces the currently loaded persisted scenario document.
+	* @internal
+	*/
+	setSerializedScenario(scenario) {
+		this.#scenario = scenario;
+	}
+	/**
+	* Resolves the next matching rule for a target call, if this scenario has any.
+	* @internal
+	*/
+	resolveRuleMatch(target) {
+		if (!this.#scenario || !hasScenarioRuleForTarget(this.#scenario, target)) return void 0;
+		return resolveRuntimeRuleMatch({
+			scenario: this.#scenario,
+			target,
+			targetCounters: this.#targetCounters
+		});
+	}
+};
+function getTargetKey(target) {
+	if (target.kind === "function") return `function:${target.function}`;
+	return `service:${target.service}:${target.method}`;
+}
+function isSameTarget(left, right) {
+	if (left.kind !== right.kind) return false;
+	if (left.kind === "function" && right.kind === "function") return left.function === right.function;
+	if (left.kind === "service-method" && right.kind === "service-method") return left.service === right.service && left.method === right.method;
+	return false;
+}
+function incrementTargetCounter(targetCounters, target) {
+	const targetKey = getTargetKey(target);
+	const nextCallNumber = (targetCounters.get(targetKey) ?? 0) + 1;
+	targetCounters.set(targetKey, nextCallNumber);
+	return nextCallNumber;
+}
+/**
+* Checks whether a scenario contains any rule for a target.
+* @internal
+*/
+function hasScenarioRuleForTarget(scenario, target) {
+	if (!scenario) return false;
+	return scenario.rules.some((rule) => isSameTarget(rule.target, target));
+}
+/**
+* Resolves the next matching rule for a target call.
+* @internal
+*/
+function resolveRuntimeRuleMatch(options) {
+	const callNumber = incrementTargetCounter(options.targetCounters, options.target);
+	const rule = options.scenario.rules.find((candidate) => {
+		return candidate.callNumber === callNumber && isSameTarget(candidate.target, options.target);
+	});
+	return {
+		callNumber,
+		rule
+	};
+}
+
+//#endregion
+//#region src/services/impls/RuntimeScenarioLoaderService.ts
+/**
+* Default runtime scenario loader implementation.
+* @internal
+*/
+var RuntimeScenarioLoaderService = class {
+	adapter;
+	cacheService;
+	resolveScenarioId;
+	constructor(options) {
+		this.adapter = options.adapter;
+		this.cacheService = options.cacheService;
+		this.resolveScenarioId = options.resolveScenarioId;
+	}
+	resolve() {
+		const scenarioId = this.resolveScenarioId();
+		if (!scenarioId) return void 0;
+		const cachedScenario = this.cacheService.get(scenarioId);
+		if (cachedScenario) return cachedScenario;
+		const runtimeScenario = new RuntimeScenario(scenarioId, this.adapter.loadScenario(scenarioId));
+		this.cacheService.set(scenarioId, runtimeScenario);
+		return runtimeScenario;
+	}
+};
+
+//#endregion
+//#region src/services/impls/ScenarioBuilderService.ts
+function isSameSerializedTarget(left, right) {
+	if (left.kind !== right.kind) return false;
+	if (left.kind === "function" && right.kind === "function") return left.function === right.function;
+	if (left.kind === "service-method" && right.kind === "service-method") return left.service === right.service && left.method === right.method;
+	return false;
+}
+function formatSerializedTarget(target) {
+	if (target.kind === "function") return `function ${target.function}`;
+	return `service method ${target.service}.${target.method}`;
+}
+function createActionBuilder(context, target, callNumber) {
+	function pushRuleAndReturnBuilder(action) {
+		const duplicateRule = context.rules.find((rule) => {
+			return rule.callNumber === callNumber && isSameSerializedTarget(rule.target, target);
+		});
+		if (duplicateRule) throw new Error(`Duplicate scenario rule for ${formatSerializedTarget(target)} on call ${callNumber}.`);
+		context.rules.push({
+			action,
+			callNumber,
+			target
+		});
+		if (!context.scenario) throw new Error("scenario builder reference is not initialized");
+		return context.scenario;
+	}
+	return {
+		returns(value) {
+			return pushRuleAndReturnBuilder({
+				kind: "return",
+				value
+			});
+		},
+		throwsMessage(message) {
+			return pushRuleAndReturnBuilder({
+				kind: "throw-message",
+				message
+			});
+		},
+		throwsFactory(factory, ...args) {
+			const [input] = args;
+			return pushRuleAndReturnBuilder({
+				kind: "throw-factory",
+				factory,
+				input
+			});
+		}
+	};
+}
+function createScenarioServiceMethodRuleBuilder(context, service, method) {
+	return { onCall(callNumber) {
+		return createActionBuilder(context, {
+			kind: "service-method",
+			method,
+			service
+		}, callNumber);
+	} };
+}
+function createScenarioServiceRuleBuilder(context, service) {
+	return { method(method) {
+		return createScenarioServiceMethodRuleBuilder(context, service, method);
+	} };
+}
+function createScenarioFunctionRuleBuilder(context, fn) {
+	return { onCall(callNumber) {
+		return createActionBuilder(context, {
+			kind: "function",
+			function: fn
+		}, callNumber);
+	} };
+}
+/**
+* Default scenario builder implementation.
+* @internal
+*/
+var ScenarioBuilderService = class {
+	id;
+	adapter;
+	createdAt;
+	context;
+	constructor(adapter) {
+		this.adapter = adapter;
+		this.id = randomUUID();
+		this.createdAt = new Date().toISOString();
+		this.context = {
+			rules: [],
+			scenario: this
+		};
+	}
+	service(service) {
+		return createScenarioServiceRuleBuilder(this.context, service);
+	}
+	fn(fn) {
+		return createScenarioFunctionRuleBuilder(this.context, fn);
+	}
+	async save() {
+		await this.adapter.saveScenario({
+			id: this.id,
+			version: 1,
+			createdAt: this.createdAt,
+			rules: this.context.rules
+		});
+	}
+	async dispose() {
+		await this.adapter.deleteScenario(this.id);
+	}
+};
+
+//#endregion
+//#region src/runtime-wrappers.ts
+/**
+* Wraps a synchronous function with scenario interception behavior.
+* @internal
+*/
+function createWrappedSyncFunction(implementation, options) {
+	return new Proxy(implementation, { apply(target, thisArg, args) {
+		const runtimeScenario = options.runtimeScenarioLoaderService.resolve();
+		if (!runtimeScenario) return Reflect.apply(target, thisArg, args);
+		const match = runtimeScenario.resolveRuleMatch(options.target);
+		if (match?.rule?.action.kind === "return") return match.rule.action.value;
+		if (match?.rule?.action.kind === "throw-message") throw new Error(match.rule.action.message);
+		if (match?.rule?.action.kind === "throw-factory") throw options.runtimeErrorFactory.create(match.rule.action.factory, match.rule.action.input);
+		return Reflect.apply(target, thisArg, args);
+	} });
+}
+/**
+* Wraps an async function with scenario interception behavior.
+* @internal
+*/
+function createWrappedAsyncFunction(implementation, options) {
+	return new Proxy(implementation, { apply(target, thisArg, args) {
+		const runtimeScenario = options.runtimeScenarioLoaderService.resolve();
+		if (!runtimeScenario) return Reflect.apply(target, thisArg, args);
+		const match = runtimeScenario.resolveRuleMatch(options.target);
+		if (match?.rule?.action.kind === "return") return Promise.resolve(match.rule.action.value);
+		if (match?.rule?.action.kind === "throw-message") return Promise.reject(new Error(match.rule.action.message));
+		if (match?.rule?.action.kind === "throw-factory") try {
+			return Promise.reject(options.runtimeErrorFactory.create(match.rule.action.factory, match.rule.action.input));
+		} catch (error) {
+			return Promise.reject(error);
+		}
+		return Reflect.apply(target, thisArg, args);
+	} });
+}
+/**
+* Wraps each callable method on a service with scenario interception behavior.
+* @internal
+*/
+function createWrappedService(options) {
+	const wrappedMethods = new Map();
+	return new Proxy(options.implementation, { get(target, property, _receiver) {
+		const value = Reflect.get(target, property, target);
+		if (typeof property !== "string" || typeof value !== "function") return value;
+		const targetRule = {
+			kind: "service-method",
+			method: property,
+			service: options.service
+		};
+		const wrappedMethod = wrappedMethods.get(property);
+		if (wrappedMethod) return wrappedMethod;
+		const nextWrappedMethod = options.createWrapper(value.bind(options.implementation), {
+			runtimeScenarioLoaderService: options.runtimeScenarioLoaderService,
+			target: targetRule,
+			runtimeErrorFactory: options.runtimeErrorFactory
+		});
+		wrappedMethods.set(property, nextWrappedMethod);
+		return nextWrappedMethod;
+	} });
+}
+
+//#endregion
+//#region src/index.ts
+function resolveScenarioStorageAdapter(options = {}) {
+	const storageSelection = resolveScenarioStorageSelection({
+		adapter: "adapter" in options ? options.adapter : void 0,
+		directory: "directory" in options ? options.directory : void 0
+	});
+	return storageSelection.kind === "adapter" ? storageSelection.adapter : new JsonScenarioStorageAdapter(storageSelection.kind === "directory" ? { directory: storageSelection.directory } : {});
+}
+/**
+* Creates a scenario builder that records interception rules and persists them as JSON.
+*
+* @public
+*
+* @example
+* ```ts
+* import { JsonScenarioStorageAdapter, createScenario } from "definitely-fine";
+*
+* const scenario = createScenario({
+*   adapter: new JsonScenarioStorageAdapter({}),
+* });
+*
+* scenario.fn("fetchUser").onCall(1).returns({ id: "user-1" });
+* await scenario.save();
+* ```
+*/
+function createScenario(options = {}) {
+	const adapter = resolveScenarioStorageAdapter(options);
+	return new ScenarioBuilderService(adapter);
+}
+/**
+* Creates a runtime that loads a persisted scenario and wraps implementations.
+*
+* @public
+*
+* @example
+* ```ts
+* import { createRuntime, type IScenarioStorageAdapter } from "definitely-fine";
+*
+* const customAdapter: IScenarioStorageAdapter = {
+*   async deleteScenario(_scenarioId) {},
+*   loadScenario(_scenarioId) {
+*     return undefined;
+*   },
+*   async saveScenario(_scenario) {},
+* };
+*
+* const runtime = createRuntime({
+*   adapter: customAdapter,
+*   errorFactories: {},
+* });
+*
+* const wrappedFetchUser = runtime.wrapAsyncFunction("fetchUser", fetchUser);
+* ```
+*/
+function createRuntime(options = {}) {
+	if (options.enabled === false) return {
+		wrapSyncFunction(_name, implementation) {
+			return implementation;
+		},
+		wrapAsyncFunction(_name, implementation) {
+			return implementation;
+		},
+		wrapSyncServiceMethod(_service, _method, implementation) {
+			return implementation;
+		},
+		wrapAsyncServiceMethod(_service, _method, implementation) {
+			return implementation;
+		},
+		wrapSyncService(_service, implementation) {
+			return implementation;
+		},
+		wrapAsyncService(_service, implementation) {
+			return implementation;
+		}
+	};
+	const storageSelection = resolveScenarioStorageSelection({
+		adapter: "adapter" in options ? options.adapter : void 0,
+		directory: "directory" in options ? options.directory : void 0
+	});
+	const adapter = storageSelection.kind === "adapter" ? storageSelection.adapter : new JsonScenarioStorageAdapter(storageSelection.kind === "directory" ? { directory: storageSelection.directory } : {});
+	const runtimeErrorFactory = new RuntimeErrorFactory(options.errorFactories);
+	const cacheService = new RuntimeScenarioCacheService(options.cache);
+	const runtimeScenarioLoaderService = new RuntimeScenarioLoaderService({
+		adapter,
+		cacheService,
+		resolveScenarioId: getRuntimeScenarioId
+	});
+	return {
+		wrapSyncFunction(name, implementation) {
+			return createWrappedSyncFunction(implementation, {
+				runtimeErrorFactory,
+				runtimeScenarioLoaderService,
+				target: {
+					kind: "function",
+					function: name
+				}
+			});
+		},
+		wrapAsyncFunction(name, implementation) {
+			return createWrappedAsyncFunction(implementation, {
+				runtimeErrorFactory,
+				runtimeScenarioLoaderService,
+				target: {
+					kind: "function",
+					function: name
+				}
+			});
+		},
+		wrapSyncServiceMethod(service, method, implementation) {
+			return createWrappedSyncFunction(implementation, {
+				runtimeErrorFactory,
+				runtimeScenarioLoaderService,
+				target: {
+					kind: "service-method",
+					method,
+					service
+				}
+			});
+		},
+		wrapAsyncServiceMethod(service, method, implementation) {
+			return createWrappedAsyncFunction(implementation, {
+				runtimeErrorFactory,
+				runtimeScenarioLoaderService,
+				target: {
+					kind: "service-method",
+					method,
+					service
+				}
+			});
+		},
+		wrapSyncService(service, implementation) {
+			return createWrappedService({
+				implementation,
+				createWrapper: createWrappedSyncFunction,
+				runtimeErrorFactory,
+				service,
+				runtimeScenarioLoaderService
+			});
+		},
+		wrapAsyncService(service, implementation) {
+			return createWrappedService({
+				implementation,
+				createWrapper: createWrappedAsyncFunction,
+				runtimeErrorFactory,
+				service,
+				runtimeScenarioLoaderService
+			});
+		}
+	};
+}
+
+//#endregion
+export { JsonScenarioStorageAdapter, RuntimeConfigurationError, createRuntime, createScenario, getRuntimeScenarioId, resolveJsonScenarioStorageAdapterDirectory, runWithRuntimeScenarioContext };
+//# sourceMappingURL=index.js.map