@sapiom/orchestration 0.1.0

package/dist/cjs/manifest.d.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod/v4';
+export declare const MANIFEST_PROTOCOL: 1;
+export type ManifestTransition = {
+    readonly kind: 'continue';
+    readonly target: string;
+} | {
+    readonly kind: 'terminate';
+} | {
+    readonly kind: 'fail';
+} | {
+    readonly kind: 'pause';
+    readonly signal: string;
+    readonly resumeStep: string;
+};
+export interface WorkflowStepManifest {
+    readonly timeoutMs: number | null;
+    readonly inputSchema: Record<string, unknown> | null;
+    readonly transitions: readonly ManifestTransition[];
+}
+export interface WorkflowManifest {
+    readonly protocol: typeof MANIFEST_PROTOCOL;
+    readonly name: string;
+    readonly entry: string;
+    readonly sdkVersion: string;
+    readonly artifact: {
+        readonly sha256: string;
+        readonly entryFile: string;
+    };
+    readonly steps: Readonly<Record<string, WorkflowStepManifest>>;
+}
+export declare const workflowManifestSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<1>;
+    name: z.ZodString;
+    entry: z.ZodString;
+    sdkVersion: z.ZodString;
+    artifact: z.ZodObject<{
+        sha256: z.ZodString;
+        entryFile: z.ZodString;
+    }, z.core.$strip>;
+    steps: z.ZodRecord<z.ZodString, z.ZodObject<{
+        timeoutMs: z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>;
+        inputSchema: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodNull]>;
+        transitions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"continue">;
+            target: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"terminate">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"fail">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"pause">;
+            signal: z.ZodString;
+            resumeStep: z.ZodString;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/dist/cjs/manifest.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowManifestSchema = exports.MANIFEST_PROTOCOL = void 0;
+const v4_1 = require("zod/v4");
+exports.MANIFEST_PROTOCOL = 1;
+const manifestTransitionSchema = v4_1.z.discriminatedUnion('kind', [
+    v4_1.z.object({ kind: v4_1.z.literal('continue'), target: v4_1.z.string().min(1) }),
+    v4_1.z.object({ kind: v4_1.z.literal('terminate') }),
+    v4_1.z.object({ kind: v4_1.z.literal('fail') }),
+    v4_1.z.object({ kind: v4_1.z.literal('pause'), signal: v4_1.z.string().min(1), resumeStep: v4_1.z.string().min(1) }),
+]);
+const workflowStepManifestSchema = v4_1.z.object({
+    timeoutMs: v4_1.z.union([v4_1.z.number().int().positive(), v4_1.z.null()]),
+    inputSchema: v4_1.z.union([v4_1.z.record(v4_1.z.string(), v4_1.z.unknown()), v4_1.z.null()]),
+    transitions: v4_1.z.array(manifestTransitionSchema),
+});
+exports.workflowManifestSchema = v4_1.z.object({
+    protocol: v4_1.z.literal(exports.MANIFEST_PROTOCOL),
+    name: v4_1.z.string().min(1),
+    entry: v4_1.z.string().min(1),
+    sdkVersion: v4_1.z.string().min(1),
+    artifact: v4_1.z.object({
+        sha256: v4_1.z.string().min(1),
+        entryFile: v4_1.z.string().min(1),
+    }),
+    steps: v4_1.z.record(v4_1.z.string(), workflowStepManifestSchema),
+});

package/dist/cjs/step.d.ts

