@temelj/workflow 0.0.0-alpha.1

package/dist/types/vite.d.mts

@@ -0,0 +1,65 @@
+//#region src/types/vite.d.ts
+/** Kind values for workflow directive. */
+type DirectiveKind = "workflow" | "step";
+/** Describes the workflow transform metadata entry contract. */
+interface TransformMetadataEntry {
+  readonly kind: DirectiveKind;
+  readonly name: string;
+  readonly generatedName: string;
+  readonly workflowName: string;
+  readonly version?: string;
+}
+/** Describes the workflow transform metadata contract. */
+interface TransformMetadata {
+  readonly file: string;
+  readonly entries: readonly TransformMetadataEntry[];
+}
+/** Describes the workflow transform manifest function contract. */
+interface TransformManifestFunction {
+  readonly kind: DirectiveKind;
+  readonly exportName: string;
+  readonly localName: string;
+  readonly generatedName: string;
+  readonly workflowName: string;
+  readonly version?: string;
+}
+/** Describes the workflow transform manifest import edge contract. */
+interface TransformManifestImportEdge {
+  readonly source: string;
+  readonly importName: string;
+  readonly localName: string;
+  readonly kind: DirectiveKind;
+  readonly workflowName: string;
+  readonly version?: string;
+}
+/** Describes the workflow transform manifest contract. */
+interface TransformManifest {
+  readonly file: string;
+  readonly functions: readonly TransformManifestFunction[];
+  readonly imports: readonly TransformManifestImportEdge[];
+}
+/** Options for workflow transform. */
+interface TransformOptions {
+  readonly root?: string;
+  readonly name?: (localName: string, file: string, kind: DirectiveKind) => string;
+  readonly version?: string | ((workflowName: string, file: string) => string | undefined);
+  readonly manifests?: readonly TransformManifest[];
+  readonly sourcemap?: boolean;
+  readonly runtimeImport?: string;
+}
+/** Result returned by workflow transform. */
+interface TransformResult {
+  readonly code: string;
+  readonly map?: unknown;
+  readonly metadata: TransformMetadata;
+  readonly manifest: TransformManifest;
+}
+/** Options for workflow build-tool plugins. */
+interface WorkflowPluginOptions extends TransformOptions {
+  readonly include?: readonly string[];
+  readonly exclude?: readonly string[];
+}
+/** Options for workflow Vite plugin. */
+type VitePluginOptions = WorkflowPluginOptions;
+//#endregion
+export { DirectiveKind, TransformManifest, TransformManifestFunction, TransformManifestImportEdge, TransformMetadata, TransformMetadataEntry, TransformOptions, TransformResult, VitePluginOptions, WorkflowPluginOptions };

package/dist/types/vite.mjs

@@ -0,0 +1 @@
+export {};

package/dist/types/worker-id.d.mts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+//#region src/types/worker-id.d.ts
+declare const workerIdSchema: z.ZodCustom<string, string>;
+/** Non-empty identifier used when a worker claims and heartbeats workflow runs. */
+type WorkerId = string;
+//#endregion
+export { WorkerId, workerIdSchema };

package/dist/types/worker-id.mjs

@@ -0,0 +1,5 @@
+import { z } from "zod";
+//#region src/types/worker-id.ts
+const workerIdSchema = z.custom().refine((value) => typeof value === "string" && value.trim().length > 0, "Expected an ID");
+//#endregion
+export { workerIdSchema };

package/dist/types/worker.d.mts

