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

package/dist/pagination.d.mts

@@ -1,25 +1,19 @@
-import { StepId } from "./types/step-id.mjs";
+import { StepId } from "./types/ids.mjs";
 import { CursorKeyPart, PageOptions, WorkflowPage } from "./types/pagination.mjs";
-import "./types/step.mjs";
 //#region src/pagination.d.ts
-declare function pageItems<TItem>(items: readonly TItem[], options: PageOptions | undefined, label: string, cursorKey: (item: TItem, index: number) => readonly CursorKeyPart[]): WorkflowPage<TItem>;
-declare function makeWorkflowRunCursorKey(run: {
+export declare function pageItems<TItem>(items: readonly TItem[], options: PageOptions | undefined, label: string, cursorKey: (item: TItem, index: number) => readonly CursorKeyPart[]): WorkflowPage<TItem>;
+export declare function makeRunCursorKey(run: {
   readonly createdAt: Temporal.Instant;
   readonly id: string;
 }): readonly [number, string];
-declare function makeWorkflowEventCursorKey(_event: unknown, index: number): readonly [number];
-declare function makeWorkflowStepAttemptCursorKey(attempt: {
+export declare function makeStepAttemptCursorKey(attempt: {
   readonly startedAt: Temporal.Instant;
   readonly stepId: StepId;
   readonly attempt: number;
 }): readonly [number, StepId, number];
-declare function makeScheduleCursorKey(schedule: {
+export declare function makeScheduleCursorKey(schedule: {
   readonly nextFireAt: Temporal.Instant;
   readonly createdAt: Temporal.Instant;
   readonly id: string;
 }): readonly [number, number, string];
-declare function makeStreamChunkCursorKey(chunk: {
-  readonly index: number;
-}): readonly [number];
-//#endregion
-export { makeScheduleCursorKey, makeStreamChunkCursorKey, makeWorkflowEventCursorKey, makeWorkflowRunCursorKey, makeWorkflowStepAttemptCursorKey, pageItems };
+//#endregion

package/dist/pagination.mjs

@@ -1,6 +1,8 @@
 import { WorkflowOptionsError } from "./errors/base.mjs";
 import "./errors/mod.mjs";
-import { workflowCursorPayloadSchema } from "./types/pagination.mjs";
+import { cursorPayloadSchema } from "./schema/pagination.mjs";
+import { ss } from "@temelj/standard-schema";
+import { isNumber } from "@temelj/value";
 import { decodeBase64UrlString, encodeBase64UrlString } from "@temelj/string";
 //#region src/pagination.ts
 const CURSOR_PREFIX = "wf-page:";
@@ -17,17 +19,14 @@ function pageItems(items, options, label, cursorKey) {
 	const last = pageItems.at(-1);
 	return {
 		items: pageItems,
-		...hasMore && last !== void 0 ? { nextCursor: encodeCursor({ key: [...cursorKey(last, nextOffset - 1)] }) } : {},
+		nextCursor: hasMore && last !== void 0 ? encodeCursor({ key: [...cursorKey(last, nextOffset - 1)] }) : void 0,
 		hasMore
 	};
 }
-function makeWorkflowRunCursorKey(run) {
+function makeRunCursorKey(run) {
 	return [run.createdAt.epochMilliseconds, run.id];
 }
-function makeWorkflowEventCursorKey(_event, index) {
-	return [index];
-}
-function makeWorkflowStepAttemptCursorKey(attempt) {
+function makeStepAttemptCursorKey(attempt) {
 	return [
 		attempt.startedAt.epochMilliseconds,
 		attempt.stepId,
@@ -41,9 +40,6 @@ function makeScheduleCursorKey(schedule) {
 		schedule.id
 	];
 }
-function makeStreamChunkCursorKey(chunk) {
-	return [chunk.index];
-}
 function encodeCursor(payload) {
 	return `${CURSOR_PREFIX}${encodeBase64UrlString(JSON.stringify(payload))}`;
 }
@@ -51,9 +47,9 @@ function decodeCursor(value, label) {
 	if (value === void 0) return;
 	if (!value.startsWith(CURSOR_PREFIX)) WorkflowOptionsError.cursorInvalid(label);
 	try {
-		const parsed = workflowCursorPayloadSchema.safeParse(JSON.parse(decodeBase64UrlString(value.slice(8))));
+		const parsed = ss.safeParseSync(cursorPayloadSchema, JSON.parse(decodeBase64UrlString(value.slice(8))));
 		if (!parsed.success) WorkflowOptionsError.cursorInvalid(label);
-		return parsed.data.key;
+		return parsed.value.key;
 	} catch (error) {
 		if (!(error instanceof WorkflowOptionsError)) WorkflowOptionsError.cursorInvalid(label);
 		throw error;
@@ -64,10 +60,10 @@ function compareCursorKeys(left, right) {
 	for (let index = 0; index < length; index++) {
 		const leftPart = left[index];
 		const rightPart = right[index];
-		const compared = leftPart === rightPart ? 0 : leftPart === void 0 ? -1 : rightPart === void 0 ? 1 : typeof leftPart === "number" && Number.isFinite(leftPart) && typeof rightPart === "number" && Number.isFinite(rightPart) ? leftPart - rightPart : String(leftPart).localeCompare(String(rightPart));
+		const compared = leftPart === rightPart ? 0 : leftPart === void 0 ? -1 : rightPart === void 0 ? 1 : isNumber(leftPart) && Number.isFinite(leftPart) && isNumber(rightPart) && Number.isFinite(rightPart) ? leftPart - rightPart : String(leftPart).localeCompare(String(rightPart));
 		if (compared !== 0) return compared;
 	}
 	return 0;
 }
 //#endregion
-export { makeScheduleCursorKey, makeStreamChunkCursorKey, makeWorkflowEventCursorKey, makeWorkflowRunCursorKey, makeWorkflowStepAttemptCursorKey, pageItems };
+export { makeRunCursorKey, makeScheduleCursorKey, makeStepAttemptCursorKey, pageItems };

package/dist/registry.d.mts

@@ -1,11 +1,15 @@
 import { Registry as Registry$1, WorkflowDefinition, WorkflowHandler, WorkflowImplementation } from "./types/definition.mjs";
+import "temporal-polyfill/global";
 //#region src/registry.d.ts
-/** In-memory workflow registry implementation. */
-declare class Registry implements Registry$1 {
+/** A compiled function or implementation accepted by a heterogeneous registry. */
+export type RegistryEntry = Function | (Omit<WorkflowImplementation, "handler"> & {
+  readonly handler: Function;
+});
+export declare class Registry implements Registry$1 {
   private readonly implementations;
+  constructor(entries?: readonly RegistryEntry[]);
   /** Defines and registers a workflow implementation. */
   readonly implementWorkflow: <TInput, TOutput, TRawInput = TInput>(definition: WorkflowDefinition<TInput, TOutput, TRawInput>, handler: WorkflowHandler<TInput, TOutput>) => WorkflowImplementation<TInput, TOutput, TRawInput>;
-  /** Registers a workflow implementation. */
   readonly register: <TInput, TOutput, TRawInput = TInput>(implementation: WorkflowImplementation<TInput, TOutput, TRawInput>) => void;
   /** Returns the workflow implementation registered for a definition. */
   readonly get: <TInput, TOutput, TRawInput = TInput>(definition: WorkflowDefinition<TInput, TOutput, TRawInput>) => WorkflowImplementation<TInput, TOutput, TRawInput> | undefined;
@@ -16,5 +20,4 @@ declare class Registry implements Registry$1 {
   /** Returns all registered workflow implementations in registration order. */
   readonly entries: () => readonly WorkflowImplementation<unknown, unknown>[];
 }
-//#endregion
-export { Registry };
+//#endregion

package/dist/registry.mjs

@@ -1,9 +1,18 @@
 import { WorkflowDefinitionError } from "./errors/definition.mjs";
 import "./errors/mod.mjs";
+import { getCompiledDefinition } from "./compiled-function.mjs";
+import "temporal-polyfill/global";
+import { isFunction } from "@temelj/value";
 //#region src/registry.ts
-/** In-memory workflow registry implementation. */
 var Registry = class {
 	implementations = /* @__PURE__ */ new Map();
+	constructor(entries = []) {
+		for (const entry of entries) if (isFunction(entry)) {
+			const implementation = getCompiledDefinition(entry);
+			if (implementation === void 0) WorkflowDefinitionError.compiledMetadataMissing();
+			this.register(implementation);
+		} else this.register(entry);
+	}
 	/** Defines and registers a workflow implementation. */
 	implementWorkflow = (definition, handler) => {
 		const implementation = {
@@ -11,24 +20,25 @@ var Registry = class {
 			definition,
 			config: definition.config,
 			name: definition.name,
-			...definition.version === void 0 ? {} : { version: definition.version },
+			version: definition.version,
 			handler
 		};
 		this.register(implementation);
 		return implementation;
 	};
-	/** Registers a workflow implementation. */
 	register = (implementation) => {
-		const key = makeWorkflowImplementationKey(implementation.name, implementation.version);
-		if (this.implementations.has(key)) WorkflowDefinitionError.implementationAlreadyRegistered(key);
+		const key = makeImplementationKey(implementation.name, implementation.version);
+		if (this.implementations.has(key)) throw new WorkflowDefinitionError(`Workflow implementation already registered: ${implementation.version === void 0 ? implementation.name : `${implementation.name}@${implementation.version}`}`);
 		this.implementations.set(key, implementation);
 	};
 	/** Returns the workflow implementation registered for a definition. */
 	get = (definition) => {
-		return this.implementations.get(makeWorkflowImplementationKey(definition.name, definition.version));
+		const implementation = this.implementations.get(makeImplementationKey(definition.name, definition.version));
+		if (implementation?.definition !== definition) return;
+		return implementation;
 	};
 	/** Returns the workflow implementation registered for a name and optional version. */
-	getByName = (name, version) => this.implementations.get(makeWorkflowImplementationKey(name, version));
+	getByName = (name, version) => this.implementations.get(makeImplementationKey(name, version));
 	/** Returns the last registered workflow implementation for a name. */
 	latest = (name) => {
 		const implementations = this.entries();
@@ -40,9 +50,8 @@ var Registry = class {
 	/** Returns all registered workflow implementations in registration order. */
 	entries = () => [...this.implementations.values()];
 };
-/** Builds the internal registry key for a workflow implementation. */
-function makeWorkflowImplementationKey(name, version) {
-	return version === void 0 ? name : `${name}@${version}`;
+function makeImplementationKey(name, version) {
+	return JSON.stringify([name, version ?? null]);
 }
 //#endregion
 export { Registry };

package/dist/rolldown.d.mts

@@ -1,7 +1,9 @@
-import { WorkflowPluginOptions } from "./types/vite.mjs";
-import { workflowPlugin } from "./vite/plugin.mjs";
+import { PluginOptions } from "./types/compiler.mjs";
+import { workflowPlugin } from "./compiler/plugin.mjs";
+import "./esbuild.mjs";
+import "temporal-polyfill/global";
 //#region src/rolldown.d.ts
 /** Creates the Rolldown plugin that compiles workflow and step directives. */
-declare const workflow: (options?: WorkflowPluginOptions | undefined) => import("rolldown").Plugin<any>;
+export declare const workflow: (options?: PluginOptions | undefined) => import("rolldown").Plugin<any>;
 //#endregion
-export { type WorkflowPluginOptions, workflow, workflowPlugin };
+export { type PluginOptions, workflowPlugin };

package/dist/rolldown.mjs

@@ -1,4 +1,5 @@
-import { workflowPlugin } from "./vite/plugin.mjs";
+import { workflowPlugin } from "./compiler/plugin.mjs";
+import "temporal-polyfill/global";
 //#region src/rolldown.ts
 /** Creates the Rolldown plugin that compiles workflow and step directives. */
 const workflow = workflowPlugin.rolldown;

package/dist/rollup.d.mts

@@ -1,7 +1,9 @@
-import { WorkflowPluginOptions } from "./types/vite.mjs";
-import { workflowPlugin } from "./vite/plugin.mjs";
+import { PluginOptions } from "./types/compiler.mjs";
+import { workflowPlugin } from "./compiler/plugin.mjs";
+import "./esbuild.mjs";
+import "temporal-polyfill/global";
 //#region src/rollup.d.ts
 /** Creates the Rollup plugin that compiles workflow and step directives. */
-declare const workflow: (options?: WorkflowPluginOptions | undefined) => import("rollup").Plugin<any>;
+export declare const workflow: (options?: PluginOptions | undefined) => import("rollup").Plugin<any>;
 //#endregion
-export { type WorkflowPluginOptions, workflow, workflowPlugin };
+export { type PluginOptions, workflowPlugin };

package/dist/rollup.mjs

@@ -1,4 +1,5 @@
-import { workflowPlugin } from "./vite/plugin.mjs";
+import { workflowPlugin } from "./compiler/plugin.mjs";
+import "temporal-polyfill/global";
 //#region src/rollup.ts
 /** Creates the Rollup plugin that compiles workflow and step directives. */
 const workflow = workflowPlugin.rollup;

package/dist/rspack.d.mts

@@ -1,7 +1,9 @@
-import { WorkflowPluginOptions } from "./types/vite.mjs";
-import { workflowPlugin } from "./vite/plugin.mjs";
+import { PluginOptions } from "./types/compiler.mjs";
+import { workflowPlugin } from "./compiler/plugin.mjs";
+import "./esbuild.mjs";
+import "temporal-polyfill/global";
 //#region src/rspack.d.ts
 /** Creates the Rspack plugin that compiles workflow and step directives. */
-declare const workflow: (options?: WorkflowPluginOptions | undefined) => import("unplugin").RspackPluginInstance;
+export declare const workflow: (options?: PluginOptions | undefined) => import("unplugin").RspackPluginInstance;
 //#endregion
-export { type WorkflowPluginOptions, workflow, workflowPlugin };
+export { type PluginOptions, workflowPlugin };

package/dist/rspack.mjs

@@ -1,4 +1,5 @@
-import { workflowPlugin } from "./vite/plugin.mjs";
+import { workflowPlugin } from "./compiler/plugin.mjs";
+import "temporal-polyfill/global";
 //#region src/rspack.ts
 /** Creates the Rspack plugin that compiles workflow and step directives. */
 const workflow = workflowPlugin.rspack;

package/dist/run-status.d.mts

@@ -0,0 +1,29 @@
+import { RunRecord, RunStatus, TerminalRunStatus } from "./types/run.mjs";
+import { EventRecord } from "./types/events.mjs";
+//#region src/run-status.d.ts
+export declare function isRunStatus(status: string): status is RunStatus;
+export declare function isActiveRunStatus(status: RunStatus): boolean;
+export declare function isScheduledRunStatus(status: RunStatus): boolean;
+/** Returns whether a workflow run status is terminal for its current execution attempt. */
+export declare function isTerminalRunStatus(status: RunStatus): status is TerminalRunStatus;
+/** Returns whether an event is the terminal lifecycle event matching a run's current status. */
+export declare function isTerminalEventForRun(run: RunRecord, event: EventRecord): boolean;
+export declare function nextRunAttempt(value: number | undefined): number;
+/** Run fields cleared together when a run no longer waits on a retry, a lease, or a result. */
+export declare const CLEARED_RETRY: {
+  readonly retryAt: undefined;
+  readonly retryReason: undefined;
+  readonly retryAttempt: undefined;
+  readonly retryStepId: undefined;
+  readonly retryStepName: undefined;
+};
+export declare const CLEARED_LEASE: {
+  readonly workerId: undefined;
+  readonly leaseExpiresAt: undefined;
+};
+export declare const UNFINISHED: {
+  readonly error: undefined;
+  readonly output: undefined;
+  readonly finishedAt: undefined;
+};
+//#endregion

package/dist/run-status.mjs

@@ -0,0 +1,42 @@
+import { isNonNegativeSafeInteger } from "./values.mjs";
+//#region src/run-status.ts
+function isRunStatus(status) {
+	return status === "pending" || status === "running" || status === "waiting" || status === "completed" || status === "failed" || status === "canceled";
+}
+function isActiveRunStatus(status) {
+	return status === "pending" || status === "running" || status === "waiting";
+}
+function isScheduledRunStatus(status) {
+	return status === "pending" || status === "waiting";
+}
+/** Returns whether a workflow run status is terminal for its current execution attempt. */
+function isTerminalRunStatus(status) {
+	return status === "completed" || status === "failed" || status === "canceled";
+}
+/** Returns whether an event is the terminal lifecycle event matching a run's current status. */
+function isTerminalEventForRun(run, event) {
+	return run.status === "completed" && event.kind === "workflow_completed" || run.status === "failed" && event.kind === "workflow_failed";
+}
+function nextRunAttempt(value) {
+	if (value === void 0 || !isNonNegativeSafeInteger(value) || value >= Number.MAX_SAFE_INTEGER) return 1;
+	return value + 1;
+}
+/** Run fields cleared together when a run no longer waits on a retry, a lease, or a result. */
+const CLEARED_RETRY = {
+	retryAt: void 0,
+	retryReason: void 0,
+	retryAttempt: void 0,
+	retryStepId: void 0,
+	retryStepName: void 0
+};
+const CLEARED_LEASE = {
+	workerId: void 0,
+	leaseExpiresAt: void 0
+};
+const UNFINISHED = {
+	error: void 0,
+	output: void 0,
+	finishedAt: void 0
+};
+//#endregion
+export { CLEARED_LEASE, CLEARED_RETRY, UNFINISHED, isActiveRunStatus, isRunStatus, isScheduledRunStatus, isTerminalEventForRun, isTerminalRunStatus, nextRunAttempt };

package/dist/schema/common.d.mts

@@ -0,0 +1,22 @@
+import { Schema, SchemaInput, SchemaOutput } from "@temelj/standard-schema";
+import "temporal-polyfill/global";
+//#region src/schema/common.d.ts
+export declare const temporalInstantSchema: Schema<unknown, Temporal.Instant>;
+export declare const temporalDurationSchema: Schema<unknown, Temporal.Duration>;
+export declare const temporalNonNegativeDurationSchema: Schema<unknown, Temporal.Duration>;
+export declare const nonBlankStringSchema: Schema<unknown, string>;
+export declare const nonBlankStringListSchema: Schema<unknown, string[]>;
+export declare const positiveSafeIntegerSchema: Schema<unknown, number>;
+export declare const nonNegativeSafeIntegerSchema: Schema<unknown, number>;
+export declare const idSchema: Schema<unknown, string>;
+export declare const telemetryContextSchema: Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+  traceparent: Schema<unknown, string | undefined>;
+  tracestate: Schema<unknown, string | undefined>;
+}>>;
+/** A record whose keys must also match `keySchema`. */
+export declare function keyedRecord<TValue extends Schema>(keySchema: Schema<unknown, string>, valueSchema: TValue): Schema<unknown, Record<string, SchemaOutput<TValue>>>;
+/** Picks the schema for a value by its `key` field, so errors come from that schema. */
+export declare function discriminated<const TSchemas extends Record<string, Schema>>(key: string, schemas: TSchemas, message: string): Schema<unknown, SchemaOutput<TSchemas[keyof TSchemas]>>;
+/** Parses a value, throwing an error whose message names every issue. */
+export declare function parse<TSchema extends Schema>(schema: TSchema, value: SchemaInput<TSchema>): SchemaOutput<TSchema>;
+//#endregion

package/dist/schema/common.mjs

@@ -0,0 +1,54 @@
+import { durationTotal } from "../temporal.mjs";
+import { StandardSchemaValidationError, ss } from "@temelj/standard-schema";
+import "temporal-polyfill/global";
+import { isObject, isPlainObject, isString } from "@temelj/value";
+//#region src/schema/common.ts
+const temporalInstantSchema = ss.instanceOf(Temporal.Instant, "Expected a Temporal.Instant");
+const temporalDurationSchema = ss.instanceOf(Temporal.Duration, "Expected a Temporal.Duration");
+const temporalNonNegativeDurationSchema = ss.refine(temporalDurationSchema, (value) => durationTotal(value) >= 0, "Expected a non-negative duration");
+const nonBlankStringSchema = ss.refine(ss.string(), (value) => value.trim().length > 0, "Expected a non-blank string");
+const nonBlankStringListSchema = ss.array(nonBlankStringSchema);
+const positiveSafeIntegerSchema = ss.positiveSafeInteger();
+const nonNegativeSafeIntegerSchema = ss.nonNegativeSafeInteger();
+const idSchema = ss.refine(ss.string("Expected an ID"), (value) => value.trim().length > 0, "Expected an ID");
+const telemetryContextSchema = ss.object({
+	traceparent: ss.optional(nonBlankStringSchema),
+	tracestate: ss.optional(nonBlankStringSchema)
+});
+/** A record whose keys must also match `keySchema`. */
+function keyedRecord(keySchema, valueSchema) {
+	const recordSchema = ss.record(valueSchema);
+	return ss.schema((value) => {
+		const record = ss.safeParseSync(recordSchema, value);
+		if (!record.success) return { issues: record.issues };
+		for (const key of Object.keys(record.value)) {
+			const result = ss.safeParseSync(keySchema, key);
+			if (!result.success) return ss.failure(result.issues[0]?.message ?? "Invalid key", [key]);
+		}
+		return ss.success(record.value);
+	});
+}
+/** Picks the schema for a value by its `key` field, so errors come from that schema. */
+function discriminated(key, schemas, message) {
+	return ss.schema((value) => {
+		const tag = isPlainObject(value) ? new Map(Object.entries(value)).get(key) : void 0;
+		const schema = isString(tag) && Object.hasOwn(schemas, tag) ? schemas[tag] : void 0;
+		if (schema === void 0) return ss.failure(message, [key]);
+		const result = ss.safeParseSync(schema, value);
+		return result.success ? ss.success(result.value) : { issues: result.issues };
+	});
+}
+/** Parses a value, throwing an error whose message names every issue. */
+function parse(schema, value) {
+	const result = ss.safeParseSync(schema, value);
+	if (result.success) return result.value;
+	StandardSchemaValidationError.failed(issuesMessage(result.issues), result.issues);
+}
+function issuesMessage(issues) {
+	return issues.map((issue) => {
+		const path = issue.path?.map((segment) => isObject(segment) ? String(segment.key) : String(segment)).join(".");
+		return path === void 0 || path === "" ? issue.message : `${path}: ${issue.message}`;
+	}).join("; ");
+}
+//#endregion
+export { discriminated, idSchema, keyedRecord, nonBlankStringListSchema, nonBlankStringSchema, nonNegativeSafeIntegerSchema, parse, positiveSafeIntegerSchema, telemetryContextSchema, temporalDurationSchema, temporalInstantSchema, temporalNonNegativeDurationSchema };

package/dist/schema/error.d.mts

@@ -0,0 +1,17 @@
+import { WorkflowErrorCode } from "../errors/codes.mjs";
+import { RunStatus, TerminalRunStatus } from "../types/run.mjs";
+import { Schema } from "@temelj/standard-schema";
+//#region src/schema/error.d.ts
+export declare const errorCodeSchema: Schema<unknown, WorkflowErrorCode>;
+export declare const errorDetailsSchema: Schema<unknown, Record<string, string | number | boolean | null | undefined>>;
+export declare const errorRecordSchema: Schema<unknown, import("@temelj/standard-schema").ObjectOutput<{
+  code: Schema<unknown, WorkflowErrorCode | undefined>;
+  name: Schema<unknown, string>;
+  message: Schema<unknown, string>;
+  stack: Schema<unknown, string | undefined>;
+  details: Schema<unknown, Record<string, string | number | boolean | null | undefined> | undefined>;
+}>>;
+export declare const optionalErrorStringSchema: Schema<unknown, string | undefined>;
+export declare const errorRunStatusSchema: Schema<unknown, RunStatus>;
+export declare const terminalErrorRunStatusSchema: Schema<unknown, TerminalRunStatus>;
+//#endregion

package/dist/schema/error.mjs

@@ -0,0 +1,39 @@
+import { nonBlankStringSchema } from "./common.mjs";
+import { WorkflowErrorCode } from "../errors/codes.mjs";
+import { ss } from "@temelj/standard-schema";
+import { isPlainObject } from "@temelj/value";
+//#region src/schema/error.ts
+const errorCodeSchema = ss.picklist(Object.values(WorkflowErrorCode));
+const runStatuses = [
+	"pending",
+	"running",
+	"waiting",
+	"completed",
+	"failed",
+	"canceled"
+];
+const terminalRunStatuses = [
+	"completed",
+	"failed",
+	"canceled"
+];
+const errorDetailSchema = ss.union([
+	ss.string(),
+	ss.number(),
+	ss.boolean(),
+	ss.literal(null),
+	ss.literal(void 0)
+]);
+const errorDetailsSchema = ss.refine(ss.pipe(ss.schema((value) => isPlainObject(value) ? ss.success(value) : ss.failure("Expected an object")), ss.record(errorDetailSchema)), (details) => Object.keys(details).every((key) => key.trim().length > 0), "Expected non-blank detail keys");
+const errorRecordSchema = ss.object({
+	code: ss.optional(errorCodeSchema),
+	name: nonBlankStringSchema,
+	message: nonBlankStringSchema,
+	stack: ss.optional(nonBlankStringSchema),
+	details: ss.optional(errorDetailsSchema)
+});
+const optionalErrorStringSchema = ss.optional(nonBlankStringSchema);
+const errorRunStatusSchema = ss.picklist(runStatuses, "Expected a workflow run status");
+const terminalErrorRunStatusSchema = ss.picklist(terminalRunStatuses, "Expected a terminal workflow run status");
+//#endregion
+export { errorCodeSchema, errorDetailsSchema, errorRecordSchema, errorRunStatusSchema, optionalErrorStringSchema, terminalErrorRunStatusSchema };