@@ -0,0 +1,42 @@
+import type { ZodType } from 'zod/v4';
+import type { OrchestrationExecutionContext } from './context.js';
+import type { Fail, Goto, NextStepDirective, Pause, Retry, Terminate } from './directives.js';
+export interface Step<TIn = unknown, TOut = unknown, TShared extends Record<string, unknown> = Record<string, unknown>> {
+    readonly name: string;
+    readonly inputSchema?: ZodType<TIn>;
+    readonly timeoutMs?: number;
+    run(input: TIn, ctx: OrchestrationExecutionContext<TShared>): Promise<StepResult<TOut>>;
+}
+export interface StepResult<TOut = unknown> {
+    readonly output: TOut;
+    readonly next: NextStepDirective;
+}
+export type Allowed<Next extends readonly string[], Term extends boolean, CanFail extends boolean, PauseTo extends string> = Goto<Next[number]> | (Term extends true ? Terminate : never) | (CanFail extends true ? Fail : never) | ([PauseTo] extends [never] ? never : Pause<PauseTo>) | Retry;
+export interface StepDefinition<TShared extends Record<string, unknown> = Record<string, unknown>> {
+    readonly name: string;
+    readonly next: readonly string[];
+    readonly terminal: boolean;
+    readonly canFail: boolean;
+    readonly pause?: {
+        readonly signal: string;
+        readonly resumeStep: string;
+    };
+    readonly inputSchema?: ZodType<unknown>;
+    readonly timeoutMs?: number;
+    run(input: unknown, ctx: OrchestrationExecutionContext<TShared>): Promise<NextStepDirective>;
+}
+export declare function defineStep<TIn = unknown, TShared extends Record<string, unknown> = Record<string, unknown>, const Next extends readonly string[] = readonly [], const Term extends boolean = false, const CanFail extends boolean = false, const PauseDecl extends {
+    signal: string;
+    resumeStep: string;
+} | undefined = undefined>(def: {
+    name: string;
+    next?: Next;
+    terminal?: Term;
+    canFail?: CanFail;
+    pause?: PauseDecl;
+    inputSchema?: ZodType<TIn>;
+    timeoutMs?: number;
+    run: (input: TIn, ctx: OrchestrationExecutionContext<TShared>) => Promise<Allowed<Next, Term, CanFail, PauseDecl extends {
+        resumeStep: infer R extends string;
+    } ? R : never>>;
+}): StepDefinition<TShared>;

package/dist/cjs/step.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineStep = defineStep;
+function defineStep(def) {
+    return {
+        name: def.name,
+        next: def.next ?? [],
+        terminal: def.terminal ?? false,
+        canFail: def.canFail ?? false,
+        ...(def.pause ? { pause: def.pause } : {}),
+        ...(def.inputSchema ? { inputSchema: def.inputSchema } : {}),
+        ...(def.timeoutMs !== undefined ? { timeoutMs: def.timeoutMs } : {}),
+        run: def.run,
+    };
+}

package/dist/cjs/workflow.d.ts

@@ -0,0 +1,10 @@
+import type { StepDefinition } from './step.js';
+export declare const ORCHESTRATION_DEFINITION_BRAND: unique symbol;
+export interface OrchestrationDefinition<TInput = unknown, TShared extends Record<string, unknown> = Record<string, unknown>> {
+    readonly name: string;
+    readonly entry: string;
+    readonly steps: Readonly<Record<string, StepDefinition<TShared>>>;
+    readonly __inputType?: TInput;
+}
+export declare function isOrchestrationDefinition(val: unknown): val is OrchestrationDefinition;
+export declare function defineOrchestration<TInput = unknown, TShared extends Record<string, unknown> = Record<string, unknown>>(def: OrchestrationDefinition<TInput, TShared>): OrchestrationDefinition<TInput, TShared>;

package/dist/cjs/workflow.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORCHESTRATION_DEFINITION_BRAND = void 0;
+exports.isOrchestrationDefinition = isOrchestrationDefinition;
+exports.defineOrchestration = defineOrchestration;
+const errors_js_1 = require("./errors.js");
+exports.ORCHESTRATION_DEFINITION_BRAND = Symbol.for('sapiom.orchestration.definition');
+function isOrchestrationDefinition(val) {
+    if (val === null || typeof val !== 'object')
+        return false;
+    return val[exports.ORCHESTRATION_DEFINITION_BRAND] === 1;
+}
+function defineOrchestration(def) {
+    if (!def.name) {
+        throw new Error('Workflow definition must have a non-empty name');
+    }
+    if (!def.entry) {
+        throw new Error(`Workflow '${def.name}' must declare an entry step`);
+    }
+    if (!def.steps[def.entry]) {
+        throw new errors_js_1.UnknownStepError(def.entry);
+    }
+    for (const [key, step] of Object.entries(def.steps)) {
+        if (!step) {
+            throw new Error(`Workflow '${def.name}' has null/undefined step at key '${key}'`);
+        }
+        if (step.name !== key) {
+            throw new Error(`Workflow '${def.name}' step name mismatch at key '${key}': step.name='${step.name}'`);
+        }
+    }
+    Object.defineProperty(def, exports.ORCHESTRATION_DEFINITION_BRAND, {
+        value: 1,
+        enumerable: false,
+        writable: false,
+        configurable: false,
+    });
+    return def;
+}

