@temporal-contract/worker 0.2.0 → 2.0.0

package/dist/internal-C8MB-kez.cjs

@@ -0,0 +1,453 @@
+let _temporalio_workflow = require("@temporalio/workflow");
+//#region src/format.ts
+/**
+* Pattern for string keys safe to render with dot notation. A "safe" key is a
+* JavaScript identifier (letters/digits/underscore/$, not starting with a
+* digit). Anything else — keys containing dots, spaces, leading digits, the
+* empty string, the literal string `"0"` etc. — gets bracket-quoted so the
+* path is unambiguous. Reserved words are accepted: we are formatting a
+* diagnostic, not generating runnable code.
+*/
+const SAFE_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+* Render a Standard Schema {@link StandardSchemaV1.Issue} into a human-readable
+* string that includes the failing field's path.
+*/
+function formatIssue(issue) {
+	if (issue.path === void 0 || issue.path.length === 0) return issue.message;
+	let path = "";
+	for (let i = 0; i < issue.path.length; i++) {
+		const segment = issue.path[i];
+		const key = segment !== null && typeof segment === "object" && "key" in segment ? segment.key : segment;
+		if (typeof key === "number") path += `[${key}]`;
+		else if (typeof key === "string" && SAFE_IDENTIFIER.test(key)) path += i === 0 ? key : `.${key}`;
+		else if (typeof key === "string") path += `[${JSON.stringify(key)}]`;
+		else path += `[${String(key)}]`;
+	}
+	return `at ${path}: ${issue.message}`;
+}
+/**
+* Join a list of validation issues into a single message, with each issue
+* rendered via {@link formatIssue} so field paths surface in the error text.
+*/
+function summarizeIssues(issues) {
+	return issues.map(formatIssue).join("; ");
+}
+/**
+* Build the message attached to a `ChildWorkflowError` for input/output
+* validation failures. Centralized so the worker and any future call sites
+* format identically.
+*/
+function formatChildWorkflowValidationMessage(workflowName, direction, issues) {
+	return `Child workflow "${workflowName}" ${direction} validation failed: ${summarizeIssues(issues)}`;
+}
+//#endregion
+//#region src/errors.ts
+/**
+* Base error class for worker errors
+*/
+var WorkerError = class extends Error {
+	constructor(message, cause) {
+		super(message, { cause });
+		this.name = "WorkerError";
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Error thrown when an activity definition is not found in the contract
+*/
+var ActivityDefinitionNotFoundError = class extends WorkerError {
+	constructor(activityName, availableDefinitions = []) {
+		const available = availableDefinitions.length > 0 ? availableDefinitions.join(", ") : "none";
+		super(`Activity definition not found for: "${activityName}". Available activities: ${available}`);
+		this.activityName = activityName;
+		this.availableDefinitions = availableDefinitions;
+		this.name = "ActivityDefinitionNotFoundError";
+	}
+};
+/**
+* Error thrown when activity input validation fails
+*/
+var ActivityInputValidationError = class extends WorkerError {
+	constructor(activityName, issues) {
+		const message = summarizeIssues(issues);
+		super(`Activity "${activityName}" input validation failed: ${message}`);
+		this.activityName = activityName;
+		this.issues = issues;
+		this.name = "ActivityInputValidationError";
+	}
+};
+/**
+* Error thrown when activity output validation fails
+*/
+var ActivityOutputValidationError = class extends WorkerError {
+	constructor(activityName, issues) {
+		const message = summarizeIssues(issues);
+		super(`Activity "${activityName}" output validation failed: ${message}`);
+		this.activityName = activityName;
+		this.issues = issues;
+		this.name = "ActivityOutputValidationError";
+	}
+};
+/**
+* Error thrown when workflow input validation fails
+*/
+var WorkflowInputValidationError = class extends WorkerError {
+	constructor(workflowName, issues) {
+		const message = summarizeIssues(issues);
+		super(`Workflow "${workflowName}" input validation failed: ${message}`);
+		this.workflowName = workflowName;
+		this.issues = issues;
+		this.name = "WorkflowInputValidationError";
+	}
+};
+/**
+* Error thrown when workflow output validation fails
+*/
+var WorkflowOutputValidationError = class extends WorkerError {
+	constructor(workflowName, issues) {
+		const message = summarizeIssues(issues);
+		super(`Workflow "${workflowName}" output validation failed: ${message}`);
+		this.workflowName = workflowName;
+		this.issues = issues;
+		this.name = "WorkflowOutputValidationError";
+	}
+};
+/**
+* Error thrown when signal input validation fails
+*/
+var SignalInputValidationError = class extends WorkerError {
+	constructor(signalName, issues) {
+		const message = summarizeIssues(issues);
+		super(`Signal "${signalName}" input validation failed: ${message}`);
+		this.signalName = signalName;
+		this.issues = issues;
+		this.name = "SignalInputValidationError";
+	}
+};
+/**
+* Error thrown when query input validation fails
+*/
+var QueryInputValidationError = class extends WorkerError {
+	constructor(queryName, issues) {
+		const message = summarizeIssues(issues);
+		super(`Query "${queryName}" input validation failed: ${message}`);
+		this.queryName = queryName;
+		this.issues = issues;
+		this.name = "QueryInputValidationError";
+	}
+};
+/**
+* Error thrown when query output validation fails
+*/
+var QueryOutputValidationError = class extends WorkerError {
+	constructor(queryName, issues) {
+		const message = summarizeIssues(issues);
+		super(`Query "${queryName}" output validation failed: ${message}`);
+		this.queryName = queryName;
+		this.issues = issues;
+		this.name = "QueryOutputValidationError";
+	}
+};
+/**
+* Error thrown when update input validation fails
+*/
+var UpdateInputValidationError = class extends WorkerError {
+	constructor(updateName, issues) {
+		const message = summarizeIssues(issues);
+		super(`Update "${updateName}" input validation failed: ${message}`);
+		this.updateName = updateName;
+		this.issues = issues;
+		this.name = "UpdateInputValidationError";
+	}
+};
+/**
+* Error thrown when update output validation fails
+*/
+var UpdateOutputValidationError = class extends WorkerError {
+	constructor(updateName, issues) {
+		const message = summarizeIssues(issues);
+		super(`Update "${updateName}" output validation failed: ${message}`);
+		this.updateName = updateName;
+		this.issues = issues;
+		this.name = "UpdateOutputValidationError";
+	}
+};
+/**
+* Error thrown when a child workflow is not found in the contract
+*/
+var ChildWorkflowNotFoundError = class extends WorkerError {
+	constructor(workflowName, availableWorkflows = []) {
+		const available = availableWorkflows.length > 0 ? availableWorkflows.join(", ") : "none";
+		super(`Child workflow not found: "${workflowName}". Available workflows: ${available}`);
+		this.workflowName = workflowName;
+		this.availableWorkflows = availableWorkflows;
+		this.name = "ChildWorkflowNotFoundError";
+	}
+};
+/**
+* Generic error for child workflow operations
+*/
+var ChildWorkflowError = class extends WorkerError {
+	constructor(message, cause) {
+		super(message, cause);
+		this.name = "ChildWorkflowError";
+	}
+};
+/**
+* Error surfaced in the `err(...)` branch of a `ResultAsync` when a typed
+* cancellation scope is cancelled via Temporal's cancellation propagation.
+* Returned by both `context.cancellableScope` (when the workflow or an
+* ancestor scope cancels) and `context.nonCancellableScope` (when
+* cancellation is raised from inside the scope). Distinct from arbitrary
+* thrown errors so call sites can branch on cancellation explicitly while
+* still surfacing non-cancellation errors as ResultAsync rejections.
+*/
+var WorkflowCancelledError = class extends WorkerError {
+	constructor(cause) {
+		super("Workflow cancellation scope was cancelled", cause);
+		this.name = "WorkflowCancelledError";
+	}
+};
+//#endregion
+//#region src/internal.ts
+/**
+* Internal helpers shared across the worker package's entry points.
+*
+* Not part of the public API — this module is not listed in the package's
+* `exports` map, so consumers can't import from `@temporal-contract/worker/internal`.
+* In-package tests import it directly via relative path.
+*/
+/**
+* Extract the single payload from a Temporal handler's `...args` array.
+*
+* Temporal invokes handlers with whatever was passed via `args: [...]` at the
+* call site. The typed-contract layer always sends `args: [validatedInput]`,
+* so the common case is a one-element array containing the wrapped input.
+*
+* If a non-typed-contract caller passes multiple positional arguments
+* (`args: [a, b, c]`), we surface the whole array as the input — the schema
+* will then reject it unless the contract specifically modeled a tuple.
+*/
+function extractHandlerInput(args) {
+	return args.length === 1 ? args[0] : args;
+}
+/**
+* Build the raw `Record<name, fn>` proxy of activities for a workflow,
+* applying per-activity `ActivityOptions` overrides where requested.
+*
+* **Fast path (no overrides):** a single `proxyActivities(defaultOptions)`
+* call is made and returned directly. The proxy synthesizes a function for
+* any property access by name, so downstream code that looks up
+* `proxy[activityName]` works identically to before.
+*
+* **Override path:** one extra `proxyActivities(merged)` call is made *only*
+* for each activity that has an override. Activities without an entry keep
+* using the single default proxy. The result is a `Proxy` that returns the
+* override-bound function for named keys and falls back to the default proxy
+* for everything else — so the per-execution overhead scales with the number
+* of overrides, not the number of activities.
+*
+* Per-override merge is shallow: the override's properties replace the
+* default's, including the entire nested `retry` block. This matches
+* Temporal's "one ActivityOptions per `proxyActivities` call" semantics.
+*/
+function buildRawActivitiesProxy(workflowActivities, contractActivities, defaultOptions, overrides) {
+	const defaultProxy = (0, _temporalio_workflow.proxyActivities)(defaultOptions);
+	const overrideEntries = overrides ? Object.entries(overrides).filter((entry) => entry[1] !== void 0) : [];
+	if (overrideEntries.length === 0) return defaultProxy;
+	const declared = new Set([...Object.keys(workflowActivities ?? {}), ...Object.keys(contractActivities ?? {})]);
+	for (const [name] of overrideEntries) if (!declared.has(name)) throw new Error(`activityOptionsByName entry "${name}" does not match any declared activity. Available: ${[...declared].join(", ") || "none"}.`);
+	const overriddenFns = {};
+	for (const [name, override] of overrideEntries) {
+		const fn = (0, _temporalio_workflow.proxyActivities)({
+			...defaultOptions,
+			...override
+		})[name];
+		if (fn !== void 0) overriddenFns[name] = fn;
+	}
+	return new Proxy(overriddenFns, { get(target, prop) {
+		if (typeof prop !== "string") return void 0;
+		return target[prop] ?? defaultProxy[prop];
+	} });
+}
+/**
+* Build the typed `continueAsNew` function bound to the running workflow's
+* contract. Two overloads — same-workflow and cross-contract — share one
+* implementation; the public type signature lives on `WorkflowContext` so
+* call sites are type-safe.
+*
+* Validation runs *before* Temporal's `makeContinueAsNewFunc(...)` is invoked.
+* On failure, throws a `WorkflowInputValidationError` (matching the behaviour
+* of `declareWorkflow`'s incoming-input validation), which surfaces back to
+* Temporal as a workflow failure rather than silently proceeding with an
+* invalid run.
+*
+* Temporal's `continueAsNew` never returns — it throws a `ContinueAsNew`
+* exception that the runtime intercepts. The returned function preserves
+* `Promise<never>` to encode that.
+*
+* @internal
+*/
+function createContinueAsNew(currentContract, currentWorkflowName) {
+	return async function continueAsNew(arg1, arg2, arg3, arg4) {
+		const isCrossContract = looksLikeCrossContractCall(arg1, arg2);
+		let targetContract;
+		let targetName;
+		let rawArgs;
+		let options;
+		if (isCrossContract) {
+			targetContract = arg1;
+			targetName = arg2;
+			rawArgs = arg3;
+			options = arg4;
+		} else {
+			targetContract = currentContract;
+			targetName = String(currentWorkflowName);
+			rawArgs = arg1;
+			options = arg2;
+		}
+		const targetDef = targetContract.workflows[targetName];
+		if (!targetDef) throw new WorkflowInputValidationError(targetName, [{ message: `continueAsNew target workflow "${targetName}" is not declared on the supplied contract.` }]);
+		const inputResult = await targetDef.input["~standard"].validate(rawArgs);
+		if (inputResult.issues) throw new WorkflowInputValidationError(targetName, inputResult.issues);
+		await (0, _temporalio_workflow.makeContinueAsNewFunc)({
+			workflowType: targetName,
+			taskQueue: targetContract.taskQueue,
+			...options
+		})(inputResult.value);
+	};
+}
+/**
+* Structural check: does `(arg1, arg2)` look like the
+* `(contract, workflowName, ...)` cross-contract overload of `continueAsNew`?
+*
+* Returns `true` only when:
+*   1. `arg1` is a non-null object with a string `taskQueue` and a non-null
+*      object `workflows` (handles `workflows: null`, where
+*      `typeof null === "object"`).
+*   2. `arg2` is a string.
+*
+* Both halves matter. A same-workflow input that happens to contain
+* `taskQueue` and `workflows` keys would otherwise be misclassified — but
+* none of the same-workflow signatures (`continueAsNew(args)`,
+* `continueAsNew(args, options)`) accept a string as `arg2`, so the
+* second check makes the false-positive surface vanishingly small.
+*
+* We deliberately do *not* check that `arg1.workflows[arg2]` is a valid
+* workflow definition. If it isn't, the dispatcher falls through to the
+* `targetContract.workflows[targetName]` lookup which throws a clear
+* "target workflow X is not declared" error — better than silently
+* misrouting a typo back to the current workflow.
+*/
+function looksLikeCrossContractCall(arg1, arg2) {
+	if (typeof arg1 !== "object" || arg1 === null) return false;
+	if (typeof arg2 !== "string") return false;
+	const candidate = arg1;
+	if (typeof candidate["taskQueue"] !== "string") return false;
+	const workflows = candidate["workflows"];
+	return typeof workflows === "object" && workflows !== null;
+}
+//#endregion
+Object.defineProperty(exports, "ActivityDefinitionNotFoundError", {
+	enumerable: true,
+	get: function() {
+		return ActivityDefinitionNotFoundError;
+	}
+});
+Object.defineProperty(exports, "ActivityInputValidationError", {
+	enumerable: true,
+	get: function() {
+		return ActivityInputValidationError;
+	}
+});
+Object.defineProperty(exports, "ActivityOutputValidationError", {
+	enumerable: true,
+	get: function() {
+		return ActivityOutputValidationError;
+	}
+});
+Object.defineProperty(exports, "ChildWorkflowError", {
+	enumerable: true,
+	get: function() {
+		return ChildWorkflowError;
+	}
+});
+Object.defineProperty(exports, "ChildWorkflowNotFoundError", {
+	enumerable: true,
+	get: function() {
+		return ChildWorkflowNotFoundError;
+	}
+});
+Object.defineProperty(exports, "QueryInputValidationError", {
+	enumerable: true,
+	get: function() {
+		return QueryInputValidationError;
+	}
+});
+Object.defineProperty(exports, "QueryOutputValidationError", {
+	enumerable: true,
+	get: function() {
+		return QueryOutputValidationError;
+	}
+});
+Object.defineProperty(exports, "SignalInputValidationError", {
+	enumerable: true,
+	get: function() {
+		return SignalInputValidationError;
+	}
+});
+Object.defineProperty(exports, "UpdateInputValidationError", {
+	enumerable: true,
+	get: function() {
+		return UpdateInputValidationError;
+	}
+});
+Object.defineProperty(exports, "UpdateOutputValidationError", {
+	enumerable: true,
+	get: function() {
+		return UpdateOutputValidationError;
+	}
+});
+Object.defineProperty(exports, "WorkflowCancelledError", {
+	enumerable: true,
+	get: function() {
+		return WorkflowCancelledError;
+	}
+});
+Object.defineProperty(exports, "WorkflowInputValidationError", {
+	enumerable: true,
+	get: function() {
+		return WorkflowInputValidationError;
+	}
+});
+Object.defineProperty(exports, "WorkflowOutputValidationError", {
+	enumerable: true,
+	get: function() {
+		return WorkflowOutputValidationError;
+	}
+});
+Object.defineProperty(exports, "buildRawActivitiesProxy", {
+	enumerable: true,
+	get: function() {
+		return buildRawActivitiesProxy;
+	}
+});
+Object.defineProperty(exports, "createContinueAsNew", {
+	enumerable: true,
+	get: function() {
+		return createContinueAsNew;
+	}
+});
+Object.defineProperty(exports, "extractHandlerInput", {
+	enumerable: true,
+	get: function() {
+		return extractHandlerInput;
+	}
+});
+Object.defineProperty(exports, "formatChildWorkflowValidationMessage", {
+	enumerable: true,
+	get: function() {
+		return formatChildWorkflowValidationMessage;
+	}
+});

package/dist/worker.cjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let _temporalio_worker = require("@temporalio/worker");
 let node_url = require("node:url");
-
 //#region src/worker.ts
 /**
 * Create a typed Temporal worker with contract-based configuration
@@ -65,7 +64,6 @@ async function createWorker(options) {
 function workflowsPathFromURL(baseURL, relativePath) {
 	return (0, node_url.fileURLToPath)(new URL(relativePath, baseURL));
 }
-
 //#endregion
 exports.createWorker = createWorker;
-exports.workflowsPathFromURL = workflowsPathFromURL;
+exports.workflowsPathFromURL = workflowsPathFromURL;

package/dist/worker.mjs

@@ -1,6 +1,5 @@
 import { Worker } from "@temporalio/worker";
 import { fileURLToPath } from "node:url";
-
 //#region src/worker.ts
 /**
 * Create a typed Temporal worker with contract-based configuration
@@ -64,7 +63,7 @@ async function createWorker(options) {
 function workflowsPathFromURL(baseURL, relativePath) {
 	return fileURLToPath(new URL(relativePath, baseURL));
 }
-
 //#endregion
 export { createWorker, workflowsPathFromURL };
+
 //# sourceMappingURL=worker.mjs.map

package/dist/worker.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"worker.mjs","names":[],"sources":["../src/worker.ts"],"sourcesContent":["// Entry point for worker creation utilities\nimport { ContractDefinition } from \"@temporal-contract/contract\";\nimport { Worker, WorkerOptions } from \"@temporalio/worker\";\nimport { fileURLToPath } from \"node:url\";\nimport type { ActivitiesHandler } from \"./activity.js\";\n\n/**\n * Options for creating a Temporal worker\n */\nexport type CreateWorkerOptions<TContract extends ContractDefinition> = Omit<\n  WorkerOptions,\n  \"activities\" | \"taskQueue\"\n> & {\n  /**\n   * The contract definition for this worker\n   */\n  contract: TContract;\n\n  /**\n   * Activities handler for this worker\n   */\n  activities: ActivitiesHandler<TContract>;\n};\n\n/**\n * Create a typed Temporal worker with contract-based configuration\n *\n * This helper simplifies worker creation by:\n * - Using the contract's task queue automatically\n * - Providing type-safe configuration\n *\n * @example\n * ```ts\n * import { NativeConnection } from '@temporalio/worker';\n * import { createWorker } from '@temporal-contract/worker/worker';\n * import { activities } from './activities';\n * import myContract from './contract';\n *\n * const connection = await NativeConnection.connect({\n *   address: 'localhost:7233',\n * });\n *\n * const worker = await createWorker({\n *   contract: myContract,\n *   connection,\n *   workflowsPath: require.resolve('./workflows'),\n *   activities,\n * });\n *\n * await worker.run();\n * ```\n */\nexport async function createWorker<TContract extends ContractDefinition>(\n  options: CreateWorkerOptions<TContract>,\n): Promise<Worker> {\n  const { contract, activities, ...workerOptions } = options;\n\n  // Create the worker with contract's task queue\n  return await Worker.create({\n    ...workerOptions,\n    activities,\n    taskQueue: contract.taskQueue,\n  });\n}\n\n/**\n * Helper to resolve a workflow file path relative to the current module's URL.\n *\n * Useful when using ES modules (`import.meta.url`) to locate workflow files.\n * The `relativePath` should include the file extension explicitly (e.g. `./workflows.js`)\n * to ensure the resolved path is unambiguous in both source and built contexts.\n *\n * @param baseURL - The base URL to resolve from, typically `import.meta.url`\n * @param relativePath - Relative path to the workflows file, **including extension**\n *\n * @example\n * ```ts\n * import { workflowsPathFromURL } from '@temporal-contract/worker/worker';\n *\n * const worker = await createWorker({\n *   contract: myContract,\n *   connection,\n *   // Include the extension explicitly to work in both source (.ts) and build (.js) contexts\n *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows.js'),\n *   activities,\n * });\n * ```\n */\nexport function workflowsPathFromURL(baseURL: string, relativePath: string): string {\n  return fileURLToPath(new URL(relativePath, baseURL));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,eAAsB,aACpB,SACiB;CACjB,MAAM,EAAE,UAAU,YAAY,GAAG,kBAAkB;AAGnD,QAAO,MAAM,OAAO,OAAO;EACzB,GAAG;EACH;EACA,WAAW,SAAS;EACrB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;AA0BJ,SAAgB,qBAAqB,SAAiB,cAA8B;AAClF,QAAO,cAAc,IAAI,IAAI,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"worker.mjs","names":[],"sources":["../src/worker.ts"],"sourcesContent":["// Entry point for worker creation utilities\nimport { ContractDefinition } from \"@temporal-contract/contract\";\nimport { Worker, WorkerOptions } from \"@temporalio/worker\";\nimport { fileURLToPath } from \"node:url\";\nimport type { ActivitiesHandler } from \"./activity.js\";\n\n/**\n * Options for creating a Temporal worker\n */\nexport type CreateWorkerOptions<TContract extends ContractDefinition> = Omit<\n  WorkerOptions,\n  \"activities\" | \"taskQueue\"\n> & {\n  /**\n   * The contract definition for this worker\n   */\n  contract: TContract;\n\n  /**\n   * Activities handler for this worker\n   */\n  activities: ActivitiesHandler<TContract>;\n};\n\n/**\n * Create a typed Temporal worker with contract-based configuration\n *\n * This helper simplifies worker creation by:\n * - Using the contract's task queue automatically\n * - Providing type-safe configuration\n *\n * @example\n * ```ts\n * import { NativeConnection } from '@temporalio/worker';\n * import { createWorker } from '@temporal-contract/worker/worker';\n * import { activities } from './activities';\n * import myContract from './contract';\n *\n * const connection = await NativeConnection.connect({\n *   address: 'localhost:7233',\n * });\n *\n * const worker = await createWorker({\n *   contract: myContract,\n *   connection,\n *   workflowsPath: require.resolve('./workflows'),\n *   activities,\n * });\n *\n * await worker.run();\n * ```\n */\nexport async function createWorker<TContract extends ContractDefinition>(\n  options: CreateWorkerOptions<TContract>,\n): Promise<Worker> {\n  const { contract, activities, ...workerOptions } = options;\n\n  // Create the worker with contract's task queue\n  return await Worker.create({\n    ...workerOptions,\n    activities,\n    taskQueue: contract.taskQueue,\n  });\n}\n\n/**\n * Helper to resolve a workflow file path relative to the current module's URL.\n *\n * Useful when using ES modules (`import.meta.url`) to locate workflow files.\n * The `relativePath` should include the file extension explicitly (e.g. `./workflows.js`)\n * to ensure the resolved path is unambiguous in both source and built contexts.\n *\n * @param baseURL - The base URL to resolve from, typically `import.meta.url`\n * @param relativePath - Relative path to the workflows file, **including extension**\n *\n * @example\n * ```ts\n * import { workflowsPathFromURL } from '@temporal-contract/worker/worker';\n *\n * const worker = await createWorker({\n *   contract: myContract,\n *   connection,\n *   // Include the extension explicitly to work in both source (.ts) and build (.js) contexts\n *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows.js'),\n *   activities,\n * });\n * ```\n */\nexport function workflowsPathFromURL(baseURL: string, relativePath: string): string {\n  return fileURLToPath(new URL(relativePath, baseURL));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,eAAsB,aACpB,SACiB;CACjB,MAAM,EAAE,UAAU,YAAY,GAAG,kBAAkB;AAGnD,QAAO,MAAM,OAAO,OAAO;EACzB,GAAG;EACH;EACA,WAAW,SAAS;EACrB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;AA0BJ,SAAgB,qBAAqB,SAAiB,cAA8B;AAClF,QAAO,cAAc,IAAI,IAAI,cAAc,QAAQ,CAAC"}