@@ -0,0 +1,94 @@
+import { RunId } from "./run-id.mjs";
+import { WorkflowMissingImplementationRetryConfig } from "./retry.mjs";
+import { RegistryLike } from "./definition.mjs";
+import { WorkerId } from "./worker-id.mjs";
+import { ExecutionResult } from "./result.mjs";
+import { WorkflowAttributeValue, WorkflowRunRecord, WorkflowRunRetryReason, WorkflowRunStatus, WorkflowRunTransitionReason } from "./run.mjs";
+import { WorkflowWorkerEngine } from "./engine.mjs";
+//#region src/types/worker.d.ts
+/** Options for creating a direct workflow worker host. */
+interface CreateWorkflowWorkerOptions {
+  readonly engine: WorkflowWorkerEngine;
+  readonly registry: RegistryLike;
+  readonly workerId?: WorkerId;
+  readonly leaseDuration?: Temporal.Duration;
+  readonly pollInterval?: Temporal.Duration;
+  readonly heartbeatInterval?: Temporal.Duration;
+  readonly stopDrainTimeout?: Temporal.Duration;
+  readonly missingImplementationRetry?: WorkflowMissingImplementationRetryConfig;
+  readonly now?: () => Temporal.Instant;
+}
+/** Describes the workflow worker contract. */
+interface WorkflowWorker {
+  /** Claims and processes a specific run by ID. */
+  processRun(runId: RunId): Promise<ExecutionResult<unknown>>;
+  /** Claims and processes the next available run matching the optional filters. */
+  processNextRun(options?: WorkflowWorkerRunFilterOptions): Promise<ExecutionResult<unknown> | undefined>;
+  /** Extends the worker lease for a claimed run. */
+  extendLease(runId: RunId, options?: WorkflowWorkerLeaseOptions): Promise<WorkflowRunRecord | undefined>;
+  /** Releases the worker lease for a claimed run. */
+  releaseLease(runId: RunId, options?: WorkflowWorkerLeaseOptions): Promise<WorkflowRunRecord | undefined>;
+  /** Runs the worker polling loop until stopped, aborted, or maxRuns is reached. */
+  run(options?: WorkflowWorkerRunOptions): Promise<WorkflowWorkerRunResult>;
+  /** Stops the worker polling loop and waits for active work to settle. */
+  stop(): Promise<void>;
+}
+/** Options for workflow worker lease. */
+interface WorkflowWorkerLeaseOptions {
+  readonly attempts?: number;
+}
+/** Run filters accepted by workers; worker identity is supplied by the worker itself. */
+interface WorkflowWorkerRunFilterOptions {
+  readonly status?: WorkflowRunStatus | readonly WorkflowRunStatus[];
+  readonly workflowName?: string;
+  readonly workflowVersion?: string;
+  readonly idempotencyKey?: string;
+  readonly parentRunId?: string;
+  readonly parentStepId?: string;
+  readonly parentStepName?: string;
+  readonly parentStepAttempt?: number;
+  readonly lastTransitionReason?: WorkflowRunTransitionReason | readonly WorkflowRunTransitionReason[];
+  readonly createdAtFrom?: Temporal.Instant;
+  readonly createdAtTo?: Temporal.Instant;
+  readonly updatedAtFrom?: Temporal.Instant;
+  readonly updatedAtTo?: Temporal.Instant;
+  readonly finishedAtFrom?: Temporal.Instant;
+  readonly finishedAtTo?: Temporal.Instant;
+  readonly startedAtFrom?: Temporal.Instant;
+  readonly startedAtTo?: Temporal.Instant;
+  readonly availableAtFrom?: Temporal.Instant;
+  readonly availableAtTo?: Temporal.Instant;
+  readonly leaseExpiresAtFrom?: Temporal.Instant;
+  readonly leaseExpiresAtTo?: Temporal.Instant;
+  readonly retryReason?: WorkflowRunRetryReason | readonly WorkflowRunRetryReason[];
+  readonly retryAtFrom?: Temporal.Instant;
+  readonly retryAtTo?: Temporal.Instant;
+  readonly cleanupFinishedAtBefore?: Temporal.Instant;
+  readonly attributes?: Readonly<Record<string, WorkflowAttributeValue>>;
+  readonly attributeExists?: string | readonly string[];
+  readonly attributeMissing?: string | readonly string[];
+  readonly limit?: number;
+}
+/** Options for workflow worker run. */
+interface WorkflowWorkerRunOptions extends WorkflowWorkerRunFilterOptions {
+  readonly signal?: AbortSignal;
+  readonly maxRuns?: number;
+  readonly concurrency?: number;
+  readonly pollInterval?: Temporal.Duration;
+  readonly tickSchedules?: boolean;
+}
+/** Result returned by workflow worker run. */
+interface WorkflowWorkerRunResult {
+  readonly processedRuns: number;
+}
+/** Options for workflow wake due runs. */
+interface WorkflowWakeDueRunsOptions extends WorkflowWorkerRunFilterOptions {
+  readonly workerId?: string;
+  readonly leaseDuration?: Temporal.Duration;
+  readonly heartbeatInterval?: Temporal.Duration;
+  readonly missingImplementationRetry?: WorkflowMissingImplementationRetryConfig;
+  readonly signal?: AbortSignal;
+  readonly maxRuns?: number;
+}
+//#endregion
+export { CreateWorkflowWorkerOptions, WorkflowWakeDueRunsOptions, WorkflowWorker, WorkflowWorkerLeaseOptions, WorkflowWorkerRunFilterOptions, WorkflowWorkerRunOptions, WorkflowWorkerRunResult };