package/dist/esm/build-manifest.d.ts

@@ -0,0 +1,15 @@
+import { type WorkflowManifest } from './manifest.js';
+import type { OrchestrationDefinition } from './workflow.js';
+export declare function buildManifest(def: OrchestrationDefinition, opts: {
+    sdkVersion: string;
+    artifact: {
+        sha256: string;
+        entryFile: string;
+    };
+}): WorkflowManifest;
+export interface GraphValidation {
+    readonly errors: string[];
+    readonly warnings: string[];
+}
+export declare function validateGraph(manifest: WorkflowManifest): GraphValidation;
+export declare function assertValidGraph(manifest: WorkflowManifest): string[];

package/dist/esm/build-manifest.js

@@ -0,0 +1,141 @@
+import { zodToJsonSchema } from './introspection.js';
+import { MANIFEST_PROTOCOL } from './manifest.js';
+export function buildManifest(def, opts) {
+    const steps = {};
+    for (const [stepName, step] of Object.entries(def.steps)) {
+        let inputSchema = null;
+        if (step.inputSchema) {
+            const raw = zodToJsonSchema(step.inputSchema);
+            inputSchema = dropDefaultedFromRequired(raw);
+        }
+        steps[stepName] = {
+            timeoutMs: step.timeoutMs ?? null,
+            inputSchema,
+            transitions: transitionsFor(step),
+        };
+    }
+    return {
+        protocol: MANIFEST_PROTOCOL,
+        name: def.name,
+        entry: def.entry,
+        sdkVersion: opts.sdkVersion,
+        artifact: opts.artifact,
+        steps,
+    };
+}
+function transitionsFor(step) {
+    const transitions = [];
+    for (const target of step.next ?? []) {
+        transitions.push({ kind: 'continue', target });
+    }
+    if (step.pause) {
+        transitions.push({ kind: 'pause', signal: step.pause.signal, resumeStep: step.pause.resumeStep });
+    }
+    if (step.terminal)
+        transitions.push({ kind: 'terminate' });
+    if (step.canFail)
+        transitions.push({ kind: 'fail' });
+    return transitions;
+}
+export function validateGraph(manifest) {
+    const errors = [];
+    const names = new Set(Object.keys(manifest.steps));
+    if (!names.has(manifest.entry)) {
+        errors.push(`entry step '${manifest.entry}' is not in the steps map`);
+    }
+    const forward = buildForwardEdges(manifest, names, errors);
+    const warnings = [];
+    if (names.has(manifest.entry)) {
+        const reachable = bfs([manifest.entry], forward);
+        for (const name of names) {
+            if (!reachable.has(name))
+                warnings.push(`step '${name}' is unreachable from entry '${manifest.entry}'`);
+        }
+    }
+    warnings.push(...terminalReachabilityWarnings(manifest, names, forward));
+    return { errors, warnings };
+}
+export function assertValidGraph(manifest) {
+    const { errors, warnings } = validateGraph(manifest);
+    if (errors.length > 0) {
+        throw new Error(`Invalid workflow graph for '${manifest.name}':\n  - ${errors.join('\n  - ')}`);
+    }
+    return warnings;
+}
+function buildForwardEdges(manifest, names, errors) {
+    const forward = new Map();
+    for (const [name, step] of Object.entries(manifest.steps)) {
+        const targets = new Set();
+        for (const t of step.transitions) {
+            if (t.kind === 'continue') {
+                if (names.has(t.target))
+                    targets.add(t.target);
+                else
+                    errors.push(`step '${name}' has a continue target '${t.target}' that is not in the steps map`);
+            }
+            else if (t.kind === 'pause' && names.has(t.resumeStep)) {
+                targets.add(t.resumeStep);
+            }
+        }
+        if (step.transitions.length === 0) {
+            errors.push(`step '${name}' is a dead-end: it declares no transitions (next/terminal/canFail/pause)`);
+        }
+        forward.set(name, targets);
+    }
+    return forward;
+}
+function terminalReachabilityWarnings(manifest, names, forward) {
+    const sinks = Object.entries(manifest.steps)
+        .filter(([, s]) => s.transitions.some((t) => t.kind === 'terminate' || t.kind === 'fail'))
+        .map(([name]) => name);
+    if (sinks.length === 0) {
+        return ['no step can terminate or fail — the workflow has no terminal state'];
+    }
+    const reverse = new Map();
+    for (const name of names)
+        reverse.set(name, new Set());
+    for (const [name, targets] of forward) {
+        for (const t of targets)
+            reverse.get(t)?.add(name);
+    }
+    const canReach = bfs(sinks, reverse);
+    const warnings = [];
+    for (const name of names) {
+        if (!canReach.has(name)) {
+            warnings.push(`step '${name}' cannot reach any terminate/fail (possible unbounded loop or missing terminal)`);
+        }
+    }
+    return warnings;
+}
+function bfs(starts, edges) {
+    const seen = new Set();
+    const queue = [...starts];
+    while (queue.length > 0) {
+        const cur = queue.shift();
+        if (seen.has(cur))
+            continue;
+        seen.add(cur);
+        for (const next of edges.get(cur) ?? [])
+            if (!seen.has(next))
+                queue.push(next);
+    }
+    return seen;
+}
+function dropDefaultedFromRequired(schema) {
+    const required = schema.required;
+    const properties = schema.properties;
+    if (!Array.isArray(required) || !properties || typeof properties !== 'object') {
+        return schema;
+    }
+    const props = properties;
+    const filtered = required.filter((key) => {
+        if (typeof key !== 'string')
+            return true;
+        const prop = props[key];
+        return !(prop && typeof prop === 'object' && 'default' in prop);
+    });
+    if (filtered.length === required.length) {
+        return schema;
+    }
+    return { ...schema, required: filtered };
+}

