@aikirun/types 0.5.3

package/README.md

@@ -0,0 +1,48 @@
+# @aikirun/types
+
+Core type definitions for Aiki durable execution platform.
+
+This package provides the foundational TypeScript types used throughout the Aiki ecosystem. It is typically not used
+directly, but imported by other Aiki packages.
+
+## Installation
+
+```bash
+npm install @aikirun/types
+```
+
+## Exports
+
+- `/client` - Client configuration and API types
+- `/workflow` - Workflow definition types
+- `/workflow-run` - Workflow execution state types
+- `/workflow-run-api` - API contract types
+- `/task` - Task definition and state types
+- `/trigger` - Trigger strategy types
+- `/duration` - Duration types
+- `/retry` - Retry strategy types
+- `/error` - Serializable error types
+
+## Usage
+
+These types are primarily used by other Aiki packages:
+
+```typescript
+import type { WorkflowOptions } from "@aikirun/types/workflow-run";
+import type { TriggerStrategy } from "@aikirun/types/trigger";
+```
+
+## Related Packages
+
+- [@aikirun/client](https://www.npmjs.com/package/@aikirun/client) - Client SDK
+- [@aikirun/workflow](https://www.npmjs.com/package/@aikirun/workflow) - Workflow SDK
+- [@aikirun/task](https://www.npmjs.com/package/@aikirun/task) - Task SDK
+- [@aikirun/worker](https://www.npmjs.com/package/@aikirun/worker) - Worker SDK
+
+## Changelog
+
+See the [CHANGELOG](https://github.com/aikirun/aiki/blob/main/CHANGELOG.md) for version history.
+
+## License
+
+Apache-2.0

package/dist/client.d.ts

@@ -0,0 +1,125 @@
+import { WorkflowMeta } from './workflow.js';
+import { WorkflowRun, WorkflowRunId } from './workflow-run.js';
+import { WorkflowRunApi } from './workflow-run-api.js';
+import { INTERNAL } from './symbols.js';
+import './error.js';
+import './retry.js';
+import './sleep.js';
+import './duration.js';
+import './utils.js';
+import './task.js';
+import './trigger.js';
+
+interface ClientParams<AppContext> {
+    url: string;
+    redis: RedisConfig;
+    logger?: Logger;
+    contextFactory?: (run: Readonly<WorkflowRun>) => AppContext | Promise<AppContext>;
+}
+interface Client<AppContext> {
+    api: ApiClient;
+    logger: Logger;
+    close: () => Promise<void>;
+    [INTERNAL]: {
+        subscriber: {
+            create: (strategy: SubscriberStrategy, workflows: WorkflowMeta[], workerShards?: string[]) => SubscriberStrategyBuilder;
+        };
+        redis: RedisConnection;
+        contextFactory?: (run: WorkflowRun) => AppContext | Promise<AppContext>;
+    };
+}
+interface Logger {
+    info(message: string, metadata?: Record<string, unknown>): void;
+    debug(message: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, metadata?: Record<string, unknown>): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+    trace(message: string, metadata?: Record<string, unknown>): void;
+    child(bindings: Record<string, unknown>): Logger;
+}
+interface ApiClient {
+    workflowRun: WorkflowRunApi;
+}
+interface RedisClient {
+    xclaim(...args: unknown[]): Promise<unknown>;
+    xack(stream: string, group: string, messageId: string): Promise<number>;
+    xgroup(...args: unknown[]): Promise<unknown>;
+    xreadgroup(...args: unknown[]): Promise<unknown>;
+    xpending(...args: unknown[]): Promise<unknown>;
+    quit(): Promise<unknown>;
+}
+interface RedisConfig {
+    host: string;
+    port: number;
+    password?: string;
+    db?: number;
+    maxRetriesPerRequest?: number;
+    retryDelayOnFailoverMs?: number;
+    connectTimeoutMs?: number;
+}
+interface RedisConnection {
+    getConnection: () => RedisClient;
+    closeConnection: () => Promise<void>;
+}
+interface SubscriberMessageMeta {
+    stream: string;
+    messageId: string;
+    consumerGroup: string;
+}
+interface WorkflowRunBatch {
+    data: {
+        workflowRunId: WorkflowRunId;
+    };
+    meta?: SubscriberMessageMeta;
+}
+type SubscriberDelayParams = {
+    type: "polled";
+    foundWork: boolean;
+} | {
+    type: "retry";
+    attemptNumber: number;
+} | {
+    type: "heartbeat";
+} | {
+    type: "at_capacity";
+};
+interface ResolvedSubscriberStrategy {
+    type: string;
+    getNextDelay: (context: SubscriberDelayParams) => number;
+    getNextBatch: (size: number) => Promise<WorkflowRunBatch[]>;
+    heartbeat?: (workflowRunId: WorkflowRunId, meta: SubscriberMessageMeta) => Promise<void>;
+    acknowledge?: (workflowRunId: WorkflowRunId, meta: SubscriberMessageMeta) => Promise<void>;
+}
+interface PollingSubscriberStrategy {
+    type: "polling";
+    intervalMs?: number;
+    maxRetryIntervalMs?: number;
+    atCapacityIntervalMs?: number;
+}
+interface AdaptivePollingSubscriberStrategy {
+    type: "adaptive_polling";
+    minPollIntervalMs?: number;
+    maxPollIntervalMs?: number;
+    backoffMultiplier?: number;
+    emptyPollThreshold?: number;
+    jitterFactor?: number;
+    successResetThreshold?: number;
+    atCapacityIntervalMs?: number;
+}
+interface RedisStreamsSubscriberStrategy {
+    type: "redis_streams";
+    intervalMs?: number;
+    maxRetryIntervalMs?: number;
+    atCapacityIntervalMs?: number;
+    blockTimeMs?: number;
+    claimMinIdleTimeMs?: number;
+}
+type SubscriberStrategy = RedisStreamsSubscriberStrategy;
+interface SubscriberStrategyBuilder {
+    init: (workerId: string, callbacks: StrategyCallbacks) => Promise<ResolvedSubscriberStrategy>;
+}
+interface StrategyCallbacks {
+    onError?: (error: Error) => void;
+    onStop?: () => Promise<void>;
+}
+
+export type { AdaptivePollingSubscriberStrategy, ApiClient, Client, ClientParams, Logger, PollingSubscriberStrategy, RedisClient, RedisConfig, RedisConnection, RedisStreamsSubscriberStrategy, ResolvedSubscriberStrategy, StrategyCallbacks, SubscriberDelayParams, SubscriberMessageMeta, SubscriberStrategy, SubscriberStrategyBuilder, WorkflowRunBatch };

package/dist/duration.d.ts

@@ -0,0 +1,14 @@
+import { RequireAtLeastOneOf } from './utils.js';
+
+interface DurationFields {
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+    milliseconds?: number;
+}
+type DurationObject = RequireAtLeastOneOf<DurationFields, keyof DurationFields>;
+type DurationMs = number;
+type Duration = DurationMs | DurationObject;
+
+export type { Duration, DurationFields, DurationObject };

package/dist/error.d.ts

@@ -0,0 +1,11 @@
+type SerializableInput = null | string | number | boolean | {
+    [key: string]: SerializableInput;
+} | SerializableInput[];
+interface SerializableError {
+    message: string;
+    name: string;
+    stack?: string;
+    cause?: SerializableError;
+}
+
+export type { SerializableError, SerializableInput };

package/dist/retry.d.ts

@@ -0,0 +1,25 @@
+interface NeverRetryStrategy {
+    type: "never";
+}
+interface FixedRetryStrategy {
+    type: "fixed";
+    maxAttempts: number;
+    delayMs: number;
+}
+interface ExponentialRetryStrategy {
+    type: "exponential";
+    maxAttempts: number;
+    baseDelayMs: number;
+    factor?: number;
+    maxDelayMs?: number;
+}
+interface JitteredRetryStrategy {
+    type: "jittered";
+    maxAttempts: number;
+    baseDelayMs: number;
+    jitterFactor?: number;
+    maxDelayMs?: number;
+}
+type RetryStrategy = NeverRetryStrategy | FixedRetryStrategy | ExponentialRetryStrategy | JitteredRetryStrategy;
+
+export type { ExponentialRetryStrategy, FixedRetryStrategy, JitteredRetryStrategy, NeverRetryStrategy, RetryStrategy };

package/dist/sleep.d.ts

@@ -0,0 +1,37 @@
+import { DurationObject } from './duration.js';
+import './utils.js';
+
+type SleepId = string & {
+    _brand: "sleep_id";
+};
+type SleepPath = string & {
+    _brand: "sleep_path";
+};
+type SleepStatus = "none" | "sleeping" | "completed" | "cancelled";
+interface SleepStateBase {
+    status: SleepStatus;
+}
+interface SleepStateNone extends SleepStateBase {
+    status: "none";
+}
+interface SleepStateSleeping extends SleepStateBase {
+    status: "sleeping";
+    awakeAt: number;
+}
+interface SleepStateCompleted extends SleepStateBase {
+    status: "completed";
+    completedAt: number;
+}
+interface SleepStateCancelled extends SleepStateBase {
+    status: "cancelled";
+    cancelledAt: number;
+}
+type SleepState = SleepStateNone | SleepStateSleeping | SleepStateCompleted | SleepStateCancelled;
+type SleepParams = {
+    id: string;
+} & DurationObject;
+interface SleepResult {
+    cancelled: boolean;
+}
+
+export type { SleepId, SleepParams, SleepPath, SleepResult, SleepState, SleepStateCancelled, SleepStateCompleted, SleepStateNone, SleepStateSleeping, SleepStatus };

package/dist/symbols.d.ts

@@ -0,0 +1,3 @@
+declare const INTERNAL: unique symbol;
+
+export { INTERNAL };

package/dist/symbols.js

@@ -0,0 +1,5 @@
+// symbols.ts
+var INTERNAL = /* @__PURE__ */ Symbol("aiki.internal");
+export {
+  INTERNAL
+};

package/dist/task.d.ts

@@ -0,0 +1,40 @@
+import { SerializableError } from './error.js';
+
+type TaskId = string & {
+    _brand: "task_id";
+};
+type TaskPath = string & {
+    _brand: "task_path";
+};
+type TaskStatus = "none" | "running" | "completed" | "failed";
+interface TaskStateBase {
+    status: TaskStatus;
+}
+interface TaskStateNone extends TaskStateBase {
+    status: "none";
+}
+interface TaskStateRunning extends TaskStateBase {
+    status: "running";
+    attempts: number;
+}
+interface TaskStateCompleted<Output> extends TaskStateBase {
+    status: "completed";
+    output: Output;
+}
+interface TaskStateFailed extends TaskStateBase {
+    status: "failed";
+    reason: string;
+    attempts: number;
+    attemptedAt: number;
+    nextAttemptAt?: number;
+    error?: SerializableError;
+}
+type TaskState<Output> = TaskStateNone | TaskStateRunning | TaskStateCompleted<Output> | TaskStateFailed;
+declare class TaskFailedError extends Error {
+    readonly taskPath: TaskPath;
+    readonly attempts: number;
+    readonly reason: string;
+    constructor(taskPath: TaskPath, attempts: number, reason: string);
+}
+
+export { TaskFailedError, type TaskId, type TaskPath, type TaskState, type TaskStateCompleted, type TaskStateFailed, type TaskStateNone, type TaskStateRunning, type TaskStatus };

package/dist/task.js

@@ -0,0 +1,13 @@
+// task.ts
+var TaskFailedError = class extends Error {
+  constructor(taskPath, attempts, reason) {
+    super(`Task ${taskPath} failed after ${attempts} attempts. Reason: ${reason}`);
+    this.taskPath = taskPath;
+    this.attempts = attempts;
+    this.reason = reason;
+    this.name = "TaskFailedError";
+  }
+};
+export {
+  TaskFailedError
+};

package/dist/trigger.d.ts

@@ -0,0 +1,17 @@
+import { DurationObject } from './duration.js';
+import './utils.js';
+
+type TriggerStrategy = {
+    type: "immediate";
+} | {
+    type: "delayed";
+    delayMs: number;
+} | {
+    type: "delayed";
+    delay: DurationObject;
+} | {
+    type: "startAt";
+    startAt: number;
+};
+
+export type { TriggerStrategy };

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+type RequireAtLeastOneOf<T, Keys extends keyof T> = {
+    [K in Keys]-?: Required<Pick<T, K>> & Omit<T, K>;
+}[Keys];
+
+export type { RequireAtLeastOneOf };

package/dist/workflow-run-api.d.ts

@@ -0,0 +1,111 @@
+import { TaskState } from './task.js';
+import { WorkflowRunStatus, WorkflowRun, WorkflowRunState, WorkflowOptions, WorkflowRunStateScheduled, WorkflowRunStateScheduledByNew, WorkflowRunStateScheduledByResume, WorkflowRunStatePaused, WorkflowRunStateCancelled, WorkflowRunTransition } from './workflow-run.js';
+import './error.js';
+import './retry.js';
+import './sleep.js';
+import './duration.js';
+import './utils.js';
+import './trigger.js';
+
+interface WorkflowRunApi {
+    listV1: (input: WorkflowRunListRequestV1) => Promise<WorkflowRunListResponseV1>;
+    getByIdV1: (input: WorkflowRunGetByIdRequestV1) => Promise<WorkflowRunGetByIdResponseV1>;
+    getStateV1: (input: WorkflowRunGetStateRequestV1) => Promise<WorkflowRunGetStateResponseV1>;
+    createV1: (input: WorkflowRunCreateRequestV1) => Promise<WorkflowRunCreateResponseV1>;
+    transitionStateV1: (input: WorkflowRunTransitionStateRequestV1) => Promise<WorkflowRunTransitionStateResponseV1>;
+    transitionTaskStateV1: (input: WorkflowRunTransitionTaskStateRequestV1) => Promise<WorkflowRunTransitionTaskStateResponseV1>;
+    listTransitionsV1: (input: WorkflowRunListTransitionsRequestV1) => Promise<WorkflowRunListTransitionsResponseV1>;
+}
+interface WorkflowRunListRequestV1 {
+    limit?: number;
+    offset?: number;
+    filters?: {
+        workflows?: {
+            id?: string;
+            versionId?: string;
+        }[];
+        status?: WorkflowRunStatus[];
+    };
+    sort?: {
+        field: "createdAt";
+        order: "asc" | "desc";
+    };
+}
+interface WorkflowRunListItem {
+    id: string;
+    workflowId: string;
+    workflowVersionId: string;
+    createdAt: number;
+    status: WorkflowRunStatus;
+}
+interface WorkflowRunListResponseV1 {
+    runs: WorkflowRunListItem[];
+    total: number;
+}
+interface WorkflowRunGetByIdRequestV1 {
+    id: string;
+}
+interface WorkflowRunGetByIdResponseV1 {
+    run: WorkflowRun;
+}
+interface WorkflowRunGetStateRequestV1 {
+    id: string;
+}
+interface WorkflowRunGetStateResponseV1 {
+    state: WorkflowRunState<unknown>;
+}
+interface WorkflowRunCreateRequestV1 {
+    workflowId: string;
+    workflowVersionId: string;
+    input: unknown;
+    options?: WorkflowOptions;
+}
+interface WorkflowRunCreateResponseV1 {
+    run: WorkflowRun;
+}
+interface WorkflowRunTransitionStateRequestBase {
+    type: "optimistic" | "pessimistic";
+    id: string;
+    state: WorkflowRunState<unknown>;
+}
+interface WorkflowRunTransitionStateRequestOptimistic extends WorkflowRunTransitionStateRequestBase {
+    type: "optimistic";
+    state: Exclude<WorkflowRunState<unknown>, {
+        status: "scheduled" | "paused" | "cancelled";
+    }> | Exclude<WorkflowRunStateScheduled, {
+        reason: "new" | "resume";
+    }>;
+    expectedRevision: number;
+}
+interface WorkflowRunTransitionStateRequestPessimistic extends WorkflowRunTransitionStateRequestBase {
+    type: "pessimistic";
+    state: WorkflowRunStateScheduledByNew | WorkflowRunStateScheduledByResume | WorkflowRunStatePaused | WorkflowRunStateCancelled;
+}
+type WorkflowRunTransitionStateRequestV1 = WorkflowRunTransitionStateRequestOptimistic | WorkflowRunTransitionStateRequestPessimistic;
+interface WorkflowRunTransitionStateResponseV1 {
+    run: WorkflowRun;
+}
+interface WorkflowRunTransitionTaskStateRequestV1 {
+    id: string;
+    taskPath: string;
+    taskState: TaskState<unknown>;
+    expectedRevision: number;
+}
+interface WorkflowRunTransitionTaskStateResponseV1 {
+    run: WorkflowRun;
+}
+interface WorkflowRunListTransitionsRequestV1 {
+    id: string;
+    limit?: number;
+    offset?: number;
+    sort?: {
+        field: "createdAt";
+        order: "asc" | "desc";
+    };
+}
+interface WorkflowRunListTransitionsResponseV1 {
+    transitions: WorkflowRunTransition[];
+    total: number;
+}
+
+export type { WorkflowRunApi, WorkflowRunCreateRequestV1, WorkflowRunCreateResponseV1, WorkflowRunGetByIdRequestV1, WorkflowRunGetByIdResponseV1, WorkflowRunGetStateRequestV1, WorkflowRunGetStateResponseV1, WorkflowRunListItem, WorkflowRunListRequestV1, WorkflowRunListResponseV1, WorkflowRunListTransitionsRequestV1, WorkflowRunListTransitionsResponseV1, WorkflowRunTransitionStateRequestV1, WorkflowRunTransitionStateResponseV1, WorkflowRunTransitionTaskStateRequestV1, WorkflowRunTransitionTaskStateResponseV1 };

package/dist/workflow-run.d.ts

@@ -0,0 +1,173 @@
+import { SerializableError } from './error.js';
+import { RetryStrategy } from './retry.js';
+import { SleepState } from './sleep.js';
+import { TaskState } from './task.js';
+import { TriggerStrategy } from './trigger.js';
+import './duration.js';
+import './utils.js';
+
+type WorkflowRunId = string & {
+    _brand: "workflow_run_id";
+};
+type WorkflowRunStatus = "scheduled" | "queued" | "running" | "paused" | "sleeping" | "awaiting_event" | "awaiting_retry" | "awaiting_child_workflow" | "cancelled" | "completed" | "failed";
+type TerminalWorkflowRunStatus = "cancelled" | "completed" | "failed";
+type NonTerminalWorkflowRunStatus = Exclude<WorkflowRunStatus, TerminalWorkflowRunStatus>;
+interface WorkflowOptions {
+    retry?: RetryStrategy;
+    idempotencyKey?: string;
+    trigger?: TriggerStrategy;
+    shardKey?: string;
+}
+interface WorkflowRunStateBase {
+    status: WorkflowRunStatus;
+}
+type WorkflowRunScheduledReason = "new" | "retry" | "awake" | "resume" | "event";
+interface WorkflowRunStateScheduledBase extends WorkflowRunStateBase {
+    status: "scheduled";
+    scheduledAt: number;
+    reason: WorkflowRunScheduledReason;
+}
+interface WorkflowRunStateScheduledByNew extends WorkflowRunStateScheduledBase {
+    reason: "new";
+}
+interface WorkflowRunStateScheduledByRetry extends WorkflowRunStateScheduledBase {
+    reason: "retry";
+}
+interface WorkflowRunStateScheduledByAwake extends WorkflowRunStateScheduledBase {
+    reason: "awake";
+}
+interface WorkflowRunStateScheduledByResume extends WorkflowRunStateScheduledBase {
+    reason: "resume";
+}
+interface WorkflowRunStateScheduledByEvent extends WorkflowRunStateScheduledBase {
+    reason: "event";
+}
+type WorkflowRunStateScheduled = WorkflowRunStateScheduledByNew | WorkflowRunStateScheduledByRetry | WorkflowRunStateScheduledByAwake | WorkflowRunStateScheduledByResume | WorkflowRunStateScheduledByEvent;
+interface WorkflowRunStateQueued extends WorkflowRunStateBase {
+    status: "queued";
+    reason: WorkflowRunScheduledReason;
+}
+interface WorkflowRunStateRunning extends WorkflowRunStateBase {
+    status: "running";
+}
+interface WorkflowRunStatePaused extends WorkflowRunStateBase {
+    status: "paused";
+    pausedAt: number;
+}
+interface WorkflowRunStateSleeping extends WorkflowRunStateBase {
+    status: "sleeping";
+    sleepPath: string;
+    durationMs: number;
+}
+interface WorkflowRunStateAwaitingEvent extends WorkflowRunStateBase {
+    status: "awaiting_event";
+}
+type WorkflowFailureCause = "task" | "child_workflow" | "self";
+interface WorkflowRunStateAwaitingBase extends WorkflowRunStateBase {
+    status: "awaiting_retry";
+    cause: WorkflowFailureCause;
+    reason: string;
+    nextAttemptAt: number;
+}
+interface WorkflowRunStateAwaitingRetryCausedByTask extends WorkflowRunStateAwaitingBase {
+    cause: "task";
+    taskPath: string;
+}
+interface WorkflowRunStateAwaitingRetryCausedByChildWorkflow extends WorkflowRunStateAwaitingBase {
+    cause: "child_workflow";
+    childWorkflowRunId: string;
+}
+interface WorkflowRunStateAwaitingRetryCausedBySelf extends WorkflowRunStateAwaitingBase {
+    cause: "self";
+    error: SerializableError;
+}
+type WorkflowRunStateAwaitingRetry = WorkflowRunStateAwaitingRetryCausedByTask | WorkflowRunStateAwaitingRetryCausedByChildWorkflow | WorkflowRunStateAwaitingRetryCausedBySelf;
+interface WorkflowRunStateAwaitingChildWorkflow extends WorkflowRunStateBase {
+    status: "awaiting_child_workflow";
+}
+interface WorkflowRunStateCancelled extends WorkflowRunStateBase {
+    status: "cancelled";
+    reason?: string;
+}
+interface WorkflowRunStateCompleted<Output> extends WorkflowRunStateBase {
+    status: "completed";
+    output: Output;
+}
+interface WorkflowRunStateFailedBase extends WorkflowRunStateBase {
+    status: "failed";
+    cause: WorkflowFailureCause;
+    reason: string;
+}
+interface WorkflowRunStateFailedByTask extends WorkflowRunStateFailedBase {
+    cause: "task";
+    taskPath: string;
+}
+interface WorkflowRunStateFailedByChildWorkflow extends WorkflowRunStateFailedBase {
+    cause: "child_workflow";
+    childWorkflowRunId: string;
+}
+interface WorkflowRunStateFailedBySelf extends WorkflowRunStateFailedBase {
+    cause: "self";
+    error: SerializableError;
+}
+type WorkflowRunStateFailed = WorkflowRunStateFailedByTask | WorkflowRunStateFailedByChildWorkflow | WorkflowRunStateFailedBySelf;
+type WorkflowRunStateInComplete = WorkflowRunStateScheduled | WorkflowRunStateQueued | WorkflowRunStateRunning | WorkflowRunStatePaused | WorkflowRunStateSleeping | WorkflowRunStateAwaitingEvent | WorkflowRunStateAwaitingRetry | WorkflowRunStateAwaitingChildWorkflow | WorkflowRunStateCancelled | WorkflowRunStateFailed;
+type WorkflowRunState<Output> = WorkflowRunStateInComplete | WorkflowRunStateCompleted<Output>;
+interface WorkflowRun<Input = unknown, Output = unknown> {
+    id: string;
+    workflowId: string;
+    workflowVersionId: string;
+    createdAt: number;
+    revision: number;
+    input: Input;
+    options: WorkflowOptions;
+    attempts: number;
+    state: WorkflowRunState<Output>;
+    tasksState: Record<string, TaskState<unknown>>;
+    sleepsState: Record<string, SleepState>;
+    childWorkflowsRunState: Record<string, WorkflowRunState<unknown>>;
+}
+interface WorkflowRunTransitionBase {
+    createdAt: number;
+    type: "state" | "task_state";
+}
+interface WorkflowRunStateTransition extends WorkflowRunTransitionBase {
+    type: "state";
+    state: WorkflowRunState<unknown>;
+}
+interface WorkflowRunTaskStateTransition extends WorkflowRunTransitionBase {
+    type: "task_state";
+    taskPath: string;
+    taskState: TaskState<unknown>;
+}
+type WorkflowRunTransition = WorkflowRunStateTransition | WorkflowRunTaskStateTransition;
+declare class WorkflowRunConflictError extends Error {
+    readonly id: WorkflowRunId;
+    readonly operation: string;
+    readonly attempts: number;
+    constructor(id: WorkflowRunId, operation: string, attempts: number);
+}
+declare class WorkflowRunNotExecutableError extends Error {
+    readonly id: WorkflowRunId;
+    readonly status: WorkflowRunStatus;
+    constructor(id: WorkflowRunId, status: WorkflowRunStatus);
+}
+declare class WorkflowRunPausedError extends Error {
+    constructor(id: WorkflowRunId);
+}
+declare class WorkflowRunCancelledError extends Error {
+    constructor(id: WorkflowRunId);
+}
+declare class WorkflowRunFailedError extends Error {
+    readonly id: WorkflowRunId;
+    readonly attempts: number;
+    readonly reason: string;
+    readonly failureCause?: WorkflowFailureCause | undefined;
+    constructor(id: WorkflowRunId, attempts: number, reason: string, failureCause?: WorkflowFailureCause | undefined);
+}
+declare class WorkflowRunSuspendedError extends Error {
+    readonly id: WorkflowRunId;
+    constructor(id: WorkflowRunId);
+}
+
+export { type NonTerminalWorkflowRunStatus, type TerminalWorkflowRunStatus, type WorkflowFailureCause, type WorkflowOptions, type WorkflowRun, WorkflowRunCancelledError, WorkflowRunConflictError, WorkflowRunFailedError, type WorkflowRunId, WorkflowRunNotExecutableError, WorkflowRunPausedError, type WorkflowRunScheduledReason, type WorkflowRunState, type WorkflowRunStateAwaitingBase, type WorkflowRunStateAwaitingChildWorkflow, type WorkflowRunStateAwaitingEvent, type WorkflowRunStateAwaitingRetry, type WorkflowRunStateAwaitingRetryCausedByChildWorkflow, type WorkflowRunStateAwaitingRetryCausedBySelf, type WorkflowRunStateAwaitingRetryCausedByTask, type WorkflowRunStateCancelled, type WorkflowRunStateCompleted, type WorkflowRunStateFailed, type WorkflowRunStateFailedByChildWorkflow, type WorkflowRunStateFailedBySelf, type WorkflowRunStateFailedByTask, type WorkflowRunStateInComplete, type WorkflowRunStatePaused, type WorkflowRunStateQueued, type WorkflowRunStateRunning, type WorkflowRunStateScheduled, type WorkflowRunStateScheduledByAwake, type WorkflowRunStateScheduledByEvent, type WorkflowRunStateScheduledByNew, type WorkflowRunStateScheduledByResume, type WorkflowRunStateScheduledByRetry, type WorkflowRunStateSleeping, type WorkflowRunStateTransition, type WorkflowRunStatus, WorkflowRunSuspendedError, type WorkflowRunTaskStateTransition, type WorkflowRunTransition, type WorkflowRunTransitionBase };

package/dist/workflow-run.js

@@ -0,0 +1,55 @@
+// workflow-run.ts
+var WorkflowRunConflictError = class extends Error {
+  constructor(id, operation, attempts) {
+    super(`Conflict while performing ${operation} on workflow ${id} after ${attempts} attempts`);
+    this.id = id;
+    this.operation = operation;
+    this.attempts = attempts;
+    this.name = "WorkflowRunConflictError";
+  }
+};
+var WorkflowRunNotExecutableError = class extends Error {
+  constructor(id, status) {
+    super(`Workflow ${id} is not executable while ${status}`);
+    this.id = id;
+    this.status = status;
+    this.name = "WorkflowRunNotExecutableError";
+  }
+};
+var WorkflowRunPausedError = class extends Error {
+  constructor(id) {
+    super(`Workflow ${id} paused`);
+    this.name = "WorkflowRunPausedError";
+  }
+};
+var WorkflowRunCancelledError = class extends Error {
+  constructor(id) {
+    super(`Workflow ${id} cancelled`);
+    this.name = "WorkflowRunCancelledError";
+  }
+};
+var WorkflowRunFailedError = class extends Error {
+  constructor(id, attempts, reason, failureCause) {
+    super(`Workflow ${id} failed after ${attempts} attempt(s): ${reason}`);
+    this.id = id;
+    this.attempts = attempts;
+    this.reason = reason;
+    this.failureCause = failureCause;
+    this.name = "WorkflowRunFailedError";
+  }
+};
+var WorkflowRunSuspendedError = class extends Error {
+  constructor(id) {
+    super(`Workflow ${id} is suspended`);
+    this.id = id;
+    this.name = "WorkflowRunSuspendedError";
+  }
+};
+export {
+  WorkflowRunCancelledError,
+  WorkflowRunConflictError,
+  WorkflowRunFailedError,
+  WorkflowRunNotExecutableError,
+  WorkflowRunPausedError,
+  WorkflowRunSuspendedError
+};

package/dist/workflow.d.ts

@@ -0,0 +1,12 @@
+type WorkflowId = string & {
+    _brand: "workflow_id";
+};
+type WorkflowVersionId = string & {
+    _brand: "workflow_version_id";
+};
+interface WorkflowMeta {
+    id: WorkflowId;
+    versionId: WorkflowVersionId;
+}
+
+export type { WorkflowId, WorkflowMeta, WorkflowVersionId };

package/package.json

@@ -0,0 +1,66 @@
+{
+	"name": "@aikirun/types",
+	"version": "0.5.3",
+	"description": "Core type definitions for Aiki - including workflow, task, client, and trigger types",
+	"type": "module",
+	"exports": {
+		"./utils": {
+			"types": "./dist/utils.d.ts",
+			"import": "./dist/utils.js"
+		},
+		"./symbols": {
+			"types": "./dist/symbols.d.ts",
+			"import": "./dist/symbols.js"
+		},
+		"./duration": {
+			"types": "./dist/duration.d.ts",
+			"import": "./dist/duration.js"
+		},
+		"./retry": {
+			"types": "./dist/retry.d.ts",
+			"import": "./dist/retry.js"
+		},
+		"./error": {
+			"types": "./dist/error.d.ts",
+			"import": "./dist/error.js"
+		},
+		"./client": {
+			"types": "./dist/client.d.ts",
+			"import": "./dist/client.js"
+		},
+		"./trigger": {
+			"types": "./dist/trigger.d.ts",
+			"import": "./dist/trigger.js"
+		},
+		"./workflow": {
+			"types": "./dist/workflow.d.ts",
+			"import": "./dist/workflow.js"
+		},
+		"./workflow-run": {
+			"types": "./dist/workflow-run.d.ts",
+			"import": "./dist/workflow-run.js"
+		},
+		"./workflow-run-api": {
+			"types": "./dist/workflow-run-api.d.ts",
+			"import": "./dist/workflow-run-api.js"
+		},
+		"./task": {
+			"types": "./dist/task.d.ts",
+			"import": "./dist/task.js"
+		},
+		"./sleep": {
+			"types": "./dist/sleep.d.ts",
+			"import": "./dist/sleep.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsup"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"license": "Apache-2.0"
+}