package/dist/types/worker.mjs

@@ -0,0 +1 @@
+export {};

package/dist/utility.d.mts

@@ -0,0 +1,49 @@
+import { RunId } from "./types/run-id.mjs";
+import { WorkflowStepAttemptRecord } from "./types/step-attempts.mjs";
+import { WorkerId } from "./types/worker-id.mjs";
+import { WorkflowRunRecord, WorkflowRunStatus, WorkflowTerminalRunStatus } from "./types/run.mjs";
+import { EventRecord } from "./types/events.mjs";
+import { WorkflowRunReaderRepository } from "./types/store.mjs";
+import { WorkflowRecordedIdContext } from "./types/engine-options.mjs";
+import { StandardSchemaValidationError } from "@temelj/standard-schema";
+//#region src/utility.d.ts
+/** Converts arbitrary command ID text into a stable segment safe for recorded IDs. */
+declare function sanitizeRecordedIdPart(value: string): string;
+/** Formats standard-schema validation issues into a single human-readable message. */
+declare function formatStandardSchemaIssues(error: StandardSchemaValidationError): string;
+/** Returns the greatest positive safe integer from two optional values. */
+declare function greatestOptionalNumber(current: number | undefined, next: number | undefined): number | undefined;
+/** Returns whether a value is a positive safe integer. */
+declare function isPositiveSafeInteger(value: unknown): value is number;
+/** Returns whether a value is a non-negative safe integer. */
+declare function isNonNegativeSafeInteger(value: unknown): value is number;
+/** Returns the next positive safe integer, or undefined when the input cannot be advanced. */
+declare function nextPositiveSafeInteger(value: number): number | undefined;
+declare function isWorkflowRunStatus(status: string): status is WorkflowRunStatus;
+declare function isActiveWorkflowRunStatus(status: WorkflowRunStatus): boolean;
+declare function isScheduledWorkflowRunStatus(status: WorkflowRunStatus): boolean;
+/** Returns whether a workflow run status is terminal for its current execution attempt. */
+declare function isTerminalWorkflowRunStatus(status: WorkflowRunStatus): status is WorkflowTerminalRunStatus;
+/** Returns whether an event is the terminal lifecycle event matching a run's current status. */
+declare function isTerminalWorkflowLifecycleEventForRun(run: WorkflowRunRecord, event: EventRecord): boolean;
+/** Creates a default worker identifier using the current time and a random suffix. */
+declare function createDefaultWorkerId(): WorkerId;
+/** Returns a duration's total milliseconds, or NaN when Temporal cannot represent it safely. */
+declare function durationTotal(value: Temporal.Duration): number;
+declare function safeDuration(value: number, label: string): number;
+declare function durationAmount(value: Temporal.Duration, label: string): number;
+/** Returns a retry delay in milliseconds and reports invalid numbers as duration errors. */
+declare function resolveSafeRetryDelay(value: number | undefined, label: string): number | undefined;
+declare function nextRunAttempt(value: number | undefined): number;
+declare function limitWorkflowItems<T>(items: readonly T[], limit: number | undefined): readonly T[];
+declare function isAbortError(error: unknown): boolean;
+declare function positiveSafeInteger(value: number, label: string): number;
+declare function resolvePositiveSafeIntegerOption(value: number | undefined, label: string): number | undefined;
+declare function getRequiredRun(store: WorkflowRunReaderRepository, runId: RunId): Promise<WorkflowRunRecord>;
+declare function makeWorkflowRunStepAttemptKey(runId: RunId, attempt: WorkflowStepAttemptRecord): string;
+/** Creates the default workflow run ID factory. */
+declare function createDefaultRunIdFactory(now?: () => Temporal.Instant): () => string;
+/** Creates the default workflow recorded command ID factory. */
+declare function createDefaultWorkflowRecordedIdFactory(createRunId: () => string): (context: WorkflowRecordedIdContext) => string;
+//#endregion
+export { createDefaultRunIdFactory, createDefaultWorkerId, createDefaultWorkflowRecordedIdFactory, durationAmount, durationTotal, formatStandardSchemaIssues, getRequiredRun, greatestOptionalNumber, isAbortError, isActiveWorkflowRunStatus, isNonNegativeSafeInteger, isPositiveSafeInteger, isScheduledWorkflowRunStatus, isTerminalWorkflowLifecycleEventForRun, isTerminalWorkflowRunStatus, isWorkflowRunStatus, limitWorkflowItems, makeWorkflowRunStepAttemptKey, nextPositiveSafeInteger, nextRunAttempt, positiveSafeInteger, resolvePositiveSafeIntegerOption, resolveSafeRetryDelay, safeDuration, sanitizeRecordedIdPart };