package/dist/esm/context.d.ts

@@ -0,0 +1,45 @@
+import type { NextStepDirective } from './directives.js';
+export interface StepLogger {
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+    debug(message: string, meta?: Record<string, unknown>): void;
+}
+export type FinishedStepStatus = 'dispatched' | 'succeeded' | 'failed';
+export interface OrchestrationExecutionContext<TShared extends Record<string, unknown> = Record<string, unknown>> {
+    readonly executionId: string;
+    readonly workflowName: string;
+    readonly organizationId: string | null;
+    readonly tenantId: string | null;
+    readonly input: unknown;
+    readonly shared: TypedContextStore<TShared>;
+    readonly history: readonly StepExecutionRecord[];
+    readonly attempts: number;
+    readonly logger: StepLogger;
+}
+export interface TypedContextStore<TShared extends Record<string, unknown>> {
+    get<K extends keyof TShared>(key: K): TShared[K] | undefined;
+    set<K extends keyof TShared>(key: K, value: TShared[K]): void;
+    has<K extends keyof TShared>(key: K): boolean;
+    snapshot(): Partial<TShared>;
+}
+export interface StepExecutionRecord {
+    readonly stepName: string;
+    readonly attempt: number;
+    readonly status: FinishedStepStatus;
+    readonly input: unknown;
+    readonly output: unknown;
+    readonly error: unknown;
+    readonly nextDirective: NextStepDirective | null;
+    readonly sharedStateAfter: Record<string, unknown> | null;
+    readonly startedAt: Date;
+    readonly finishedAt: Date;
+}
+export declare class InMemoryContextStore<TShared extends Record<string, unknown>> implements TypedContextStore<TShared> {
+    private state;
+    constructor(initial?: Partial<TShared>);
+    get<K extends keyof TShared>(key: K): TShared[K] | undefined;
+    set<K extends keyof TShared>(key: K, value: TShared[K]): void;
+    has<K extends keyof TShared>(key: K): boolean;
+    snapshot(): Partial<TShared>;
+}

