@temelj/workflow 0.0.0-alpha.3 → 0.0.0-alpha.4

package/dist/collection.mjs

@@ -1,3 +1,4 @@
+import { isPlainObject } from "@temelj/value";
 //#region src/collection.ts
 /** Returns whether a value matches one expected value or any value in an expected list. */
 function matchesOptionalValue(value, expected) {
@@ -13,21 +14,16 @@ function uniqueBy(items, key) {
 		return true;
 	});
 }
-/** Returns a copy of an object without properties whose value is undefined. */
+/** Copies the defined own enumerable fields of a plain record. */
 function omitUndefined(value) {
-	return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
+	if (!isPlainObject(value)) throw new TypeError("Expected a plain record");
+	const result = { ...value };
+	for (const key of Reflect.ownKeys(result)) if (Object.getOwnPropertyDescriptor(result, key)?.value === void 0) Reflect.deleteProperty(result, key);
+	return result;
 }
-/** Returns an object containing one property only when the value is defined. */
-function optionalProperty(key, value) {
-	return value === void 0 ? {} : { [key]: value };
-}
-/** Returns sorted string values from a set. */
-function sortedStringSet(values) {
-	return [...values].sort();
-}
-/** Returns an object containing a sorted string set only when the set is not empty. */
-function optionalSortedStringSetProperty(key, values) {
-	return values.size === 0 ? {} : { [key]: sortedStringSet(values) };
+function limitItems(items, limit) {
+	if (limit === void 0) return items;
+	return items.slice(0, limit);
 }
 //#endregion
-export { matchesOptionalValue, omitUndefined, optionalProperty, optionalSortedStringSetProperty, sortedStringSet, uniqueBy };
+export { limitItems, matchesOptionalValue, omitUndefined, uniqueBy };

package/dist/compiled-function.d.mts

@@ -1,27 +1,22 @@
 import { RegistryLike, WorkflowImplementation } from "./types/definition.mjs";
-import { WorkflowStepApi, WorkflowStepDefinition } from "./types/step.mjs";
-import { CompiledWorkflowFunction, WorkflowClient, WorkflowRunHandle } from "./types/client.mjs";
+import { StepApi, StepDefinition } from "./types/step.mjs";
+import { CompiledWorkflowFunction } from "./types/client.mjs";
 //#region src/compiled-function.d.ts
-type AnyCompiledWorkflowFunction = (...args: never[]) => unknown;
-type AnyCompiledWorkflowImplementation = WorkflowImplementation<readonly unknown[], unknown, readonly unknown[]>;
-type AnyCompiledWorkflowStepDefinition = WorkflowStepDefinition<readonly unknown[], unknown>;
+export declare const COMPILED_WORKFLOW: unique symbol;
+export declare const COMPILED_STEP: unique symbol;
+type AnyCompiledImplementation = WorkflowImplementation<readonly unknown[], unknown, readonly unknown[]>;
 /** Attaches compiled workflow metadata to a directive-authored function. */
-declare function attachWorkflowDefinition<TArgs extends readonly unknown[], TOutput>(fn: CompiledWorkflowFunction<TArgs, TOutput>, definition: WorkflowImplementation<TArgs, Awaited<TOutput>, TArgs>): CompiledWorkflowFunction<TArgs, TOutput>;
+export declare function attachWorkflowDefinition<TArgs extends readonly unknown[], TOutput>(fn: CompiledWorkflowFunction<TArgs, TOutput>, definition: WorkflowImplementation<NoInfer<TArgs>, Awaited<NoInfer<TOutput>>, NoInfer<TArgs>>): CompiledWorkflowFunction<TArgs, TOutput>;
 /** Attaches compiled step metadata to a directive-authored function. */
-declare function attachWorkflowStepDefinition<TArgs extends readonly unknown[], TOutput>(fn: CompiledWorkflowFunction<TArgs, TOutput>, definition: WorkflowStepDefinition<TArgs, Awaited<TOutput>>): CompiledWorkflowFunction<TArgs, TOutput>;
+export declare function attachWorkflowStepDefinition<TArgs extends readonly unknown[], TOutput>(fn: CompiledWorkflowFunction<TArgs, TOutput>, definition: StepDefinition<NoInfer<TArgs>, Awaited<NoInfer<TOutput>>>): CompiledWorkflowFunction<TArgs, TOutput>;
 /** Reads workflow metadata previously attached to a compiled workflow function. */
-declare function getWorkflowFunctionDefinition<TArgs extends readonly unknown[], TOutput>(fn: CompiledWorkflowFunction<TArgs, TOutput>): WorkflowImplementation<TArgs, Awaited<TOutput>, TArgs> | undefined;
+export declare function getWorkflowFunctionDefinition<TArgs extends readonly unknown[], TOutput>(fn: CompiledWorkflowFunction<TArgs, TOutput>): WorkflowImplementation<TArgs, Awaited<TOutput>, TArgs> | undefined;
 /** Reads step metadata previously attached to a compiled step function. */
-declare function getWorkflowStepFunctionDefinition<TArgs extends readonly unknown[], TOutput>(fn: CompiledWorkflowFunction<TArgs, TOutput>): WorkflowStepDefinition<TArgs, Awaited<TOutput>> | undefined;
-/** Reads erased workflow metadata from a function after runtime validation. */
-declare function getCompiledWorkflowDefinition(fn: AnyCompiledWorkflowFunction): AnyCompiledWorkflowImplementation | undefined;
-/** Reads erased step metadata from a function after runtime validation. */
-declare function getCompiledWorkflowStepDefinition(fn: AnyCompiledWorkflowFunction): AnyCompiledWorkflowStepDefinition | undefined;
-/** Registers compiled workflow functions with a workflow registry. */
-declare function registerWorkflowFunctions(registry: RegistryLike, workflows: readonly AnyCompiledWorkflowFunction[]): void;
-/** Starts a compiled workflow function through a workflow client. */
-declare function runWorkflowFunction<TArgs extends readonly unknown[], TOutput>(client: WorkflowClient, workflow: CompiledWorkflowFunction<TArgs, TOutput>, ...args: TArgs): Promise<WorkflowRunHandle<Awaited<TOutput>>>;
+export declare function getWorkflowStepFunctionDefinition<TArgs extends readonly unknown[], TOutput>(fn: CompiledWorkflowFunction<TArgs, TOutput>): StepDefinition<TArgs, Awaited<TOutput>> | undefined;
+/** Reads compiler-owned metadata for heterogeneous workflow registration. */
+export declare function getCompiledDefinition(fn: Function): AnyCompiledImplementation | undefined;
+export declare function registerWorkflowFunctions(registry: RegistryLike, workflows: readonly Function[]): void;
 /** Calls a compiled step function through the durable step API when metadata is present. */
-declare function callWorkflowStepFunction<TArgs extends readonly unknown[], TOutput>(step: WorkflowStepApi, fn: CompiledWorkflowFunction<TArgs, TOutput>, ...args: TArgs): Promise<Awaited<TOutput>>;
+export declare function callWorkflowStepFunction<TArgs extends readonly unknown[], TOutput>(step: StepApi, fn: CompiledWorkflowFunction<TArgs, TOutput>, ...args: TArgs): Promise<Awaited<TOutput>>;
 //#endregion
-export { attachWorkflowDefinition, attachWorkflowStepDefinition, callWorkflowStepFunction, getCompiledWorkflowDefinition, getCompiledWorkflowStepDefinition, getWorkflowFunctionDefinition, getWorkflowStepFunctionDefinition, registerWorkflowFunctions, runWorkflowFunction };
+export {};

package/dist/compiled-function.mjs

@@ -1,54 +1,42 @@
 import { WorkflowDefinitionError } from "./errors/definition.mjs";
 import "./errors/mod.mjs";
 //#region src/compiled-function.ts
-const workflowDefinitions = /* @__PURE__ */ new WeakMap();
-const stepDefinitions = /* @__PURE__ */ new WeakMap();
+const COMPILED_WORKFLOW = Symbol("temelj.workflow.definition");
+const COMPILED_STEP = Symbol("temelj.workflow.step");
 /** Attaches compiled workflow metadata to a directive-authored function. */
 function attachWorkflowDefinition(fn, definition) {
-	workflowDefinitions.set(fn, definition);
+	Object.defineProperty(fn, COMPILED_WORKFLOW, { value: definition });
 	return fn;
 }
 /** Attaches compiled step metadata to a directive-authored function. */
 function attachWorkflowStepDefinition(fn, definition) {
-	stepDefinitions.set(fn, definition);
+	Object.defineProperty(fn, COMPILED_STEP, { value: definition });
 	return fn;
 }
 /** Reads workflow metadata previously attached to a compiled workflow function. */
 function getWorkflowFunctionDefinition(fn) {
-	return getCompiledWorkflowDefinition(fn);
+	return fn[COMPILED_WORKFLOW];
 }
 /** Reads step metadata previously attached to a compiled step function. */
 function getWorkflowStepFunctionDefinition(fn) {
-	return getCompiledWorkflowStepDefinition(fn);
+	return fn[COMPILED_STEP];
 }
-/** Reads erased workflow metadata from a function after runtime validation. */
-function getCompiledWorkflowDefinition(fn) {
-	return workflowDefinitions.get(fn);
+/** Reads compiler-owned metadata for heterogeneous workflow registration. */
+function getCompiledDefinition(fn) {
+	return Object.getOwnPropertyDescriptor(fn, COMPILED_WORKFLOW)?.value;
 }
-/** Reads erased step metadata from a function after runtime validation. */
-function getCompiledWorkflowStepDefinition(fn) {
-	return stepDefinitions.get(fn);
-}
-/** Registers compiled workflow functions with a workflow registry. */
 function registerWorkflowFunctions(registry, workflows) {
 	for (const workflow of workflows) {
-		const definition = getCompiledWorkflowDefinition(workflow);
+		const definition = getCompiledDefinition(workflow);
 		if (definition === void 0) WorkflowDefinitionError.compiledMetadataMissing();
 		registry.register(definition);
 	}
 }
-/** Starts a compiled workflow function through a workflow client. */
-async function runWorkflowFunction(client, workflow, ...args) {
-	const definition = getWorkflowFunctionDefinition(workflow);
-	if (definition === void 0) WorkflowDefinitionError.compiledMetadataMissing();
-	client.register(definition);
-	return await client.runs.start(definition.definition, args);
-}
 /** Calls a compiled step function through the durable step API when metadata is present. */
 async function callWorkflowStepFunction(step, fn, ...args) {
 	const definition = getWorkflowStepFunctionDefinition(fn);
 	if (definition === void 0) return await fn(...args);
-	return await step.task.call(definition, ...args);
+	return await step.call(definition, ...args);
 }
 //#endregion
-export { attachWorkflowDefinition, attachWorkflowStepDefinition, callWorkflowStepFunction, getCompiledWorkflowDefinition, getCompiledWorkflowStepDefinition, getWorkflowFunctionDefinition, getWorkflowStepFunctionDefinition, registerWorkflowFunctions, runWorkflowFunction };
+export { COMPILED_STEP, COMPILED_WORKFLOW, attachWorkflowDefinition, attachWorkflowStepDefinition, callWorkflowStepFunction, getCompiledDefinition, getWorkflowFunctionDefinition, getWorkflowStepFunctionDefinition, registerWorkflowFunctions };

package/dist/compiled.d.mts

@@ -0,0 +1,4 @@
+import { attachWorkflowDefinition, attachWorkflowStepDefinition, callWorkflowStepFunction } from "./compiled-function.mjs";
+import { implementWorkflow } from "./definition.mjs";
+import { defineWorkflowStep } from "./step-definition.mjs";
+export { attachWorkflowDefinition, attachWorkflowStepDefinition, callWorkflowStepFunction, defineWorkflowStep, implementWorkflow };

package/dist/compiled.mjs

@@ -0,0 +1,4 @@
+import { attachWorkflowDefinition, attachWorkflowStepDefinition, callWorkflowStepFunction } from "./compiled-function.mjs";
+import { implementWorkflow } from "./definition.mjs";
+import { defineWorkflowStep } from "./step-definition.mjs";
+export { attachWorkflowDefinition, attachWorkflowStepDefinition, callWorkflowStepFunction, defineWorkflowStep, implementWorkflow };

package/dist/compiler/ast.d.mts

@@ -0,0 +1,26 @@
+import { BindingIdentifier, CallExpression, Node, Program } from "oxc-parser";
+//#region src/compiler/ast.d.ts
+type AstNode = Node | Program;
+export interface SourceFile {
+  readonly fileName: string;
+  readonly text: string;
+  readonly program: Program;
+}
+interface WorkflowSpan {
+  readonly start: number;
+  readonly end: number;
+}
+export declare function parseSource(fileName: string, text: string): SourceFile;
+export declare function spanText(sourceFile: SourceFile, node: WorkflowSpan): string;
+export declare function leadingTriviaStart(text: string, start: number): number;
+interface SourcePosition {
+  readonly line: number;
+  readonly column: number;
+}
+export declare function lineAndColumnOfPosition(text: string, position: number): SourcePosition;
+export declare function visitNode(node: AstNode, visitor: (node: AstNode) => void): void;
+export declare function workflowNodeChildren(node: AstNode): readonly AstNode[];
+export declare function isIdentifier(node: Node): node is BindingIdentifier;
+export declare function isCallExpression(node: Node): node is CallExpression;
+//#endregion
+export {};

package/dist/{vite → compiler}/ast.mjs

@@ -1,6 +1,6 @@
 import { workflowSourceKindForId } from "./source.mjs";
-import { parseSync } from "oxc-parser";
-//#region src/vite/ast.ts
+import { parseSync, visitorKeys } from "oxc-parser";
+//#region src/compiler/ast.ts
 const PARSER_OPTIONS_BY_SOURCE_KIND = {
 	js: {
 		lang: "js",
@@ -19,7 +19,7 @@ const PARSER_OPTIONS_BY_SOURCE_KIND = {
 		astType: "ts"
 	}
 };
-function parseWorkflowSource(fileName, text) {
+function parseSource(fileName, text) {
 	const result = parseSync(fileName, text, {
 		...PARSER_OPTIONS_BY_SOURCE_KIND[workflowSourceKindForId(fileName)],
 		sourceType: "module"
@@ -46,28 +46,36 @@ function lineAndColumnOfPosition(text, position) {
 		column: lines.at(-1).length + 1
 	};
 }
-function visitWorkflowNode(node, visitor) {
+function visitNode(node, visitor) {
 	for (const child of workflowNodeChildren(node)) {
 		visitor(child);
-		visitWorkflowNode(child, visitor);
+		visitNode(child, visitor);
 	}
 }
 function workflowNodeChildren(node) {
 	const children = [];
+	const keys = visitorKeys[node.type] ?? [];
 	for (const [key, value] of Object.entries(node)) {
-		if (key === "parent" || key === "decorators" || key === "typeAnnotation" || key === "typeArguments" || key === "typeParameters" || key === "returnType") continue;
-		if (isWorkflowAstNode(value)) {
-			children.push(value);
-			continue;
-		}
-		if (Array.isArray(value)) {
-			for (const item of value) if (isWorkflowAstNode(item)) children.push(item);
-		}
+		if (!keys.includes(key) || NON_RUNTIME_AST_KEYS.has(key)) continue;
+		const child = value;
+		if (Array.isArray(child)) {
+			for (const item of child) if (item !== null) children.push(item);
+		} else if (child !== null && child !== void 0) children.push(child);
 	}
 	return children;
 }
-function isWorkflowAstNode(value) {
-	return typeof value === "object" && value !== null && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
+const NON_RUNTIME_AST_KEYS = /* @__PURE__ */ new Set([
+	"decorators",
+	"typeAnnotation",
+	"typeArguments",
+	"typeParameters",
+	"returnType"
+]);
+function isIdentifier(node) {
+	return node.type === "Identifier";
+}
+function isCallExpression(node) {
+	return node.type === "CallExpression";
 }
 //#endregion
-export { leadingTriviaStart, lineAndColumnOfPosition, parseWorkflowSource, spanText, visitWorkflowNode, workflowNodeChildren };
+export { isCallExpression, isIdentifier, leadingTriviaStart, lineAndColumnOfPosition, parseSource, spanText, visitNode, workflowNodeChildren };

package/dist/{vite → compiler}/error.d.mts

@@ -1,7 +1,6 @@
-//#region src/vite/error.d.ts
-/** Error thrown for transform failures. */
-declare class WorkflowTransformError extends Error {
-  constructor(message: string, context?: Function);
+//#region src/compiler/error.d.ts
+export declare class WorkflowTransformError extends Error {
+  constructor(message: string);
   static directiveParametersMustBeIdentifiers(this: void): never;
   static metadataMissing(this: void, name: string): never;
   static directiveFunctionMustBeNamed(this: void): never;
@@ -15,5 +14,4 @@ declare class WorkflowTransformError extends Error {
   static invalidSourceReadRange(this: void, start: number, end: number): never;
   static overlappingSourceReplacementRanges(this: void, currentStart: number, currentEnd: number, previousStart: number, previousEnd: number): never;
 }
-//#endregion
-export { WorkflowTransformError };
+//#endregion

package/dist/{vite → compiler}/error.mjs

@@ -1,46 +1,44 @@
-//#region src/vite/error.ts
-/** Error thrown for transform failures. */
+//#region src/compiler/error.ts
 var WorkflowTransformError = class WorkflowTransformError extends Error {
-	constructor(message, context) {
+	constructor(message) {
 		super(message);
 		this.name = "WorkflowTransformError";
-		if (Error.captureStackTrace !== void 0) Error.captureStackTrace(this, context ?? this.constructor);
 	}
 	static directiveParametersMustBeIdentifiers() {
-		throw new WorkflowTransformError("Workflow directive parameters must be identifiers", WorkflowTransformError.directiveParametersMustBeIdentifiers);
+		throw new WorkflowTransformError("Workflow directive parameters must be identifiers");
 	}
 	static metadataMissing(name) {
-		throw new WorkflowTransformError(`Workflow metadata was not collected for ${name}`, WorkflowTransformError.metadataMissing);
+		throw new WorkflowTransformError(`Workflow metadata was not collected for ${name}`);
 	}
 	static directiveFunctionMustBeNamed() {
-		throw new WorkflowTransformError("Directive function declarations must be named", WorkflowTransformError.directiveFunctionMustBeNamed);
+		throw new WorkflowTransformError("Directive function declarations must be named");
 	}
 	static directiveFunctionCannotBeGenerator(directive, name) {
-		throw new WorkflowTransformError(`"${directive}" function ${name} cannot be a generator`, WorkflowTransformError.directiveFunctionCannotBeGenerator);
+		throw new WorkflowTransformError(`"${directive}" function ${name} cannot be a generator`);
 	}
 	static workflowFunctionMustBeAsync(name) {
-		throw new WorkflowTransformError(`"use workflow" function ${name} must be async`, WorkflowTransformError.workflowFunctionMustBeAsync);
+		throw new WorkflowTransformError(`"use workflow" function ${name} must be async`);
 	}
 	static directivesMustBeTopLevel() {
-		throw new WorkflowTransformError("Workflow directives are only supported on top-level functions", WorkflowTransformError.directivesMustBeTopLevel);
+		throw new WorkflowTransformError("Workflow directives are only supported on top-level functions");
 	}
 	static directiveImportsMustBeNamed(specifier) {
-		throw new WorkflowTransformError(`Workflow directive imports from ${specifier} must use named imports`, WorkflowTransformError.directiveImportsMustBeNamed);
+		throw new WorkflowTransformError(`Workflow directive imports from ${specifier} must use named imports`);
 	}
 	static directiveReExportsMustBeNamed(specifier) {
-		throw new WorkflowTransformError(`Workflow directive re-exports from ${specifier} must use named exports`, WorkflowTransformError.directiveReExportsMustBeNamed);
+		throw new WorkflowTransformError(`Workflow directive re-exports from ${specifier} must use named exports`);
 	}
 	static nondeterministicGlobal(workflowName, globalName, line, character) {
-		throw new WorkflowTransformError(`"use workflow" function ${workflowName} uses nondeterministic global ${globalName} at ${line}:${character}; use deterministic workflow helpers or durable steps`, WorkflowTransformError.nondeterministicGlobal);
+		throw new WorkflowTransformError(`"use workflow" function ${workflowName} uses nondeterministic global ${globalName} at ${line}:${character}; use deterministic workflow helpers or durable steps`);
 	}
 	static invalidSourceReplacementRange(start, end) {
-		throw new WorkflowTransformError(`Invalid source replacement range: ${start}..${end}`, WorkflowTransformError.invalidSourceReplacementRange);
+		throw new WorkflowTransformError(`Invalid source replacement range: ${start}..${end}`);
 	}
 	static invalidSourceReadRange(start, end) {
-		throw new WorkflowTransformError(`Invalid source read range: ${start}..${end}`, WorkflowTransformError.invalidSourceReadRange);
+		throw new WorkflowTransformError(`Invalid source read range: ${start}..${end}`);
 	}
 	static overlappingSourceReplacementRanges(currentStart, currentEnd, previousStart, previousEnd) {
-		throw new WorkflowTransformError(`Overlapping source replacement ranges: ${currentStart}..${currentEnd} and ${previousStart}..${previousEnd}`, WorkflowTransformError.overlappingSourceReplacementRanges);
+		throw new WorkflowTransformError(`Overlapping source replacement ranges: ${currentStart}..${currentEnd} and ${previousStart}..${previousEnd}`);
 	}
 };
 //#endregion

package/dist/compiler/manifest.d.mts

@@ -0,0 +1,6 @@
+import { TransformManifest, TransformManifestFunction, TransformManifestImportEdge } from "../types/compiler.mjs";
+import { Program } from "oxc-parser";
+//#region src/compiler/manifest.d.ts
+export declare function collectImportedStepBindings(sourceFile: Program, file: string, manifests: readonly TransformManifest[]): ReadonlyMap<string, TransformManifestImportEdge>;
+export declare function collectReExportedManifestFunctions(sourceFile: Program, file: string, manifests: readonly TransformManifest[]): readonly TransformManifestFunction[];
+//#endregion

package/dist/{vite → compiler}/manifest.mjs

@@ -1,6 +1,6 @@
 import { WorkflowTransformError } from "./error.mjs";
 import path from "node:path";
-//#region src/vite/manifest.ts
+//#region src/compiler/manifest.ts
 const JS_TS_EXTENSION_PATTERN = /\.[cm]?[jt]sx?$/;
 function collectImportedStepBindings(sourceFile, file, manifests) {
 	const manifestBySource = new Map(manifests.map((manifest) => [manifest.file, manifest]));
@@ -16,14 +16,15 @@ function collectImportedStepBindings(sourceFile, file, manifests) {
 			const importName = moduleExportNameText(element.imported);
 			const step = exportedSteps.get(importName);
 			if (step === void 0) continue;
-			importedSteps.set(element.local.name, {
+			const binding = {
 				source: resolved.source,
 				importName,
 				localName: element.local.name,
 				kind: "step",
 				workflowName: step.workflowName,
-				...step.version === void 0 ? {} : { version: step.version }
-			});
+				version: step.version
+			};
+			importedSteps.set(element.local.name, binding);
 		}
 	}
 	return importedSteps;
@@ -46,14 +47,15 @@ function collectReExportedManifestFunctions(sourceFile, file, manifests) {
 			const importName = moduleExportNameText(element.local);
 			const entry = exported.get(importName);
 			if (entry === void 0) continue;
-			functions.push({
+			const reExport = {
 				kind: entry.kind,
 				exportName: moduleExportNameText(element.exported),
 				localName: entry.localName,
 				generatedName: entry.generatedName,
 				workflowName: entry.workflowName,
-				...entry.version === void 0 ? {} : { version: entry.version }
-			});
+				version: entry.version
+			};
+			functions.push(reExport);
 		}
 	}
 	return functions;

package/dist/compiler/plugin.d.mts

@@ -0,0 +1,7 @@
+import { PluginOptions } from "../types/compiler.mjs";
+//#region src/compiler/plugin.d.ts
+export declare const workflowPlugin: import("unplugin").UnpluginInstance<PluginOptions | undefined, false>;
+/** Creates the Vite plugin that compiles workflow and step directives. */
+export declare const workflow: (options?: PluginOptions) => ReturnType<typeof workflowPlugin.vite>;
+//#endregion
+export type { PluginOptions };

package/dist/{vite → compiler}/plugin.mjs

@@ -1,10 +1,10 @@
 import { stripQuery } from "./source.mjs";
-import { parseWorkflowSource } from "./ast.mjs";
-import { transformWorkflowSource } from "./transform.mjs";
+import { parseSource } from "./ast.mjs";
+import { hasDirectiveCandidate, transformWorkflowSource } from "./transform.mjs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createUnplugin } from "unplugin";
-//#region src/vite/plugin.ts
+//#region src/compiler/plugin.ts
 const workflowUnpluginFactory = (options = {}) => {
 	const include = options.include?.map((pattern) => new RegExp(pattern));
 	const exclude = options.exclude?.map((pattern) => new RegExp(pattern));
@@ -17,49 +17,54 @@ const workflowUnpluginFactory = (options = {}) => {
 		transformInclude(id) {
 			return matchesFilters(id, include, exclude);
 		},
-		async transform(code, id) {
-			await loadWorkflowImportManifests({
-				context: this,
-				code,
-				id,
-				options,
-				include,
-				exclude,
-				manifests,
-				manifestFileById,
-				loadingManifests
-			});
-			const result = transformAndStoreWorkflowManifest(code, id, options, manifests, manifestFileById);
-			if (result === void 0) return null;
-			return {
-				code: result.code,
-				...result.map === void 0 ? {} : { map: toUnpluginSourceMap(result.map) }
-			};
+		transform(code, id) {
+			return transformWithImports(void 0, code, id);
 		},
-		vite: { handleHotUpdate(context) {
-			if (!matchesFilters(context.file, include, exclude)) return;
-			const modules = context.modules.filter((module) => module.id !== null);
-			if (modules.length === 0) return;
-			return modules;
-		} }
+		rollup: { transform: transformWithNativeContext },
+		rolldown: { transform: transformWithNativeContext },
+		unloader: { transform: transformWithNativeContext },
+		vite: {
+			transform: transformWithNativeContext,
+			handleHotUpdate(context) {
+				if (!matchesFilters(context.file, include, exclude)) return;
+				const modules = context.modules.filter((module) => module.id !== null);
+				if (modules.length === 0) return;
+				return modules;
+			}
+		}
 	};
+	async function transformWithImports(context, code, id) {
+		if (!matchesFilters(id, include, exclude)) return null;
+		await loadImportManifests({
+			context,
+			code,
+			id,
+			options,
+			include,
+			exclude,
+			manifests,
+			manifestFileById,
+			loadingManifests
+		});
+		return transformAndStoreManifest(code, id, options, manifests, manifestFileById) ?? null;
+	}
+	function transformWithNativeContext(code, id) {
+		return transformWithImports(this, code, id);
+	}
 };
 const JS_TS_EXTENSION_PATTERN = /\.[cm]?[jt]sx?$/;
-function toUnpluginSourceMap(map) {
-	return map;
-}
 const workflowPlugin = createUnplugin(workflowUnpluginFactory);
 /** Creates the Vite plugin that compiles workflow and step directives. */
 const workflow = workflowPlugin.vite;
-async function loadWorkflowImportManifests({ context, code, id, options, include, exclude, manifests, manifestFileById, loadingManifests }) {
-	if (!hasWorkflowManifestCandidate(code) || loadingManifests.has(id)) return;
+async function loadImportManifests({ context, code, id, options, include, exclude, manifests, manifestFileById, loadingManifests }) {
+	if (!hasDirectiveCandidate(code) || loadingManifests.has(id)) return;
 	loadingManifests.add(id);
 	try {
-		for (const source of collectRelativeImportSources(code, id)) if (canLoadWorkflowImportManifests(context)) {
+		for (const source of collectRelativeImportSources(code, id)) if (context !== void 0) {
 			const resolved = await context.resolve(source, id, { skipSelf: true });
 			if (resolved === null || !matchesFilters(resolved.id, include, exclude)) continue;
 			await context.load({ id: resolved.id });
-			await preloadWorkflowImportFile({
+			await preloadImportFile({
 				context,
 				id: resolved.id,
 				options,
@@ -72,7 +77,7 @@ async function loadWorkflowImportManifests({ context, code, id, options, include
 		} else {
 			const resolved = await resolveRelativeImportFile(source, id);
 			if (resolved === void 0 || !matchesFilters(resolved, include, exclude)) continue;
-			await preloadWorkflowImportFile({
+			await preloadImportFile({
 				context,
 				id: resolved,
 				options,
@@ -87,11 +92,11 @@ async function loadWorkflowImportManifests({ context, code, id, options, include
 		loadingManifests.delete(id);
 	}
 }
-async function preloadWorkflowImportFile({ context, id, options, include, exclude, manifests, manifestFileById, loadingManifests }) {
+async function preloadImportFile({ context, id, options, include, exclude, manifests, manifestFileById, loadingManifests }) {
 	const cleanId = stripQuery(id);
 	const importedCode = await fs.readFile(cleanId, "utf8").catch(() => void 0);
 	if (importedCode === void 0) return;
-	await loadWorkflowImportManifests({
+	await loadImportManifests({
 		context,
 		code: importedCode,
 		id: cleanId,
@@ -102,9 +107,9 @@ async function preloadWorkflowImportFile({ context, id, options, include, exclud
 		manifestFileById,
 		loadingManifests
 	});
-	transformAndStoreWorkflowManifest(importedCode, cleanId, options, manifests, manifestFileById);
+	transformAndStoreManifest(importedCode, cleanId, options, manifests, manifestFileById);
 }
-function transformAndStoreWorkflowManifest(code, id, options, manifests, manifestFileById) {
+function transformAndStoreManifest(code, id, options, manifests, manifestFileById) {
 	const result = transformWorkflowSource(code, id, {
 		...options,
 		manifests: [...options.manifests ?? [], ...manifests.values()]
@@ -123,15 +128,9 @@ function transformAndStoreWorkflowManifest(code, id, options, manifests, manifes
 	manifestFileById.set(id, result.manifest.file);
 	return result;
 }
-function canLoadWorkflowImportManifests(context) {
-	return typeof context.resolve === "function" && typeof context.load === "function";
-}
-function hasWorkflowManifestCandidate(code) {
-	return code.includes("\"use workflow\"") || code.includes("'use workflow'") || code.includes("\"use step\"") || code.includes("'use step'") || code.includes(" from ");
-}
 function collectRelativeImportSources(code, id) {
 	if (!JS_TS_EXTENSION_PATTERN.test(stripQuery(id))) return [];
-	const sourceFile = parseWorkflowSource(id, code);
+	const sourceFile = parseSource(id, code);
 	const sources = /* @__PURE__ */ new Set();
 	for (const statement of sourceFile.program.body) if ((statement.type === "ImportDeclaration" || statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") && statement.source !== null && isRelativeImportSource(statement.source.value)) sources.add(statement.source.value);
 	return [...sources];

package/dist/compiler/safety.d.mts

@@ -0,0 +1,12 @@
+import { FunctionBody, Program } from "oxc-parser";
+//#region src/compiler/safety.d.ts
+interface SafetyTarget {
+  readonly name: string;
+  readonly body: FunctionBody;
+}
+export declare function rejectObviousNondeterministicGlobals(entry: SafetyTarget, sourceFile: {
+  readonly text: string;
+  readonly program: Program;
+}): void;
+//#endregion
+export {};

package/dist/{vite → compiler}/safety.mjs

@@ -1,7 +1,7 @@
-import { lineAndColumnOfPosition, visitWorkflowNode } from "./ast.mjs";
+import { isCallExpression, isIdentifier, lineAndColumnOfPosition, visitNode } from "./ast.mjs";
 import { WorkflowTransformError } from "./error.mjs";
 import { builtinModules } from "node:module";
-//#region src/vite/safety.ts
+//#region src/compiler/safety.ts
 const unsafeGlobalCallNames = /* @__PURE__ */ new Set([
 	"Date",
 	"fetch",
@@ -11,8 +11,8 @@ const unsafeGlobalCallNames = /* @__PURE__ */ new Set([
 	"queueMicrotask"
 ]);
 function rejectObviousNondeterministicGlobals(entry, sourceFile) {
-	const unsafeImports = collectUnsafeWorkflowImportBindings(sourceFile.program);
-	visitWorkflowNode(entry.body, (node) => {
+	const unsafeImports = collectUnsafeImportBindings(sourceFile.program);
+	visitNode(entry.body, (node) => {
 		if (isIdentifier(node) && unsafeImports.has(node.name)) throwNondeterministicGlobalError(entry.name, unsafeImports.get(node.name), node, sourceFile);
 		if (isNewExpression(node) && isIdentifier(node.callee) && node.callee.name === "Date") throwNondeterministicGlobalError(entry.name, "Date", node, sourceFile);
 		if (isCallExpression(node) && isIdentifier(node.callee) && unsafeGlobalCallNames.has(node.callee.name)) throwNondeterministicGlobalError(entry.name, node.callee.name, node, sourceFile);
@@ -22,7 +22,7 @@ function rejectObviousNondeterministicGlobals(entry, sourceFile) {
 		}
 	});
 }
-function collectUnsafeWorkflowImportBindings(sourceFile) {
+function collectUnsafeImportBindings(sourceFile) {
 	const bindings = /* @__PURE__ */ new Map();
 	for (const statement of sourceFile.body) {
 		if (statement.type !== "ImportDeclaration") continue;
@@ -77,12 +77,6 @@ function stripGlobalQualifier(path) {
 	if (path.startsWith("window.")) return path.slice(7);
 	return path;
 }
-function isIdentifier(node) {
-	return node.type === "Identifier";
-}
-function isCallExpression(node) {
-	return node.type === "CallExpression";
-}
 function isNewExpression(node) {
 	return node.type === "NewExpression";
 }

package/dist/{vite → compiler}/source-edit.d.mts

@@ -1,6 +1,6 @@
-//#region src/vite/source-edit.d.ts
+//#region src/compiler/source-edit.d.ts
 /** Small source rewriting helper for AST-position based transforms. */
-declare class SourceEditor {
+export declare class SourceEditor {
   #private;
   constructor(source: string);
   remove(start: number, end: number): void;
@@ -8,5 +8,4 @@ declare class SourceEditor {
   read(start: number, end: number): string;
   toString(): string;
 }
-//#endregion
-export { SourceEditor };
+//#endregion

package/dist/{vite → compiler}/source-edit.mjs

@@ -1,5 +1,5 @@
 import { WorkflowTransformError } from "./error.mjs";
-//#region src/vite/source-edit.ts
+//#region src/compiler/source-edit.ts
 /** Small source rewriting helper for AST-position based transforms. */
 var SourceEditor = class {
 	#source;