package/dist/utility.mjs

@@ -0,0 +1,122 @@
+import { WorkflowOptionsError } from "./errors/base.mjs";
+import { WorkflowDurationError } from "./errors/failures.mjs";
+import { WorkflowRunNotFoundError } from "./errors/run.mjs";
+import { makeWorkflowStepAttemptKey } from "./history/attempt-key.mjs";
+//#region src/utility.ts
+/** Converts arbitrary command ID text into a stable segment safe for recorded IDs. */
+function sanitizeRecordedIdPart(value) {
+	const sanitized = value.replaceAll(/[^a-zA-Z0-9_-]/g, "_");
+	return sanitized === "" ? "run" : sanitized;
+}
+/** Formats standard-schema validation issues into a single human-readable message. */
+function formatStandardSchemaIssues(error) {
+	return error.issues.map((issue) => {
+		const path = issue.path?.join(".");
+		return path === void 0 || path === "" ? issue.message : `${path}: ${issue.message}`;
+	}).join("; ");
+}
+/** Returns the greatest positive safe integer from two optional values. */
+function greatestOptionalNumber(current, next) {
+	if (next === void 0 || !isPositiveSafeInteger(next)) return current;
+	if (current === void 0) return next;
+	return Math.max(current, next);
+}
+/** Returns whether a value is a positive safe integer. */
+function isPositiveSafeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+/** Returns whether a value is a non-negative safe integer. */
+function isNonNegativeSafeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+/** Returns the next positive safe integer, or undefined when the input cannot be advanced. */
+function nextPositiveSafeInteger(value) {
+	return isPositiveSafeInteger(value) && value < Number.MAX_SAFE_INTEGER ? value + 1 : void 0;
+}
+function isWorkflowRunStatus(status) {
+	return status === "pending" || status === "running" || status === "waiting" || status === "completed" || status === "failed" || status === "canceled";
+}
+function isActiveWorkflowRunStatus(status) {
+	return status === "pending" || status === "running" || status === "waiting";
+}
+function isScheduledWorkflowRunStatus(status) {
+	return status === "pending" || status === "waiting";
+}
+/** Returns whether a workflow run status is terminal for its current execution attempt. */
+function isTerminalWorkflowRunStatus(status) {
+	return status === "completed" || status === "failed" || status === "canceled";
+}
+/** Returns whether an event is the terminal lifecycle event matching a run's current status. */
+function isTerminalWorkflowLifecycleEventForRun(run, event) {
+	return run.status === "completed" && event.kind === "workflow_completed" || run.status === "failed" && event.kind === "workflow_failed";
+}
+/** Creates a default worker identifier using the current time and a random suffix. */
+function createDefaultWorkerId() {
+	return `worker_${Temporal.Now.instant().epochMilliseconds.toString(36)}_${Math.random().toString(36).slice(2)}`;
+}
+/** Returns a duration's total milliseconds, or NaN when Temporal cannot represent it safely. */
+function durationTotal(value) {
+	const total = value.total({ unit: "millisecond" });
+	return Number.isFinite(total) ? total : NaN;
+}
+function safeDuration(value, label) {
+	try {
+		resolveSafeRetryDelay(value, label);
+	} catch (error) {
+		if (!(error instanceof WorkflowOptionsError)) throw error;
+		WorkflowDurationError.timerSafe(label);
+	}
+	return value;
+}
+function durationAmount(value, label) {
+	if (!(value instanceof Temporal.Duration)) WorkflowDurationError.temporalDuration(label);
+	const amount = value.total({ unit: "millisecond" });
+	if (!Number.isFinite(amount)) WorkflowDurationError.finite(label);
+	return amount;
+}
+/** Returns a retry delay in milliseconds and reports invalid numbers as duration errors. */
+function resolveSafeRetryDelay(value, label) {
+	if (value !== void 0 && !Number.isSafeInteger(value)) WorkflowOptionsError.safeDuration(label);
+	return value;
+}
+function nextRunAttempt(value) {
+	if (value === void 0 || !isNonNegativeSafeInteger(value) || value >= Number.MAX_SAFE_INTEGER) return 1;
+	return value + 1;
+}
+function limitWorkflowItems(items, limit) {
+	if (limit === void 0) return items;
+	return items.slice(0, limit);
+}
+function isAbortError(error) {
+	return error instanceof Error && error.name === "AbortError" || error instanceof DOMException && error.name === "AbortError";
+}
+function positiveSafeInteger(value, label) {
+	if (!isPositiveSafeInteger(value)) WorkflowDurationError.positiveSafeInteger(label);
+	return value;
+}
+function resolvePositiveSafeIntegerOption(value, label) {
+	if (value === void 0) return;
+	if (!isPositiveSafeInteger(value)) WorkflowOptionsError.positiveSafeInteger(label);
+	return value;
+}
+async function getRequiredRun(store, runId) {
+	const run = await store.getRun(runId);
+	if (run === void 0) WorkflowRunNotFoundError.notFound(runId);
+	return run;
+}
+function makeWorkflowRunStepAttemptKey(runId, attempt) {
+	return `${runId}:${makeWorkflowStepAttemptKey(attempt.stepId, attempt.attempt)}`;
+}
+/** Creates the default workflow run ID factory. */
+function createDefaultRunIdFactory(now = Temporal.Now.instant) {
+	return () => `run_${now().epochMilliseconds.toString(36)}_${randomIdPart()}`;
+}
+/** Creates the default workflow recorded command ID factory. */
+function createDefaultWorkflowRecordedIdFactory(createRunId) {
+	return (context) => `wf_${sanitizeRecordedIdPart(context.runId)}_${createRunId()}`;
+}
+function randomIdPart() {
+	return Math.random().toString(36).slice(2);
+}
+//#endregion
+export { createDefaultRunIdFactory, createDefaultWorkerId, createDefaultWorkflowRecordedIdFactory, durationAmount, durationTotal, formatStandardSchemaIssues, getRequiredRun, greatestOptionalNumber, isAbortError, isActiveWorkflowRunStatus, isNonNegativeSafeInteger, isPositiveSafeInteger, isScheduledWorkflowRunStatus, isTerminalWorkflowLifecycleEventForRun, isTerminalWorkflowRunStatus, isWorkflowRunStatus, limitWorkflowItems, makeWorkflowRunStepAttemptKey, nextPositiveSafeInteger, nextRunAttempt, positiveSafeInteger, resolvePositiveSafeIntegerOption, resolveSafeRetryDelay, safeDuration, sanitizeRecordedIdPart };