package/dist/esm/context.js

@@ -0,0 +1,17 @@
+export class InMemoryContextStore {
+    constructor(initial = {}) {
+        this.state = { ...initial };
+    }
+    get(key) {
+        return this.state[key];
+    }
+    set(key, value) {
+        this.state[key] = value;
+    }
+    has(key) {
+        return key in this.state;
+    }
+    snapshot() {
+        return { ...this.state };
+    }
+}

package/dist/esm/directives.d.ts

@@ -0,0 +1,89 @@
+export declare const DIRECTIVE_KIND: {
+    readonly CONTINUE: "continue";
+    readonly RETRY: "retry";
+    readonly PAUSE_UNTIL_SIGNAL: "pause_until_signal";
+    readonly TERMINATE: "terminate";
+    readonly FAIL: "fail";
+};
+export type DirectiveKind = (typeof DIRECTIVE_KIND)[keyof typeof DIRECTIVE_KIND];
+export type NextStepDirective = ContinueDirective | RetryDirective | PauseUntilSignalDirective | TerminateDirective | FailDirective;
+export interface ContinueDirective {
+    readonly kind: typeof DIRECTIVE_KIND.CONTINUE;
+    readonly stepName: string;
+    readonly input?: unknown;
+}
+export interface RetryDirective {
+    readonly kind: typeof DIRECTIVE_KIND.RETRY;
+    readonly delayMs?: number;
+    readonly reason?: string;
+}
+export interface PauseUntilSignalDirective {
+    readonly kind: typeof DIRECTIVE_KIND.PAUSE_UNTIL_SIGNAL;
+    readonly signal: {
+        readonly name: string;
+        readonly correlationId?: string;
+    };
+    readonly timeoutMs?: number;
+    readonly resumeStep?: string;
+}
+export interface TerminateDirective {
+    readonly kind: typeof DIRECTIVE_KIND.TERMINATE;
+    readonly reason?: string;
+}
+export interface FailDirective {
+    readonly kind: typeof DIRECTIVE_KIND.FAIL;
+    readonly reason?: string;
+}
+export declare function isContinue(d: NextStepDirective): d is ContinueDirective;
+export declare function isRetry(d: NextStepDirective): d is RetryDirective;
+export declare function isPause(d: NextStepDirective): d is PauseUntilSignalDirective;
+export declare function isTerminate(d: NextStepDirective): d is TerminateDirective;
+export declare function isFail(d: NextStepDirective): d is FailDirective;
+export interface Goto<Target extends string> {
+    readonly kind: typeof DIRECTIVE_KIND.CONTINUE;
+    readonly stepName: Target;
+    readonly input?: unknown;
+}
+export interface Terminate {
+    readonly kind: typeof DIRECTIVE_KIND.TERMINATE;
+    readonly output?: unknown;
+    readonly reason?: string;
+}
+export interface Fail {
+    readonly kind: typeof DIRECTIVE_KIND.FAIL;
+    readonly reason?: string;
+    readonly output?: unknown;
+}
+export interface Pause<Resume extends string> {
+    readonly kind: typeof DIRECTIVE_KIND.PAUSE_UNTIL_SIGNAL;
+    readonly signal: {
+        readonly name: string;
+        readonly correlationId?: string;
+    };
+    readonly resumeStep?: Resume;
+    readonly timeoutMs?: number;
+    readonly output?: unknown;
+}
+export interface Retry {
+    readonly kind: typeof DIRECTIVE_KIND.RETRY;
+    readonly delayMs?: number;
+    readonly reason?: string;
+}
+export declare function goto<const Target extends string>(target: Target, output?: unknown): Goto<Target>;
+export declare function terminate(output?: unknown, opts?: {
+    reason?: string;
+}): Terminate;
+export declare function fail(reason?: string, opts?: {
+    output?: unknown;
+}): Fail;
+export declare function pauseUntilSignal<const Resume extends string>(args: {
+    signal: string;
+    resumeStep?: Resume;
+    correlationId?: string;
+    timeoutMs?: number;
+    output?: unknown;
+}): Pause<Resume>;
+export declare function retry(opts?: {
+    delayMs?: number;
+    reason?: string;
+}): Retry;

