@temelj/workflow 0.0.0-alpha.1

package/dist/vite/transform.mjs

@@ -0,0 +1,405 @@
+import { stripQuery } from "./source.mjs";
+import { leadingTriviaStart, parseWorkflowSource, spanText, visitWorkflowNode, 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 path from "node:path";
+//#region src/vite/transform.ts
+const JS_TS_EXTENSION_PATTERN = /\.[cm]?[jt]sx?$/;
+const GENERATED_CONTEXT_NAME = makeGeneratedName("context");
+const GENERATED_DEFINE_WORKFLOW_NAME = makeGeneratedName("implementWorkflow");
+const GENERATED_DEFINE_WORKFLOW_STEP_NAME = makeGeneratedName("defineWorkflowStep");
+const GENERATED_ATTACH_WORKFLOW_DEFINITION_NAME = makeGeneratedName("attachWorkflowDefinition");
+const GENERATED_ATTACH_WORKFLOW_STEP_DEFINITION_NAME = makeGeneratedName("attachWorkflowStepDefinition");
+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);
+	const directiveFunctions = collectDirectiveFunctions(sourceFile.program);
+	const file = relativeFile(id, options.root);
+	const reExportedFunctions = collectReExportedManifestFunctions(sourceFile.program, file, options.manifests ?? []);
+	if (directiveFunctions.length === 0 && reExportedFunctions.length === 0) return;
+	const editor = new SourceEditor(code);
+	for (const entry of directiveFunctions) editor.remove(leadingTriviaStart(code, entry.directive.start), entry.directive.end);
+	const entries = directiveFunctions.map((entry) => createMetadataEntry(entry, file, options));
+	const localFunctions = directiveFunctions.map((entry, index) => createManifestFunction(entry, entries[index]));
+	const workflowByName = new Map(directiveFunctions.filter((entry) => entry.kind === "workflow").map((entry) => [entry.name, entry]));
+	const localStepNames = new Set(directiveFunctions.filter((entry) => entry.kind === "step").map((entry) => entry.name));
+	const importedSteps = collectImportedStepBindings(sourceFile.program, file, options.manifests ?? []);
+	const knownStepNames = /* @__PURE__ */ new Set([...localStepNames, ...importedSteps.keys()]);
+	const importText = directiveFunctions.length === 0 ? "" : createRuntimeImportText(options.runtimeImport);
+	const definitionText = entries.map((entry, index) => createDefinitionText(directiveFunctions[index], entry, sourceFile)).join("\n\n");
+	const transformedCode = editor.toString();
+	const sourceText = directiveFunctions.length === 0 ? transformedCode.trim() : transformedCode.trimEnd();
+	const transformedResultCode = `${[
+		importText,
+		sourceText,
+		definitionText
+	].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
+		},
+		manifest: {
+			file,
+			functions: [...localFunctions, ...reExportedFunctions],
+			imports: [...importedSteps.values()]
+		}
+	};
+	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}`;
+			}));
+			return [
+				`const ${metadata.generatedName} = ${GENERATED_DEFINE_WORKFLOW_STEP_NAME}(${config}, async (${[...entry.parameters.map((parameter) => spanText(currentSourceFile, parameter)), contextName].join(", ")}) => {`,
+				bodyWithoutDirective(entry.body, currentSourceFile),
+				"});",
+				`${GENERATED_ATTACH_WORKFLOW_STEP_DEFINITION_NAME}(${entry.name}, ${metadata.generatedName});`
+			].join("\n");
+		}
+		const workflow = workflowByName.get(entry.name);
+		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),
+			"});",
+			`${GENERATED_ATTACH_WORKFLOW_DEFINITION_NAME}(${entry.name}, ${metadata.generatedName});`
+		].join("\n");
+	}
+}
+function hasWorkflowTransformCandidateText(code) {
+	return code.includes("\"use workflow\"") || code.includes("'use workflow'") || code.includes("\"use step\"") || code.includes("'use step'") || code.includes(" from ");
+}
+function collectDirectiveFunctions(sourceFile) {
+	const entries = [];
+	for (const statement of sourceFile.body) for (const entry of directiveFunctionsFromStatement(statement)) entries.push(entry);
+	rejectNestedDirectiveFunctions(sourceFile, new Set(entries.map((entry) => entry.body)));
+	return entries;
+}
+function directiveFunctionsFromStatement(statement) {
+	const declaration = statement.type === "ExportNamedDeclaration" && statement.declaration !== null ? statement.declaration : statement;
+	if (isFunctionDeclaration(declaration)) {
+		const entry = directiveFunctionFromDeclaration(declaration);
+		return entry === void 0 ? [] : [entry];
+	}
+	if (declaration.type !== "VariableDeclaration") return [];
+	return declaration.declarations.flatMap((variableDeclaration) => {
+		const entry = directiveFunctionFromVariableDeclaration(variableDeclaration);
+		return entry === void 0 ? [] : [entry];
+	});
+}
+function directiveFunctionFromDeclaration(node) {
+	if (node.body === null) return;
+	const directive = directiveFromBody(node.body);
+	if (directive === void 0) return;
+	if (node.id === null) WorkflowTransformError.directiveFunctionMustBeNamed();
+	rejectUnsupportedDirectiveFunction(node, directive.kind, node.id.name);
+	return {
+		kind: directive.kind,
+		name: node.id.name,
+		node,
+		body: node.body,
+		parameters: node.params,
+		directive: directive.statement
+	};
+}
+function directiveFunctionFromVariableDeclaration(node) {
+	if (node.id.type !== "Identifier" || node.init === null) return;
+	const initializer = node.init;
+	if (!isArrowOrFunctionExpression(initializer)) return;
+	if (initializer.body === null || initializer.body.type !== "BlockStatement") return;
+	const directive = directiveFromBody(initializer.body);
+	if (directive === void 0) return;
+	rejectUnsupportedDirectiveFunction(initializer, directive.kind, node.id.name);
+	return {
+		kind: directive.kind,
+		name: node.id.name,
+		node,
+		body: initializer.body,
+		parameters: initializer.params,
+		directive: directive.statement
+	};
+}
+function directiveFromBody(body) {
+	const firstStatement = body.body[0];
+	if (firstStatement === void 0 || firstStatement.type !== "ExpressionStatement") return;
+	if (firstStatement.expression.type !== "Literal") return;
+	if (firstStatement.expression.value === "use workflow") return {
+		kind: "workflow",
+		statement: firstStatement
+	};
+	if (firstStatement.expression.value === "use step") return {
+		kind: "step",
+		statement: firstStatement
+	};
+}
+function rejectUnsupportedDirectiveFunction(node, kind, name) {
+	if (node.generator) WorkflowTransformError.directiveFunctionCannotBeGenerator(directiveText(kind), name);
+	if (kind === "workflow" && !node.async) WorkflowTransformError.workflowFunctionMustBeAsync(name);
+}
+function rejectNestedDirectiveFunctions(sourceFile, topLevelBodies) {
+	visitWorkflowNode(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;
+	return {
+		kind: entry.kind,
+		name: entry.name,
+		generatedName: makeGeneratedName(entry.kind, sanitizeIdentifier(entry.name)),
+		workflowName,
+		...version === void 0 ? {} : { version }
+	};
+}
+function createManifestFunction(entry, metadata) {
+	return {
+		kind: entry.kind,
+		exportName: entry.name,
+		localName: entry.name,
+		generatedName: metadata.generatedName,
+		workflowName: metadata.workflowName,
+		...metadata.version === void 0 ? {} : { version: metadata.version }
+	};
+}
+function createDefinitionConfig(metadata) {
+	const fields = [`name: ${JSON.stringify(metadata.workflowName)}`];
+	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) => {
+		const name = parameterName(parameter);
+		if (name === void 0) WorkflowTransformError.directiveParametersMustBeIdentifiers();
+		return name || `arg${index}`;
+	});
+	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))}`;
+}
+function bodyWithoutDirective(body, sourceFile) {
+	const statements = body.body.slice(1);
+	if (statements.length === 0) return "";
+	const start = leadingTriviaStart(sourceFile.text, statements[0].start);
+	const end = statements.at(-1).end;
+	return new SourceEditor(sourceFile.text).read(start, end);
+}
+function rewriteWorkflowCalls(bodyText, sourceFile, knownStepNames, initialLocalNames) {
+	const wrapped = `async function ${makeGeneratedName("workflow", "body")}() {${bodyText}}`;
+	const bodySource = parseWorkflowSource(sourceFile.fileName, wrapped);
+	const editor = new SourceEditor(bodyText);
+	const offset = wrapped.indexOf(bodyText);
+	const wrapper = bodySource.program.body[0];
+	if (!isFunctionDeclaration(wrapper) || wrapper.body === null) return bodyText;
+	const visit = (node, localNames) => {
+		if (isCallExpression(node) && isIdentifier(node.callee) && knownStepNames.has(node.callee.name) && !localNames.has(node.callee.name)) {
+			const args = node.arguments.map((argument) => spanText(bodySource, argument)).join(", ");
+			editor.replace(node.start - offset, node.end - offset, `${GENERATED_CALL_WORKFLOW_STEP_FUNCTION_NAME}(${GENERATED_CONTEXT_NAME}.step, ${node.callee.name}${args === "" ? "" : `, ${args}`})`);
+			return;
+		}
+		if (isBlockStatement(node)) {
+			visitBlock(node, localNames);
+			return;
+		}
+		if (isFunctionLike(node)) {
+			visitFunctionLike(node, localNames);
+			return;
+		}
+		if (node.type === "ForStatement") {
+			visitForStatement(node, localNames);
+			return;
+		}
+		if (node.type === "ForInStatement" || node.type === "ForOfStatement") {
+			visitForInOrOfStatement(node, localNames);
+			return;
+		}
+		if (node.type === "CatchClause") {
+			visitCatchClause(node, localNames);
+			return;
+		}
+		if (node.type === "SwitchStatement") {
+			visitSwitchStatement(node, localNames);
+			return;
+		}
+		for (const child of workflowNodeChildren(node)) visit(child, localNames);
+	};
+	const visitBlock = (block, inheritedLocalNames) => {
+		const localNames = collectBlockLocalNames(block, inheritedLocalNames);
+		for (const statement of block.body) visit(statement, localNames);
+	};
+	const visitFunctionLike = (node, inheritedLocalNames) => {
+		const localNames = new Set(inheritedLocalNames);
+		if (node.type !== "ArrowFunctionExpression" && node.id !== null) localNames.add(node.id.name);
+		for (const parameter of node.params) collectParameterNames(parameter, localNames);
+		const body = node.body;
+		if (body !== null) visit(body, localNames);
+	};
+	const visitForStatement = (node, inheritedLocalNames) => {
+		const localNames = new Set(inheritedLocalNames);
+		if (node.init !== null) {
+			collectForInitializerNames(node.init, localNames);
+			visit(node.init, inheritedLocalNames);
+		}
+		if (node.test !== null) visit(node.test, localNames);
+		if (node.update !== null) visit(node.update, localNames);
+		visit(node.body, localNames);
+	};
+	const visitForInOrOfStatement = (node, inheritedLocalNames) => {
+		const localNames = new Set(inheritedLocalNames);
+		collectForInitializerNames(node.left, localNames);
+		visit(node.right, inheritedLocalNames);
+		visit(node.body, localNames);
+	};
+	const visitCatchClause = (node, inheritedLocalNames) => {
+		const localNames = new Set(inheritedLocalNames);
+		if (node.param !== null) collectBindingNames(node.param, localNames);
+		visit(node.body, localNames);
+	};
+	const visitSwitchStatement = (node, inheritedLocalNames) => {
+		visit(node.discriminant, inheritedLocalNames);
+		const localNames = collectSwitchCaseBlockLocalNames(node, inheritedLocalNames);
+		for (const clause of node.cases) {
+			if (clause.test !== null) visit(clause.test, localNames);
+			for (const statement of clause.consequent) visit(statement, localNames);
+		}
+	};
+	visitBlock(wrapper.body, initialLocalNames);
+	return editor.toString();
+}
+function collectBlockLocalNames(block, inheritedLocalNames) {
+	const localNames = new Set(inheritedLocalNames);
+	for (const statement of block.body) collectStatementLocalNames(statement, localNames);
+	return localNames;
+}
+function collectSwitchCaseBlockLocalNames(switchStatement, inheritedLocalNames) {
+	const localNames = new Set(inheritedLocalNames);
+	for (const clause of switchStatement.cases) for (const statement of clause.consequent) collectStatementLocalNames(statement, localNames);
+	return localNames;
+}
+function collectStatementLocalNames(statement, localNames) {
+	if (statement.type === "VariableDeclaration") {
+		for (const declaration of statement.declarations) collectBindingNames(declaration.id, localNames);
+		return;
+	}
+	if (isFunctionDeclaration(statement) && statement.id !== null) {
+		localNames.add(statement.id.name);
+		return;
+	}
+	if (isClassDeclaration(statement) && statement.id !== null) localNames.add(statement.id.name);
+}
+function collectForInitializerNames(initializer, localNames) {
+	if (initializer.type === "VariableDeclaration") for (const declaration of initializer.declarations) collectBindingNames(declaration.id, localNames);
+}
+function collectParameterNames(parameter, localNames) {
+	if (parameter.type === "TSParameterProperty") {
+		collectParameterNames(parameter.parameter, localNames);
+		return;
+	}
+	if (parameter.type === "RestElement") {
+		collectBindingNames(parameter.argument, localNames);
+		return;
+	}
+	collectBindingNames(parameter, localNames);
+}
+function collectBindingNames(name, localNames) {
+	if (name.type === "Identifier") {
+		localNames.add(name.name);
+		return;
+	}
+	if (name.type === "RestElement") {
+		collectBindingNames(name.argument, localNames);
+		return;
+	}
+	if (name.type === "AssignmentPattern") {
+		collectBindingNames(name.left, localNames);
+		return;
+	}
+	if (name.type === "ObjectPattern") {
+		for (const property of name.properties) {
+			if (property.type === "RestElement") {
+				collectBindingNames(property.argument, localNames);
+				continue;
+			}
+			collectBindingNames(property.value, localNames);
+		}
+		return;
+	}
+	for (const element of name.elements) if (element !== null) collectBindingNames(element, 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";
+}
+function isClassDeclaration(node) {
+	return node.type === "ClassDeclaration";
+}
+function isFunctionLike(node) {
+	return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+function isArrowOrFunctionExpression(node) {
+	return node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+function isBlockStatement(node) {
+	return node.type === "BlockStatement";
+}
+function isCallExpression(node) {
+	return node.type === "CallExpression";
+}
+function uniqueName(base, usedNames) {
+	let name = base;
+	let index = 1;
+	const used = new Set(usedNames);
+	while (used.has(name)) {
+		name = `${base}_${index}`;
+		index++;
+	}
+	return name;
+}
+function createRuntimeImportText(specifier = "@temelj/workflow") {
+	return [
+		"import {",
+		`  implementWorkflow as ${GENERATED_DEFINE_WORKFLOW_NAME},`,
+		`  defineWorkflowStep as ${GENERATED_DEFINE_WORKFLOW_STEP_NAME},`,
+		`  attachWorkflowDefinition as ${GENERATED_ATTACH_WORKFLOW_DEFINITION_NAME},`,
+		`  attachWorkflowStepDefinition as ${GENERATED_ATTACH_WORKFLOW_STEP_DEFINITION_NAME},`,
+		`  callWorkflowStepFunction as ${GENERATED_CALL_WORKFLOW_STEP_FUNCTION_NAME},`,
+		`} from ${JSON.stringify(specifier)};`
+	].join("\n");
+}
+function relativeFile(id, root = process.cwd()) {
+	const cleanId = stripQuery(id);
+	const relative = path.relative(root, cleanId).replaceAll(path.sep, "/");
+	return relative.startsWith("..") ? path.basename(cleanId) : relative;
+}
+function sanitizeIdentifier(value) {
+	const sanitized = value.replaceAll(/\W/g, "_");
+	return /^\d/.test(sanitized) ? `_${sanitized}` : sanitized;
+}
+function directiveText(kind) {
+	return kind === "workflow" ? "use workflow" : "use step";
+}
+//#endregion
+export { WorkflowTransformError, transformWorkflowSource };

package/dist/vite.d.mts

@@ -0,0 +1,6 @@
+import { DirectiveKind, TransformManifest, TransformManifestFunction, TransformManifestImportEdge, TransformMetadata, TransformMetadataEntry, TransformOptions, TransformResult, VitePluginOptions, WorkflowPluginOptions } from "./types/vite.mjs";
+import { workflow, workflowPlugin } from "./vite/plugin.mjs";
+import { GENERATED_PREFIX, makeGeneratedName } from "./vite/generated-name.mjs";
+import { WorkflowTransformError } from "./vite/error.mjs";
+import { transformWorkflowSource } from "./vite/transform.mjs";
+export { type DirectiveKind, GENERATED_PREFIX, type TransformManifest, type TransformManifestFunction, type TransformManifestImportEdge, type TransformMetadata, type TransformMetadataEntry, type TransformOptions, type TransformResult, type VitePluginOptions, type WorkflowPluginOptions, WorkflowTransformError, makeGeneratedName, transformWorkflowSource, workflow, workflowPlugin };

package/dist/vite.mjs

@@ -0,0 +1,5 @@
+import { WorkflowTransformError } from "./vite/error.mjs";
+import { GENERATED_PREFIX, makeGeneratedName } from "./vite/generated-name.mjs";
+import { transformWorkflowSource } from "./vite/transform.mjs";
+import { workflow, workflowPlugin } from "./vite/plugin.mjs";
+export { GENERATED_PREFIX, WorkflowTransformError, makeGeneratedName, transformWorkflowSource, workflow, workflowPlugin };

package/dist/webhook.d.mts

@@ -0,0 +1,16 @@
+import { ParsedWorkflowWebhookToken, ResumeWebhookOptions } from "./types/hook.mjs";
+//#region src/webhook.d.ts
+/** Minimal grouped hook facade required by the webhook resume helper. */
+interface WebhookResumer {
+  /** Grouped external resume hook operations. */
+  readonly hooks: {
+    /** Completes a pending webhook-labeled external resume hook. */
+    resumeWebhook(token: string, options?: ResumeWebhookOptions): Promise<void>;
+  };
+}
+/** Parses a workflow webhook resume token without resuming the hook. */
+declare function parseWebhookToken(token: string): ParsedWorkflowWebhookToken;
+/** Resumes a workflow webhook through a compatible webhook resumer. */
+declare function resumeWebhook(resumer: WebhookResumer, token: string, options?: ResumeWebhookOptions): Promise<void>;
+//#endregion
+export { WebhookResumer, parseWebhookToken, resumeWebhook };

package/dist/webhook.mjs

@@ -0,0 +1,17 @@
+import { parseWebhookToken as parseWebhookToken$1 } from "./types/hook.mjs";
+//#region src/webhook.ts
+/** Parses a workflow webhook resume token without resuming the hook. */
+function parseWebhookToken(token) {
+	const webhook = parseWebhookToken$1(token);
+	return {
+		runId: webhook.runId,
+		name: webhook.name,
+		messageId: webhook.messageId
+	};
+}
+/** Resumes a workflow webhook through a compatible webhook resumer. */
+async function resumeWebhook(resumer, token, options = {}) {
+	await resumer.hooks.resumeWebhook(token, options);
+}
+//#endregion
+export { parseWebhookToken, resumeWebhook };

package/dist/webpack.d.mts

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

package/dist/webpack.mjs

@@ -0,0 +1,6 @@
+import { workflowPlugin } from "./vite/plugin.mjs";
+//#region src/webpack.ts
+/** Creates the webpack plugin that compiles workflow and step directives. */
+const workflow = workflowPlugin.webpack;
+//#endregion
+export { workflow, workflowPlugin };

package/dist/worker/error.d.mts

@@ -0,0 +1,11 @@
+import { WorkflowResolvedMissingImplementationRetryConfig } from "../types/retry.mjs";
+import { WorkflowRunRecord } from "../types/run.mjs";
+import { WorkflowErrorRecord } from "../types/error.mjs";
+//#region src/worker/error.d.ts
+declare const DEFAULT_MISSING_IMPLEMENTATION_RETRY_INTERVAL: Temporal.Duration;
+declare function makeMissingImplementationNotFoundErrorRecord(run: WorkflowRunRecord): WorkflowErrorRecord;
+declare function makeMissingImplementationDeadlineErrorRecord(run: WorkflowRunRecord, deadlineAt: Temporal.Instant): WorkflowErrorRecord;
+declare function missingImplementationRetryDelay(retry: WorkflowResolvedMissingImplementationRetryConfig, retryAttempt: number): Temporal.Duration;
+declare function toWorkflowWorkerErrorRecord(error: unknown): WorkflowErrorRecord;
+//#endregion
+export { DEFAULT_MISSING_IMPLEMENTATION_RETRY_INTERVAL, makeMissingImplementationDeadlineErrorRecord, makeMissingImplementationNotFoundErrorRecord, missingImplementationRetryDelay, toWorkflowWorkerErrorRecord };

package/dist/worker/error.mjs

@@ -0,0 +1,40 @@
+import { WorkflowOptionsError } from "../errors/base.mjs";
+import { WorkflowRunDeadlineExceededError } from "../errors/run.mjs";
+import { durationTotal, isPositiveSafeInteger, safeDuration } from "../utility.mjs";
+import { WorkflowImplementationNotFoundError } from "../errors/implementation.mjs";
+//#region src/worker/error.ts
+const DEFAULT_MISSING_IMPLEMENTATION_RETRY_INTERVAL = Temporal.Duration.from({ seconds: 30 });
+function makeMissingImplementationNotFoundErrorRecord(run) {
+	return toWorkflowWorkerErrorRecord(WorkflowImplementationNotFoundError.create(run.workflowName, run.workflowVersion));
+}
+function makeMissingImplementationDeadlineErrorRecord(run, deadlineAt) {
+	return toWorkflowWorkerErrorRecord(WorkflowRunDeadlineExceededError.create(run.id, deadlineAt));
+}
+function missingImplementationRetryDelay(retry, retryAttempt) {
+	if (!isPositiveSafeInteger(retryAttempt)) WorkflowOptionsError.missingImplementationRetryAttemptPositiveSafeInteger();
+	const exponentialDelay = durationTotal(retry.initialInterval) * retry.backoffCoefficient ** Math.max(0, retryAttempt - 1);
+	const delay = retry.maximumInterval === void 0 ? exponentialDelay : Math.min(exponentialDelay, durationTotal(retry.maximumInterval));
+	safeDuration(delay, "Workflow missing implementation retry delay");
+	return Temporal.Duration.from({ milliseconds: delay });
+}
+function toWorkflowWorkerErrorRecord(error) {
+	if (!(error instanceof Error)) return {
+		name: "WorkflowNonErrorThrow",
+		message: String(error)
+	};
+	return {
+		name: error.name,
+		message: error.message,
+		...error.stack === void 0 ? {} : { stack: error.stack },
+		...error instanceof WorkflowRunDeadlineExceededError ? { details: {
+			runId: error.runId,
+			deadlineAt: error.deadlineAt.toString()
+		} } : {},
+		...error instanceof WorkflowImplementationNotFoundError ? { details: {
+			workflowName: error.workflowName,
+			...error.workflowVersion === void 0 ? {} : { workflowVersion: error.workflowVersion }
+		} } : {}
+	};
+}
+//#endregion
+export { DEFAULT_MISSING_IMPLEMENTATION_RETRY_INTERVAL, makeMissingImplementationDeadlineErrorRecord, makeMissingImplementationNotFoundErrorRecord, missingImplementationRetryDelay, toWorkflowWorkerErrorRecord };

package/dist/worker.d.mts

@@ -0,0 +1,18 @@
+import { RunId } from "./types/run-id.mjs";
+import { ExecutionResult } from "./types/result.mjs";
+import { WorkflowRunRecord } from "./types/run.mjs";
+import { CreateWorkflowWorkerOptions, WorkflowWorker as WorkflowWorker$1, WorkflowWorkerLeaseOptions, WorkflowWorkerRunFilterOptions, WorkflowWorkerRunOptions, WorkflowWorkerRunResult } from "./types/worker.mjs";
+//#region src/worker.d.ts
+/** Storage-backed workflow worker implementation. */
+declare class WorkflowWorker implements WorkflowWorker$1 {
+  #private;
+  constructor(options: CreateWorkflowWorkerOptions);
+  processRun(runId: RunId): Promise<ExecutionResult<unknown>>;
+  processNextRun(options?: WorkflowWorkerRunFilterOptions): Promise<ExecutionResult<unknown> | undefined>;
+  extendLease(runId: RunId, options?: WorkflowWorkerLeaseOptions): Promise<WorkflowRunRecord | undefined>;
+  releaseLease(runId: RunId, options?: WorkflowWorkerLeaseOptions): Promise<WorkflowRunRecord | undefined>;
+  run(options?: WorkflowWorkerRunOptions): Promise<WorkflowWorkerRunResult>;
+  stop(): Promise<void>;
+}
+//#endregion
+export { WorkflowWorker };