package/dist/vite/ast.d.mts

@@ -0,0 +1,23 @@
+import { Node, Program } from "oxc-parser";
+//#region src/vite/ast.d.ts
+type WorkflowAstNode = Node | Program;
+interface WorkflowSourceFile {
+  readonly fileName: string;
+  readonly text: string;
+  readonly program: Program;
+}
+interface WorkflowSpan {
+  readonly start: number;
+  readonly end: number;
+}
+declare function parseWorkflowSource(fileName: string, text: string): WorkflowSourceFile;
+declare function spanText(sourceFile: WorkflowSourceFile, node: WorkflowSpan): string;
+declare function leadingTriviaStart(text: string, start: number): number;
+declare function lineAndColumnOfPosition(text: string, position: number): {
+  readonly line: number;
+  readonly column: number;
+};
+declare function visitWorkflowNode(node: WorkflowAstNode, visitor: (node: WorkflowAstNode) => void): void;
+declare function workflowNodeChildren(node: WorkflowAstNode): readonly WorkflowAstNode[];
+//#endregion
+export { WorkflowAstNode, WorkflowSourceFile, WorkflowSpan, leadingTriviaStart, lineAndColumnOfPosition, parseWorkflowSource, spanText, visitWorkflowNode, workflowNodeChildren };