package/dist/esm/directives.js

@@ -0,0 +1,43 @@
+export const DIRECTIVE_KIND = {
+    CONTINUE: 'continue',
+    RETRY: 'retry',
+    PAUSE_UNTIL_SIGNAL: 'pause_until_signal',
+    TERMINATE: 'terminate',
+    FAIL: 'fail',
+};
+export function isContinue(d) {
+    return d.kind === DIRECTIVE_KIND.CONTINUE;
+}
+export function isRetry(d) {
+    return d.kind === DIRECTIVE_KIND.RETRY;
+}
+export function isPause(d) {
+    return d.kind === DIRECTIVE_KIND.PAUSE_UNTIL_SIGNAL;
+}
+export function isTerminate(d) {
+    return d.kind === DIRECTIVE_KIND.TERMINATE;
+}
+export function isFail(d) {
+    return d.kind === DIRECTIVE_KIND.FAIL;
+}
+export function goto(target, output) {
+    return { kind: DIRECTIVE_KIND.CONTINUE, stepName: target, input: output };
+}
+export function terminate(output, opts) {
+    return { kind: DIRECTIVE_KIND.TERMINATE, output, reason: opts?.reason };
+}
+export function fail(reason, opts) {
+    return { kind: DIRECTIVE_KIND.FAIL, reason, output: opts?.output };
+}
+export function pauseUntilSignal(args) {
+    return {
+        kind: DIRECTIVE_KIND.PAUSE_UNTIL_SIGNAL,
+        signal: { name: args.signal, correlationId: args.correlationId },
+        resumeStep: args.resumeStep,
+        timeoutMs: args.timeoutMs,
+        output: args.output,
+    };
+}
+export function retry(opts) {
+    return { kind: DIRECTIVE_KIND.RETRY, delayMs: opts?.delayMs, reason: opts?.reason };
+}

package/dist/esm/errors.d.ts

@@ -0,0 +1,19 @@
+import type { $ZodIssue } from 'zod/v4/core';
+export declare class WorkflowError extends Error {
+    constructor(message: string);
+}
+export declare class StepInputValidationError extends WorkflowError {
+    readonly stepName: string;
+    readonly issues: readonly $ZodIssue[];
+    constructor(stepName: string, issues: readonly $ZodIssue[]);
+}
+export declare class UnknownStepError extends WorkflowError {
+    readonly stepName: string;
+    constructor(stepName: string);
+}
+export declare class DisallowedTransitionError extends WorkflowError {
+    readonly stepName: string;
+    readonly directiveKind: string;
+    readonly target?: string;
+    constructor(stepName: string, directiveKind: string, target?: string);
+}

package/dist/esm/errors.js

