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

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

@@ -1,4 +1,5 @@
-//#region src/vite/source-map.d.ts
+import { SourceMap } from "../types/compiler.mjs";
+//#region src/compiler/source-map.d.ts
 interface GeneratedSourceMapOptions {
   readonly id: string;
   readonly originalCode: string;
@@ -6,6 +7,6 @@ interface GeneratedSourceMapOptions {
   readonly generatedSource: string;
   readonly sourceText: string;
 }
-declare function createGeneratedSourceMap(options: GeneratedSourceMapOptions): unknown;
+export declare function createGeneratedSourceMap(options: GeneratedSourceMapOptions): SourceMap;
 //#endregion
-export { GeneratedSourceMapOptions, createGeneratedSourceMap };
+export {};

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

@@ -1,5 +1,5 @@
 import { stripQuery } from "./source.mjs";
-//#region src/vite/source-map.ts
+//#region src/compiler/source-map.ts
 function createGeneratedSourceMap(options) {
 	return {
 		version: 3,
@@ -7,10 +7,10 @@ function createGeneratedSourceMap(options) {
 		sources: [stripQuery(options.id)],
 		sourcesContent: [options.originalCode],
 		names: [],
-		mappings: createWorkflowTransformMappings(options)
+		mappings: createTransformMappings(options)
 	};
 }
-function createWorkflowTransformMappings(options) {
+function createTransformMappings(options) {
 	const generatedLines = options.generatedCode.split("\n");
 	const sourceStart = options.sourceText === "" ? -1 : options.generatedSource.indexOf(options.sourceText);
 	const generatedStart = options.sourceText === "" ? -1 : options.generatedCode.indexOf(options.sourceText);

package/dist/compiler/source.d.mts

@@ -0,0 +1,7 @@
+//#region src/compiler/source.d.ts
+/** Removes a URL or Vite query suffix from an ID. */
+export declare function stripQuery(id: string): string;
+type SourceKind = "js" | "json" | "ts" | "tsx";
+export declare function workflowSourceKindForId(id: string): SourceKind;
+//#endregion
+export {};

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

@@ -1,4 +1,4 @@
-//#region src/vite/source.ts
+//#region src/compiler/source.ts
 /** Removes a URL or Vite query suffix from an ID. */
 function stripQuery(id) {
 	return id.split("?", 1)[0];

package/dist/compiler/transform.d.mts

@@ -0,0 +1,12 @@
+import { WorkflowTransformError } from "./error.mjs";
+import { DirectiveKind, TransformManifest, TransformManifestFunction, TransformManifestImportEdge, TransformMetadata, TransformMetadataEntry, TransformOptions, TransformResult } from "../types/compiler.mjs";
+//#region src/compiler/transform.d.ts
+/** Prefix reserved for helper identifiers that the transform injects. */
+export declare const GENERATED_PREFIX = "__temelj";
+export declare function makeGeneratedName(...parts: readonly string[]): string;
+/** Transforms one TypeScript module containing workflow or step directives. */
+export declare function transformWorkflowSource(code: string, id: string, options?: TransformOptions): TransformResult | undefined;
+/** A cheap text check for code that may hold directives or imports worth parsing. */
+export declare function hasDirectiveCandidate(code: string): boolean;
+//#endregion
+export { type DirectiveKind, type TransformManifest, type TransformManifestFunction, type TransformManifestImportEdge, type TransformMetadata, type TransformMetadataEntry, type TransformOptions, type TransformResult, WorkflowTransformError };

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

@@ -1,14 +1,19 @@
 import { stripQuery } from "./source.mjs";
-import { leadingTriviaStart, parseWorkflowSource, spanText, visitWorkflowNode, workflowNodeChildren } from "./ast.mjs";
+import { isCallExpression, isIdentifier, leadingTriviaStart, parseSource, spanText, visitNode, workflowNodeChildren } from "./ast.mjs";
 import { WorkflowTransformError } from "./error.mjs";
-import { makeGeneratedName } from "./generated-name.mjs";
 import { collectImportedStepBindings, collectReExportedManifestFunctions } from "./manifest.mjs";
 import { rejectObviousNondeterministicGlobals } from "./safety.mjs";
 import { SourceEditor } from "./source-edit.mjs";
 import { createGeneratedSourceMap } from "./source-map.mjs";
+import { isFunction } from "@temelj/value";
 import path from "node:path";
-//#region src/vite/transform.ts
+//#region src/compiler/transform.ts
 const JS_TS_EXTENSION_PATTERN = /\.[cm]?[jt]sx?$/;
+/** Prefix reserved for helper identifiers that the transform injects. */
+const GENERATED_PREFIX = "__temelj";
+function makeGeneratedName(...parts) {
+	return [GENERATED_PREFIX, ...parts].join("_");
+}
 const GENERATED_CONTEXT_NAME = makeGeneratedName("context");
 const GENERATED_DEFINE_WORKFLOW_NAME = makeGeneratedName("implementWorkflow");
 const GENERATED_DEFINE_WORKFLOW_STEP_NAME = makeGeneratedName("defineWorkflowStep");
@@ -17,8 +22,8 @@ const GENERATED_ATTACH_WORKFLOW_STEP_DEFINITION_NAME = makeGeneratedName("attach
 const GENERATED_CALL_WORKFLOW_STEP_FUNCTION_NAME = makeGeneratedName("callWorkflowStepFunction");
 /** Transforms one TypeScript module containing workflow or step directives. */
 function transformWorkflowSource(code, id, options = {}) {
-	if (!JS_TS_EXTENSION_PATTERN.test(stripQuery(id)) || !hasWorkflowTransformCandidateText(code)) return;
-	const sourceFile = parseWorkflowSource(id, code);
+	if (!JS_TS_EXTENSION_PATTERN.test(stripQuery(id)) || !hasDirectiveCandidate(code)) return;
+	const sourceFile = parseSource(id, code);
 	const directiveFunctions = collectDirectiveFunctions(sourceFile.program);
 	const file = relativeFile(id, options.root);
 	const reExportedFunctions = collectReExportedManifestFunctions(sourceFile.program, file, options.manifests ?? []);
@@ -42,13 +47,6 @@ function transformWorkflowSource(code, id, options = {}) {
 	].filter((part) => part !== "").join("\n\n")}\n`;
 	return {
 		code: transformedResultCode,
-		...options.sourcemap === true ? { map: createGeneratedSourceMap({
-			id,
-			originalCode: sourceFile.text,
-			generatedCode: transformedResultCode,
-			generatedSource: transformedCode,
-			sourceText
-		}) } : {},
 		metadata: {
 			file,
 			entries
@@ -57,18 +55,21 @@ function transformWorkflowSource(code, id, options = {}) {
 			file,
 			functions: [...localFunctions, ...reExportedFunctions],
 			imports: [...importedSteps.values()]
-		}
+		},
+		map: options.sourcemap === true ? createGeneratedSourceMap({
+			id,
+			originalCode: sourceFile.text,
+			generatedCode: transformedResultCode,
+			generatedSource: transformedCode,
+			sourceText
+		}) : void 0
 	};
 	function createDefinitionText(entry, metadata, currentSourceFile) {
 		const config = createDefinitionConfig(metadata);
 		if (entry.kind === "step") {
-			const contextName = uniqueName(GENERATED_CONTEXT_NAME, entry.parameters.map((parameter, index) => {
-				const name = parameterName(parameter);
-				if (name === void 0) WorkflowTransformError.directiveParametersMustBeIdentifiers();
-				return name || `arg${index}`;
-			}));
+			const contextName = uniqueName(GENERATED_CONTEXT_NAME, directiveParameterNames(entry.parameters));
 			return [
-				`const ${metadata.generatedName} = ${GENERATED_DEFINE_WORKFLOW_STEP_NAME}(${config}, async (${[...entry.parameters.map((parameter) => spanText(currentSourceFile, parameter)), contextName].join(", ")}) => {`,
+				`const ${metadata.generatedName} = ${GENERATED_DEFINE_WORKFLOW_STEP_NAME}(${config}, async (${[contextName, ...entry.parameters.map((parameter) => spanText(currentSourceFile, parameter))].join(", ")}) => {`,
 				bodyWithoutDirective(entry.body, currentSourceFile),
 				"});",
 				`${GENERATED_ATTACH_WORKFLOW_STEP_DEFINITION_NAME}(${entry.name}, ${metadata.generatedName});`
@@ -78,13 +79,14 @@ function transformWorkflowSource(code, id, options = {}) {
 		if (workflow === void 0) WorkflowTransformError.metadataMissing(entry.name);
 		return [
 			`const ${metadata.generatedName} = ${GENERATED_DEFINE_WORKFLOW_NAME}(${config}, async (${GENERATED_CONTEXT_NAME}) => {`,
-			createWorkflowBody(workflow, currentSourceFile, knownStepNames),
+			createBody(workflow, currentSourceFile, knownStepNames),
 			"});",
 			`${GENERATED_ATTACH_WORKFLOW_DEFINITION_NAME}(${entry.name}, ${metadata.generatedName});`
 		].join("\n");
 	}
 }
-function hasWorkflowTransformCandidateText(code) {
+/** A cheap text check for code that may hold directives or imports worth parsing. */
+function hasDirectiveCandidate(code) {
 	return code.includes("\"use workflow\"") || code.includes("'use workflow'") || code.includes("\"use step\"") || code.includes("'use step'") || code.includes(" from ");
 }
 function collectDirectiveFunctions(sourceFile) {
@@ -155,19 +157,19 @@ function rejectUnsupportedDirectiveFunction(node, kind, name) {
 	if (kind === "workflow" && !node.async) WorkflowTransformError.workflowFunctionMustBeAsync(name);
 }
 function rejectNestedDirectiveFunctions(sourceFile, topLevelBodies) {
-	visitWorkflowNode(sourceFile, (node) => {
+	visitNode(sourceFile, (node) => {
 		if (isFunctionLike(node) && node.body !== null && node.body.type === "BlockStatement" && !topLevelBodies.has(node.body) && directiveFromBody(node.body) !== void 0) WorkflowTransformError.directivesMustBeTopLevel();
 	});
 }
 function createMetadataEntry(entry, file, options) {
 	const workflowName = options.name?.(file, entry.name, entry.kind) ?? `${file}:${entry.name}`;
-	const version = typeof options.version === "function" ? options.version(file, entry.name) : options.version;
+	const version = isFunction(options.version) ? options.version(file, entry.name) : options.version;
 	return {
 		kind: entry.kind,
 		name: entry.name,
 		generatedName: makeGeneratedName(entry.kind, sanitizeIdentifier(entry.name)),
 		workflowName,
-		...version === void 0 ? {} : { version }
+		version
 	};
 }
 function createManifestFunction(entry, metadata) {
@@ -177,7 +179,7 @@ function createManifestFunction(entry, metadata) {
 		localName: entry.name,
 		generatedName: metadata.generatedName,
 		workflowName: metadata.workflowName,
-		...metadata.version === void 0 ? {} : { version: metadata.version }
+		version: metadata.version
 	};
 }
 function createDefinitionConfig(metadata) {
@@ -185,15 +187,18 @@ function createDefinitionConfig(metadata) {
 	if (metadata.version !== void 0) fields.push(`version: ${JSON.stringify(metadata.version)}`);
 	return `{ ${fields.join(", ")} }`;
 }
-function createWorkflowBody(entry, sourceFile, localStepNames) {
-	const names = entry.parameters.map((parameter, index) => {
+function directiveParameterNames(parameters) {
+	return parameters.map((parameter, index) => {
 		const name = parameterName(parameter);
 		if (name === void 0) WorkflowTransformError.directiveParametersMustBeIdentifiers();
 		return name || `arg${index}`;
 	});
+}
+function createBody(entry, sourceFile, localStepNames) {
+	const names = directiveParameterNames(entry.parameters);
 	const inputLine = `const ${names.length === 0 ? "[]" : `[${names.join(", ")}]`} = ${GENERATED_CONTEXT_NAME}.input;`;
 	rejectObviousNondeterministicGlobals(entry, sourceFile);
-	return `${inputLine}\n${rewriteWorkflowCalls(bodyWithoutDirective(entry.body, sourceFile), sourceFile, localStepNames, new Set(names))}`;
+	return `${inputLine}\n${rewriteCalls(bodyWithoutDirective(entry.body, sourceFile), sourceFile, localStepNames, new Set(names))}`;
 }
 function bodyWithoutDirective(body, sourceFile) {
 	const statements = body.body.slice(1);
@@ -202,9 +207,9 @@ function bodyWithoutDirective(body, sourceFile) {
 	const end = statements.at(-1).end;
 	return new SourceEditor(sourceFile.text).read(start, end);
 }
-function rewriteWorkflowCalls(bodyText, sourceFile, knownStepNames, initialLocalNames) {
+function rewriteCalls(bodyText, sourceFile, knownStepNames, initialLocalNames) {
 	const wrapped = `async function ${makeGeneratedName("workflow", "body")}() {${bodyText}}`;
-	const bodySource = parseWorkflowSource(sourceFile.fileName, wrapped);
+	const bodySource = parseSource(sourceFile.fileName, wrapped);
 	const editor = new SourceEditor(bodyText);
 	const offset = wrapped.indexOf(bodyText);
 	const wrapper = bodySource.program.body[0];
@@ -347,9 +352,6 @@ function collectBindingNames(name, localNames) {
 function parameterName(parameter) {
 	if (parameter.type === "Identifier") return parameter.name;
 }
-function isIdentifier(node) {
-	return node.type === "Identifier";
-}
 function isFunctionDeclaration(node) {
 	return node.type === "FunctionDeclaration";
 }
@@ -365,9 +367,6 @@ function isArrowOrFunctionExpression(node) {
 function isBlockStatement(node) {
 	return node.type === "BlockStatement";
 }
-function isCallExpression(node) {
-	return node.type === "CallExpression";
-}
 function uniqueName(base, usedNames) {
 	let name = base;
 	let index = 1;
@@ -378,7 +377,7 @@ function uniqueName(base, usedNames) {
 	}
 	return name;
 }
-function createRuntimeImportText(specifier = "@temelj/workflow") {
+function createRuntimeImportText(specifier = "@temelj/workflow/compiled") {
 	return [
 		"import {",
 		`  implementWorkflow as ${GENERATED_DEFINE_WORKFLOW_NAME},`,
@@ -402,4 +401,4 @@ function directiveText(kind) {
 	return kind === "workflow" ? "use workflow" : "use step";
 }
 //#endregion
-export { WorkflowTransformError, transformWorkflowSource };
+export { GENERATED_PREFIX, WorkflowTransformError, hasDirectiveCandidate, makeGeneratedName, transformWorkflowSource };

package/dist/definition.d.mts

@@ -1,37 +1,29 @@
-import { MessageId } from "./types/message-id.mjs";
-import { WorkflowDefinition, WorkflowDefinitionConfig, WorkflowHandler, WorkflowImplementation, WorkflowInputFromSchema, WorkflowRawInputFromSchema, WorkflowStartTarget } from "./types/definition.mjs";
-import { MessageChannel, MessageChannelConfig, SendMessageChannelOptions, WaitForMessageChannelOptions } from "./types/message.mjs";
+import { MessageId } from "./types/ids.mjs";
+import { DefinitionConfig, RawInputFromSchema, StartTarget, WorkflowDefinition, WorkflowHandler, WorkflowImplementation } from "./types/definition.mjs";
+import { MessageChannel, MessageChannelConfig, SendMessageChannelOptions, WaitForMessageChannelOptions, WaitForMessageOptions } from "./types/message.mjs";
 import { Schema, SchemaOutput } from "@temelj/standard-schema";
 //#region src/definition.d.ts
 /** Defines a durable workflow definition. */
-declare function defineWorkflow<TInput = unknown, TOutput = unknown, TRawInput = TInput>(config: WorkflowDefinitionConfig): WorkflowDefinition<TInput, TOutput, TRawInput>;
+export declare function defineWorkflow<TInput = unknown, TOutput = unknown, TRawInput = TInput>(config: DefinitionConfig): WorkflowDefinition<TInput, TOutput, TRawInput>;
 /** Defines a durable workflow definition. */
-declare function defineWorkflow<const TSchema extends Schema, TOutput = unknown>(config: WorkflowDefinitionConfig<TSchema>): WorkflowDefinition<SchemaOutput<TSchema>, TOutput, WorkflowRawInputFromSchema<TSchema, never>>;
+export declare function defineWorkflow<const TSchema extends Schema, TOutput = unknown>(config: DefinitionConfig<TSchema>): WorkflowDefinition<SchemaOutput<TSchema>, TOutput, RawInputFromSchema<TSchema, never>>;
 /** Creates a workflow definition from a resolved name and optional version. */
-declare function defineWorkflowFromName<TInput = unknown, TOutput = unknown, TRawInput = TInput>(name: string, version?: string): WorkflowDefinition<TInput, TOutput, TRawInput>;
+export declare function defineFromName<TInput = unknown, TOutput = unknown, TRawInput = TInput>(name: string, version?: string): WorkflowDefinition<TInput, TOutput, TRawInput>;
 /** Returns the durable definition for a workflow definition or implementation. */
-declare function defineWorkflowFromTarget<TInput, TOutput, TRawInput>(target: WorkflowStartTarget<TInput, TOutput, TRawInput>): WorkflowDefinition<TInput, TOutput, TRawInput>;
+export declare function defineFromTarget<TInput, TOutput, TRawInput>(target: StartTarget<TInput, TOutput, TRawInput>): WorkflowDefinition<TInput, TOutput, TRawInput>;
 /** Defines an executable workflow implementation from durable workflow config. */
-declare function implementWorkflow<TInput = unknown, TOutput = unknown, TRawInput = TInput>(config: WorkflowDefinitionConfig, handler: WorkflowHandler<TInput, TOutput>): WorkflowImplementation<TInput, TOutput, TRawInput>;
+export declare function implementWorkflow<TInput = unknown, TOutput = unknown, TRawInput = TInput>(config: DefinitionConfig, handler: WorkflowHandler<TInput, TOutput>): WorkflowImplementation<TInput, TOutput, TRawInput>;
 /** Defines an executable workflow implementation from durable workflow config. */
-declare function implementWorkflow<const TSchema extends Schema, TOutput = unknown>(config: WorkflowDefinitionConfig<TSchema>, handler: WorkflowHandler<SchemaOutput<TSchema>, TOutput>): WorkflowImplementation<SchemaOutput<TSchema>, TOutput, WorkflowRawInputFromSchema<TSchema, never>>;
-/** Defines workflow message channel for durable workflow use. */
-declare function defineMessageChannel<TPayload = unknown, TKey = void, const TSchema extends Schema | undefined = undefined>(config: MessageChannelConfig<TKey, TSchema>): MessageChannel<WorkflowInputFromSchema<TSchema, TPayload>, TKey>;
-/** Normalizes and parses workflow message channel send. */
-declare function resolveMessageChannelSend<TPayload, TKey>(channel: MessageChannel<TPayload, TKey>, options?: SendMessageChannelOptions<TPayload, TKey>): Promise<{
+export declare function implementWorkflow<const TSchema extends Schema, TOutput = unknown>(config: DefinitionConfig<TSchema>, handler: WorkflowHandler<SchemaOutput<TSchema>, TOutput>): WorkflowImplementation<SchemaOutput<TSchema>, TOutput, RawInputFromSchema<TSchema, never>>;
+/** Defines a message channel whose schema validates incoming payloads. */
+export declare function defineMessageChannel<TPayload, TRawPayload = unknown>(config: MessageChannelConfig<TPayload, TRawPayload>): MessageChannel<TPayload, TRawPayload>;
+interface ResolvedMessageChannelSend<TPayload> {
   readonly messageId: MessageId;
   readonly payload?: TPayload;
   readonly idempotencyKey?: string;
-}>;
-/** Normalizes and parses workflow message channel wait. */
-declare function resolveMessageChannelWait<TKey>(channel: MessageChannel<unknown, TKey>, options?: WaitForMessageChannelOptions<TKey>): {
-  commandId: string;
-  name: string;
-  messageId: string;
-  timeout?: Temporal.Duration | undefined;
-  schema?: Schema | undefined;
-};
-/** Parses raw workflow input against the definition schema when one is configured. */
-declare function parseWorkflowInput<TInput>(definition: WorkflowDefinition<TInput, unknown, unknown>, input: unknown): Promise<TInput>;
+}
+/** Validates a channel send and preserves its raw payload for the receiving schema. */
+export declare function resolveMessageChannelSend<TPayload, TRawPayload>(channel: MessageChannel<TPayload, TRawPayload>, options?: SendMessageChannelOptions<TRawPayload>): Promise<ResolvedMessageChannelSend<TRawPayload>>;
+export declare function resolveMessageChannelWait<TPayload>(channel: MessageChannel<TPayload, unknown>, options?: WaitForMessageChannelOptions): WaitForMessageOptions<Schema<unknown, TPayload>>;
 //#endregion
-export { defineMessageChannel, defineWorkflow, defineWorkflowFromName, defineWorkflowFromTarget, implementWorkflow, parseWorkflowInput, resolveMessageChannelSend, resolveMessageChannelWait };
+export {};

package/dist/definition.mjs

@@ -6,18 +6,18 @@ function defineWorkflow(config) {
 		kind: "definition",
 		config,
 		name: config.name,
-		...config.version === void 0 ? {} : { version: config.version }
+		version: config.version
 	};
 }
 /** Creates a workflow definition from a resolved name and optional version. */
-function defineWorkflowFromName(name, version) {
+function defineFromName(name, version) {
 	return defineWorkflow({
 		name,
-		...version === void 0 ? {} : { version }
+		version
 	});
 }
 /** Returns the durable definition for a workflow definition or implementation. */
-function defineWorkflowFromTarget(target) {
+function defineFromTarget(target) {
 	return target.kind === "implementation" ? target.definition : target;
 }
 /** Defines an executable workflow implementation from durable workflow config. */
@@ -26,58 +26,42 @@ function implementWorkflow(config, handler) {
 		kind: "definition",
 		config,
 		name: config.name,
-		...config.version === void 0 ? {} : { version: config.version }
+		version: config.version
 	};
 	return {
 		kind: "implementation",
 		definition,
 		config: definition.config,
 		name: definition.name,
-		...definition.version === void 0 ? {} : { version: definition.version },
+		version: definition.version,
 		handler
 	};
 }
-/** Defines workflow message channel for durable workflow use. */
+/** Defines a message channel whose schema validates incoming payloads. */
 function defineMessageChannel(config) {
-	const name = config.name;
 	return {
-		name,
-		...config.schema === void 0 ? {} : { schema: config.schema },
-		resolveMessageId: (...args) => {
-			return config.resolveMessageId?.(...args) ?? name;
-		}
+		name: config.name,
+		schema: config.schema
 	};
 }
-/** Normalizes and parses workflow message channel send. */
+/** Validates a channel send and preserves its raw payload for the receiving schema. */
 async function resolveMessageChannelSend(channel, options = {}) {
-	const payload = channel.schema === void 0 ? options.payload : await validateStandardSchema(channel.schema, options.payload, "Workflow message validation failed");
+	const payload = options.payload;
+	await validateStandardSchema(channel.schema, payload, "Workflow message validation failed");
 	return {
-		messageId: resolveMessageChannelMessageId(channel, options.key),
-		...payload === void 0 ? {} : { payload },
-		...options.idempotencyKey === void 0 ? {} : { idempotencyKey: options.idempotencyKey }
+		messageId: channel.name,
+		payload,
+		idempotencyKey: options.idempotencyKey
 	};
 }
-/** Normalizes and parses workflow message channel wait. */
 function resolveMessageChannelWait(channel, options = {}) {
 	return {
 		commandId: options.commandId ?? options.name ?? channel.name,
 		name: options.name ?? channel.name,
-		messageId: resolveMessageChannelMessageId(channel, options.key),
-		...options.timeout === void 0 ? {} : { timeout: options.timeout },
-		...channel.schema === void 0 ? {} : { schema: channel.schema }
+		messageId: channel.name,
+		timeout: options.timeout,
+		schema: channel.schema
 	};
 }
-function resolveMessageChannelMessageId(channel, key) {
-	return channel.resolveMessageId(...workflowMessageChannelKeyArgs(key));
-}
-function workflowMessageChannelKeyArgs(key) {
-	return key === void 0 ? [] : [key];
-}
-/** Parses raw workflow input against the definition schema when one is configured. */
-async function parseWorkflowInput(definition, input) {
-	const schema = definition.config.schema;
-	if (schema === void 0) return input;
-	return await validateStandardSchema(schema, input, "Workflow input validation failed");
-}
 //#endregion
-export { defineMessageChannel, defineWorkflow, defineWorkflowFromName, defineWorkflowFromTarget, implementWorkflow, parseWorkflowInput, resolveMessageChannelSend, resolveMessageChannelWait };
+export { defineFromName, defineFromTarget, defineMessageChannel, defineWorkflow, implementWorkflow, resolveMessageChannelSend, resolveMessageChannelWait };

package/dist/engine/child-workflow.d.mts

@@ -1,10 +1,6 @@
-import { WorkflowDefinition } from "../types/definition.mjs";
-import { WorkflowStepRunWorkflowOptions, WorkflowStepStartWorkflowOptions, WorkflowStepWorkflowApi } from "../types/step.mjs";
-import { WorkflowExecutionEnvironment, WorkflowRunCanceler, WorkflowRunStarter } from "../types/engine.mjs";
+import { StepWorkflowApi } from "../types/step.mjs";
+import { WorkflowEngine } from "./create.mjs";
+import { ExecutionEnvironment } from "../types/engine.mjs";
 //#region src/engine/child-workflow.d.ts
-interface WorkflowChildWorkflowEngine extends WorkflowRunStarter, WorkflowRunCanceler {}
-declare function createWorkflowStepWorkflowApi(environment: WorkflowExecutionEnvironment, engine: WorkflowChildWorkflowEngine): WorkflowStepWorkflowApi;
-declare function runChildWorkflow<TInput, TOutput, TRawInput = TInput>(environment: WorkflowExecutionEnvironment, engine: WorkflowChildWorkflowEngine, definition: WorkflowDefinition<TInput, TOutput, TRawInput>, input: TRawInput, options: WorkflowStepRunWorkflowOptions | undefined): Promise<TOutput>;
-declare function startBackgroundChildWorkflow<TInput, TOutput, TRawInput = TInput>(environment: WorkflowExecutionEnvironment, engine: WorkflowChildWorkflowEngine, definition: WorkflowDefinition<TInput, TOutput, TRawInput>, input: TRawInput, options: WorkflowStepStartWorkflowOptions | undefined): Promise<string>;
-//#endregion
-export { WorkflowChildWorkflowEngine, createWorkflowStepWorkflowApi, runChildWorkflow, startBackgroundChildWorkflow };
+export declare function createStepWorkflowApi(environment: ExecutionEnvironment, engine: WorkflowEngine): StepWorkflowApi;
+//#endregion