package/dist/vite/ast.mjs

@@ -0,0 +1,73 @@
+import { workflowSourceKindForId } from "./source.mjs";
+import { parseSync } from "oxc-parser";
+//#region src/vite/ast.ts
+const PARSER_OPTIONS_BY_SOURCE_KIND = {
+	js: {
+		lang: "js",
+		astType: "js"
+	},
+	json: {
+		lang: "js",
+		astType: "js"
+	},
+	ts: {
+		lang: "ts",
+		astType: "ts"
+	},
+	tsx: {
+		lang: "tsx",
+		astType: "ts"
+	}
+};
+function parseWorkflowSource(fileName, text) {
+	const result = parseSync(fileName, text, {
+		...PARSER_OPTIONS_BY_SOURCE_KIND[workflowSourceKindForId(fileName)],
+		sourceType: "module"
+	});
+	if (result.errors.length > 0) throw new Error(result.errors.map((error) => error.message).join("\n"));
+	return {
+		fileName,
+		text,
+		program: result.program
+	};
+}
+function spanText(sourceFile, node) {
+	return sourceFile.text.slice(node.start, node.end);
+}
+function leadingTriviaStart(text, start) {
+	let index = start;
+	while (index > 0 && /\s/.test(text[index - 1])) index--;
+	return index;
+}
+function lineAndColumnOfPosition(text, position) {
+	const lines = text.slice(0, position).split(/\r\n|\r|\n/);
+	return {
+		line: lines.length,
+		column: lines.at(-1).length + 1
+	};
+}
+function visitWorkflowNode(node, visitor) {
+	for (const child of workflowNodeChildren(node)) {
+		visitor(child);
+		visitWorkflowNode(child, visitor);
+	}
+}
+function workflowNodeChildren(node) {
+	const children = [];
+	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);
+		}
+	}
+	return children;
+}
+function isWorkflowAstNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
+}
+//#endregion
+export { leadingTriviaStart, lineAndColumnOfPosition, parseWorkflowSource, spanText, visitWorkflowNode, workflowNodeChildren };

package/dist/vite/error.d.mts

@@ -0,0 +1,19 @@
+//#region src/vite/error.d.ts
+/** Error thrown for transform failures. */
+declare class WorkflowTransformError extends Error {
+  constructor(message: string, context?: Function);
+  static directiveParametersMustBeIdentifiers(this: void): never;
+  static metadataMissing(this: void, name: string): never;
+  static directiveFunctionMustBeNamed(this: void): never;
+  static directiveFunctionCannotBeGenerator(this: void, directive: string, name: string): never;
+  static workflowFunctionMustBeAsync(this: void, name: string): never;
+  static directivesMustBeTopLevel(this: void): never;
+  static directiveImportsMustBeNamed(this: void, specifier: string): never;
+  static directiveReExportsMustBeNamed(this: void, specifier: string): never;
+  static nondeterministicGlobal(this: void, workflowName: string, globalName: string, line: number, character: number): never;
+  static invalidSourceReplacementRange(this: void, start: number, end: number): never;
+  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 };

package/dist/vite/error.mjs