@@ -0,0 +1,42 @@
+export class WorkflowError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WorkflowError';
+    }
+}
+export class StepInputValidationError extends WorkflowError {
+    constructor(stepName, issues) {
+        super(`Input for step '${stepName}' failed validation: ${formatIssues(issues)}`);
+        this.name = 'StepInputValidationError';
+        this.stepName = stepName;
+        this.issues = issues;
+    }
+}
+function formatIssues(issues) {
+    if (issues.length === 0)
+        return 'unknown validation error';
+    return issues
+        .map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.join('.') : '(root)';
+        return `${path}: ${issue.message}`;
+    })
+        .join('; ');
+}
+export class UnknownStepError extends WorkflowError {
+    constructor(stepName) {
+        super(`Unknown step: ${stepName}`);
+        this.name = 'UnknownStepError';
+        this.stepName = stepName;
+    }
+}
+export class DisallowedTransitionError extends WorkflowError {
+    constructor(stepName, directiveKind, target) {
+        super(`Step '${stepName}' returned a '${directiveKind}' directive` +
+            (target ? ` to '${target}'` : '') +
+            ` that is not in its declared transitions`);
+        this.name = 'DisallowedTransitionError';
+        this.stepName = stepName;
+        this.directiveKind = directiveKind;
+        this.target = target;
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,17 @@
+export { DIRECTIVE_KIND, isContinue, isRetry, isPause, isTerminate, isFail } from './directives.js';
+export type { DirectiveKind, NextStepDirective, ContinueDirective, RetryDirective, PauseUntilSignalDirective, TerminateDirective, FailDirective, } from './directives.js';
+export { goto, terminate, fail, pauseUntilSignal, retry } from './directives.js';
+export type { Goto, Terminate, Fail, Pause, Retry } from './directives.js';
+export { defineStep } from './step.js';
+export type { Step, StepResult, StepDefinition, Allowed } from './step.js';
+export type { OrchestrationExecutionContext, TypedContextStore, StepExecutionRecord, StepLogger, FinishedStepStatus, } from './context.js';
+export { InMemoryContextStore } from './context.js';
+export type { OrchestrationDefinition } from './workflow.js';
+export { defineOrchestration, isOrchestrationDefinition, ORCHESTRATION_DEFINITION_BRAND } from './workflow.js';
+export { WorkflowError, UnknownStepError, StepInputValidationError, DisallowedTransitionError } from './errors.js';
+export { zodToJsonSchema, exampleFromJsonSchema, stepInputContract, workflowInputContract } from './introspection.js';
+export type { StepInputContract, WorkflowInputContract } from './introspection.js';
+export { MANIFEST_PROTOCOL, workflowManifestSchema } from './manifest.js';
+export type { WorkflowManifest, WorkflowStepManifest, ManifestTransition } from './manifest.js';
+export { buildManifest, validateGraph, assertValidGraph } from './build-manifest.js';
+export type { GraphValidation } from './build-manifest.js';

package/dist/esm/index.js

@@ -0,0 +1,9 @@
+export { DIRECTIVE_KIND, isContinue, isRetry, isPause, isTerminate, isFail } from './directives.js';
+export { goto, terminate, fail, pauseUntilSignal, retry } from './directives.js';
+export { defineStep } from './step.js';
+export { InMemoryContextStore } from './context.js';
+export { defineOrchestration, isOrchestrationDefinition, ORCHESTRATION_DEFINITION_BRAND } from './workflow.js';
+export { WorkflowError, UnknownStepError, StepInputValidationError, DisallowedTransitionError } from './errors.js';
+export { zodToJsonSchema, exampleFromJsonSchema, stepInputContract, workflowInputContract } from './introspection.js';
+export { MANIFEST_PROTOCOL, workflowManifestSchema } from './manifest.js';
+export { buildManifest, validateGraph, assertValidGraph } from './build-manifest.js';

package/dist/esm/introspection.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod/v4';
+import type { OrchestrationDefinition } from './workflow.js';
+export interface StepInputContract {
+    readonly jsonSchema: Record<string, unknown>;
+    readonly example: unknown;
+}
+export type WorkflowInputContract = StepInputContract;
+export declare function zodToJsonSchema(schema: z.ZodType): Record<string, unknown>;
+export declare function stepInputContract(def: OrchestrationDefinition<unknown, Record<string, unknown>>, stepName: string): StepInputContract | null;
+export declare function workflowInputContract(def: OrchestrationDefinition<unknown, Record<string, unknown>>): StepInputContract | null;
+export declare function exampleFromJsonSchema(jsonSchema: Record<string, unknown>): unknown;