@@ -0,0 +1,47 @@
+//#region src/vite/error.ts
+/** Error thrown for transform failures. */
+var WorkflowTransformError = class WorkflowTransformError extends Error {
+	constructor(message, context) {
+		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);
+	}
+	static metadataMissing(name) {
+		throw new WorkflowTransformError(`Workflow metadata was not collected for ${name}`, WorkflowTransformError.metadataMissing);
+	}
+	static directiveFunctionMustBeNamed() {
+		throw new WorkflowTransformError("Directive function declarations must be named", WorkflowTransformError.directiveFunctionMustBeNamed);
+	}
+	static directiveFunctionCannotBeGenerator(directive, name) {
+		throw new WorkflowTransformError(`"${directive}" function ${name} cannot be a generator`, WorkflowTransformError.directiveFunctionCannotBeGenerator);
+	}
+	static workflowFunctionMustBeAsync(name) {
+		throw new WorkflowTransformError(`"use workflow" function ${name} must be async`, WorkflowTransformError.workflowFunctionMustBeAsync);
+	}
+	static directivesMustBeTopLevel() {
+		throw new WorkflowTransformError("Workflow directives are only supported on top-level functions", WorkflowTransformError.directivesMustBeTopLevel);
+	}
+	static directiveImportsMustBeNamed(specifier) {
+		throw new WorkflowTransformError(`Workflow directive imports from ${specifier} must use named imports`, WorkflowTransformError.directiveImportsMustBeNamed);
+	}
+	static directiveReExportsMustBeNamed(specifier) {
+		throw new WorkflowTransformError(`Workflow directive re-exports from ${specifier} must use named exports`, WorkflowTransformError.directiveReExportsMustBeNamed);
+	}
+	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);
+	}
+	static invalidSourceReplacementRange(start, end) {
+		throw new WorkflowTransformError(`Invalid source replacement range: ${start}..${end}`, WorkflowTransformError.invalidSourceReplacementRange);
+	}
+	static invalidSourceReadRange(start, end) {
+		throw new WorkflowTransformError(`Invalid source read range: ${start}..${end}`, WorkflowTransformError.invalidSourceReadRange);
+	}
+	static overlappingSourceReplacementRanges(currentStart, currentEnd, previousStart, previousEnd) {
+		throw new WorkflowTransformError(`Overlapping source replacement ranges: ${currentStart}..${currentEnd} and ${previousStart}..${previousEnd}`, WorkflowTransformError.overlappingSourceReplacementRanges);
+	}
+};
+//#endregion
+export { WorkflowTransformError };

package/dist/vite/generated-name.d.mts

@@ -0,0 +1,7 @@
+//#region src/vite/generated-name.d.ts
+/** Prefix reserved for helper identifiers injected by the workflow transform. */
+declare const GENERATED_PREFIX: string;
+/** Creates a reserved helper identifier for generated workflow transform code. */
+declare function makeGeneratedName(...parts: readonly string[]): string;
+//#endregion
+export { GENERATED_PREFIX, makeGeneratedName };

package/dist/vite/generated-name.mjs

@@ -0,0 +1,9 @@
+//#region src/vite/generated-name.ts
+/** Prefix reserved for helper identifiers injected by the workflow transform. */
+const GENERATED_PREFIX = "__temelj";
+/** Creates a reserved helper identifier for generated workflow transform code. */
+function makeGeneratedName(...parts) {
+	return [GENERATED_PREFIX, ...parts].join("_");
+}
+//#endregion
+export { GENERATED_PREFIX, makeGeneratedName };

package/dist/vite/manifest.d.mts

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

package/dist/vite/manifest.mjs

@@ -0,0 +1,106 @@
+import { WorkflowTransformError } from "./error.mjs";
+import path from "node:path";
+//#region src/vite/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]));
+	const importedSteps = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.body) {
+		if (statement.type !== "ImportDeclaration" || statement.importKind === "type") continue;
+		const resolved = resolveManifestImport(file, statement.source.value, manifestBySource);
+		if (resolved === void 0) continue;
+		if (hasNonNamedImportSpecifier(statement)) WorkflowTransformError.directiveImportsMustBeNamed(statement.source.value);
+		const exportedSteps = new Map(resolved.manifest.functions.filter((entry) => entry.kind === "step").map((entry) => [entry.exportName, entry]));
+		for (const element of statement.specifiers) {
+			if (element.type !== "ImportSpecifier" || element.importKind === "type") continue;
+			const importName = moduleExportNameText(element.imported);
+			const step = exportedSteps.get(importName);
+			if (step === void 0) continue;
+			importedSteps.set(element.local.name, {
+				source: resolved.source,
+				importName,
+				localName: element.local.name,
+				kind: "step",
+				workflowName: step.workflowName,
+				...step.version === void 0 ? {} : { version: step.version }
+			});
+		}
+	}
+	return importedSteps;
+}
+function collectReExportedManifestFunctions(sourceFile, file, manifests) {
+	const manifestBySource = new Map(manifests.map((manifest) => [manifest.file, manifest]));
+	const functions = [];
+	for (const statement of sourceFile.body) {
+		if (!isSupportedReExportDeclaration(statement) || statement.exportKind === "type") continue;
+		if (statement.type === "ExportAllDeclaration" && statement.exported !== null) WorkflowTransformError.directiveReExportsMustBeNamed(statement.source.value);
+		const resolved = resolveManifestImport(file, statement.source.value, manifestBySource);
+		if (resolved === void 0) continue;
+		if (statement.type === "ExportAllDeclaration") {
+			functions.push(...resolved.manifest.functions);
+			continue;
+		}
+		const exported = new Map(resolved.manifest.functions.map((entry) => [entry.exportName, entry]));
+		for (const element of statement.specifiers) {
+			if (element.exportKind === "type") continue;
+			const importName = moduleExportNameText(element.local);
+			const entry = exported.get(importName);
+			if (entry === void 0) continue;
+			functions.push({
+				kind: entry.kind,
+				exportName: moduleExportNameText(element.exported),
+				localName: entry.localName,
+				generatedName: entry.generatedName,
+				workflowName: entry.workflowName,
+				...entry.version === void 0 ? {} : { version: entry.version }
+			});
+		}
+	}
+	return functions;
+}
+function hasNonNamedImportSpecifier(statement) {
+	return statement.specifiers.some((specifier) => specifier.type !== "ImportSpecifier");
+}
+function isSupportedReExportDeclaration(statement) {
+	return statement.type === "ExportAllDeclaration" || statement.type === "ExportNamedDeclaration" && statement.source !== null;
+}
+function moduleExportNameText(name) {
+	return name.type === "Literal" ? String(name.value) : name.name;
+}
+function resolveManifestImport(file, specifier, manifestBySource) {
+	const source = resolveManifestImportSource(file, specifier);
+	const manifest = manifestBySource.get(source);
+	if (manifest !== void 0) return {
+		source,
+		manifest
+	};
+	for (const alias of sourceAliases(source)) {
+		const aliasManifest = manifestBySource.get(alias);
+		if (aliasManifest !== void 0) return {
+			source: alias,
+			manifest: aliasManifest
+		};
+	}
+}
+function resolveManifestImportSource(file, specifier) {
+	if (!specifier.startsWith(".")) return specifier;
+	const directory = path.posix.dirname(file);
+	const resolved = path.posix.normalize(path.posix.join(directory, specifier));
+	if (JS_TS_EXTENSION_PATTERN.test(resolved)) return resolved;
+	return `${resolved}.ts`;
+}
+function sourceAliases(source) {
+	const extension = path.posix.extname(source);
+	const aliases = ESM_SOURCE_EXTENSION_BY_IMPORT_EXTENSION.get(extension);
+	if (aliases === void 0) return [];
+	const withoutExtension = source.slice(0, -extension.length);
+	return aliases.map((alias) => `${withoutExtension}${alias}`);
+}
+const ESM_SOURCE_EXTENSION_BY_IMPORT_EXTENSION = /* @__PURE__ */ new Map([
+	[".js", [".ts", ".tsx"]],
+	[".jsx", [".tsx"]],
+	[".mjs", [".mts"]],
+	[".cjs", [".cts"]]
+]);
+//#endregion
+export { collectImportedStepBindings, collectReExportedManifestFunctions };