@lostgradient/weft 0.2.0

package/dist/core/events/activity-events.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Fired on the {@link Engine} when an activity begins execution. Use to
+ * trace activity scheduling latency. Read `e.operationId`, `e.workflowId`,
+ * `e.activityName`, and `e.attempt` directly off the event.
+ *
+ * @example
+ * ```ts
+ * import { Engine, ActivityStartedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('activity:started', (e: Event) => {
+ *   const ev = e as ActivityStartedEvent;
+ *   console.log('activity started:', ev.activityName, 'attempt', ev.attempt);
+ * });
+ * ```
+ */
+export declare class ActivityStartedEvent extends Event {
+    static readonly type: "activity:started";
+    readonly operationId: string;
+    readonly workflowId: string;
+    readonly activityName: string;
+    readonly attempt: number;
+    constructor(operationId: string, workflowId: string, activityName: string, attempt: number);
+}
+/**
+ * Fired on the {@link Engine} when an activity execution completes successfully.
+ * Read `e.operationId`, `e.workflowId`, `e.activityName`, and `e.duration`
+ * (milliseconds) to observe activity latency.
+ *
+ * @example
+ * ```ts
+ * import { Engine, ActivityCompletedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('activity:completed', (e: Event) => {
+ *   const ev = e as ActivityCompletedEvent;
+ *   console.log(ev.activityName, 'completed in', ev.duration, 'ms');
+ * });
+ * ```
+ */
+export declare class ActivityCompletedEvent extends Event {
+    static readonly type: "activity:completed";
+    readonly operationId: string;
+    readonly workflowId: string;
+    readonly activityName: string;
+    readonly duration: number;
+    constructor(operationId: string, workflowId: string, activityName: string, duration: number);
+}
+/**
+ * Fired on the {@link Engine} when an activity defers to out-of-band completion
+ * by calling `ctx.completeAsync()` from its {@link ActivityContext}. The
+ * `token` is the durable, deterministic task token an external system passes to
+ * `engine.completeAsyncActivity(token, result)` /
+ * `engine.failAsyncActivity(token, error)` (or the matching
+ * `client.activity.*` methods) to resume the workflow. The token survives
+ * engine restart, so a callback that arrives after a crash still resolves the
+ * right activity.
+ *
+ * @example
+ * ```ts
+ * import { Engine, ActivityAsyncPendingEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('activity:async-pending', (e: Event) => {
+ *   const ev = e as ActivityAsyncPendingEvent;
+ *   console.log('awaiting external completion of', ev.activityName, 'token', ev.token);
+ * });
+ * ```
+ */
+export declare class ActivityAsyncPendingEvent extends Event {
+    static readonly type: "activity:async-pending";
+    readonly token: string;
+    readonly operationId: string;
+    readonly workflowId: string;
+    readonly activityName: string;
+    readonly attempt: number;
+    constructor(token: string, operationId: string, workflowId: string, activityName: string, attempt: number);
+}
+/**
+ * Fired on the {@link Engine} when an activity execution throws an error.
+ * Check `e.attempt` to distinguish first-attempt failures from retries.
+ * Read `e.error` for the thrown error object. `attempt` is 1-indexed —
+ * `attempt === 1` is the first execution; `attempt > 1` indicates a retry.
+ *
+ * @example
+ * ```ts
+ * import { Engine, ActivityFailedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('activity:failed', (e: Event) => {
+ *   const ev = e as ActivityFailedEvent;
+ *   console.error(ev.activityName, 'attempt', ev.attempt, 'failed:', ev.error.message);
+ * });
+ * ```
+ */
+export declare class ActivityFailedEvent extends Event {
+    static readonly type: "activity:failed";
+    readonly operationId: string;
+    readonly workflowId: string;
+    readonly activityName: string;
+    readonly error: Error;
+    readonly attempt: number;
+    constructor(operationId: string, workflowId: string, activityName: string, error: Error, attempt: number);
+}

package/dist/core/events/activity-events.js

@@ -0,0 +1,63 @@
+export class ActivityStartedEvent extends Event {
+  static type = "activity:started";
+  operationId;
+  workflowId;
+  activityName;
+  attempt;
+  constructor(operationId, workflowId, activityName, attempt) {
+    super(ActivityStartedEvent.type);
+    this.operationId = operationId;
+    this.workflowId = workflowId;
+    this.activityName = activityName;
+    this.attempt = attempt;
+  }
+}
+
+export class ActivityCompletedEvent extends Event {
+  static type = "activity:completed";
+  operationId;
+  workflowId;
+  activityName;
+  duration;
+  constructor(operationId, workflowId, activityName, duration) {
+    super(ActivityCompletedEvent.type);
+    this.operationId = operationId;
+    this.workflowId = workflowId;
+    this.activityName = activityName;
+    this.duration = duration;
+  }
+}
+
+export class ActivityAsyncPendingEvent extends Event {
+  static type = "activity:async-pending";
+  token;
+  operationId;
+  workflowId;
+  activityName;
+  attempt;
+  constructor(token, operationId, workflowId, activityName, attempt) {
+    super(ActivityAsyncPendingEvent.type);
+    this.token = token;
+    this.operationId = operationId;
+    this.workflowId = workflowId;
+    this.activityName = activityName;
+    this.attempt = attempt;
+  }
+}
+
+export class ActivityFailedEvent extends Event {
+  static type = "activity:failed";
+  operationId;
+  workflowId;
+  activityName;
+  error;
+  attempt;
+  constructor(operationId, workflowId, activityName, error, attempt) {
+    super(ActivityFailedEvent.type);
+    this.operationId = operationId;
+    this.workflowId = workflowId;
+    this.activityName = activityName;
+    this.error = error;
+    this.attempt = attempt;
+  }
+}

package/dist/core/events/attribute-events.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Fired on the {@link Engine} when a workflow's search attributes are updated
+ * via `engine.setAttributes` or `ctx.setAttribute`. Read `e.changes` for the
+ * map of attribute keys to their new values.
+ *
+ * @example
+ * ```ts
+ * import { Engine, AttributesChangedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('attributes:changed', (e: Event) => {
+ *   const ev = e as AttributesChangedEvent;
+ *   console.log('attributes changed for', ev.workflowId, ev.changes);
+ * });
+ * ```
+ */
+export declare class AttributesChangedEvent extends Event {
+    static readonly type: "attributes:changed";
+    readonly workflowId: string;
+    readonly changes: Record<string, unknown>;
+    constructor(workflowId: string, changes: Record<string, unknown>);
+}

package/dist/core/events/attribute-events.js

@@ -0,0 +1,10 @@
+export class AttributesChangedEvent extends Event {
+  static type = "attributes:changed";
+  workflowId;
+  changes;
+  constructor(workflowId, changes) {
+    super(AttributesChangedEvent.type);
+    this.workflowId = workflowId;
+    this.changes = changes;
+  }
+}

package/dist/core/events/event-map.d.ts

@@ -0,0 +1,80 @@
+import type { ReviewCompletedEvent, ReviewRequestedEvent } from '../review/events.ts';
+import type { ActivityAsyncPendingEvent, ActivityCompletedEvent, ActivityFailedEvent, ActivityStartedEvent } from './activity-events.ts';
+import type { AttributesChangedEvent } from './attribute-events.ts';
+import type { SignalDeliveredEvent, SignalReceivedEvent } from './signal-events.ts';
+import type { AlertFiredEvent, AlertResolvedEvent, CheckpointSizeWarningEvent, CleanupWarningEvent, ConstraintViolatedEvent, DevelopmentWarningEvent, StorageSizeReportedEvent } from './system-events.ts';
+import type { UpdateCompletedEvent, UpdateReceivedEvent } from './update-events.ts';
+import type { WorkflowCancelledEvent, WorkflowCompletedEvent, WorkflowFailedEvent, WorkflowRecoverySkippedEvent, WorkflowResumedEvent, WorkflowStartedEvent, WorkflowTimedOutEvent } from './workflow-events.ts';
+/**
+ * Record mapping each event-name string the {@link Engine} dispatches to its
+ * corresponding typed `Event` subclass. Use this as the type parameter for
+ * {@link TypedEventTarget} to get type-safe `addEventListener` /
+ * `removeEventListener` on the engine.
+ *
+ * @example
+ * ```ts
+ * import { Engine, type TypedEventTarget, type WeftEventMap } from '@lostgradient/weft';
+ *
+ * function listenAll(engine: Engine) {
+ *   (engine as TypedEventTarget<WeftEventMap>)
+ *     .addEventListener('workflow:completed', (e) => {
+ *       console.log('done', e.workflowId, e.result);
+ *     });
+ * }
+ * void listenAll;
+ * ```
+ */
+export type WeftEventMap = {
+    'workflow:started': WorkflowStartedEvent;
+    'workflow:completed': WorkflowCompletedEvent;
+    'workflow:failed': WorkflowFailedEvent;
+    'workflow:cancelled': WorkflowCancelledEvent;
+    'workflow:timed-out': WorkflowTimedOutEvent;
+    'workflow:resumed': WorkflowResumedEvent;
+    'workflow:recovery-skipped': WorkflowRecoverySkippedEvent;
+    'activity:started': ActivityStartedEvent;
+    'activity:completed': ActivityCompletedEvent;
+    'activity:failed': ActivityFailedEvent;
+    'activity:async-pending': ActivityAsyncPendingEvent;
+    'signal:received': SignalReceivedEvent;
+    'signal:delivered': SignalDeliveredEvent;
+    'human-review:requested': ReviewRequestedEvent;
+    'human-review:completed': ReviewCompletedEvent;
+    'attributes:changed': AttributesChangedEvent;
+    'update:received': UpdateReceivedEvent;
+    'update:completed': UpdateCompletedEvent;
+    'checkpoint:size-warning': CheckpointSizeWarningEvent;
+    'development:warning': DevelopmentWarningEvent;
+    'cleanup:warning': CleanupWarningEvent;
+    'storage:size-reported': StorageSizeReportedEvent;
+    'alert:fired': AlertFiredEvent;
+    'alert:resolved': AlertResolvedEvent;
+    'constraint:violated': ConstraintViolatedEvent;
+};
+/**
+ * Typed version of the `EventTarget` interface that constrains
+ * `addEventListener` and `removeEventListener` to the keys and event types
+ * declared in `TEventMap`. The {@link Engine} implements this interface via
+ * `WeftEventMap` so callers get IntelliSense on event names and strongly-typed
+ * handler arguments.
+ *
+ * @example
+ * ```ts
+ * import { Engine, type TypedEventTarget, type WeftEventMap } from '@lostgradient/weft';
+ *
+ * function addTypedListener(target: TypedEventTarget<WeftEventMap>) {
+ *   target.addEventListener('workflow:started', (e) => {
+ *     console.log('started:', e.workflowId);
+ *   });
+ * }
+ * const engine = new Engine();
+ * addTypedListener(engine as TypedEventTarget<WeftEventMap>);
+ * void engine;
+ * ```
+ */
+export interface TypedEventTarget<TEventMap extends Record<string, Event>> {
+    addEventListener<K extends keyof TEventMap & string>(type: K, listener: (event: TEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof TEventMap & string>(type: K, listener: (event: TEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}

package/dist/core/events/index.d.ts

@@ -0,0 +1,7 @@
+export * from './activity-events.ts';
+export * from './attribute-events.ts';
+export * from './event-map.ts';
+export * from './signal-events.ts';
+export * from './system-events.ts';
+export * from './update-events.ts';
+export * from './workflow-events.ts';

package/dist/core/events/index.js

@@ -0,0 +1,7 @@
+export * from "./activity-events.js";
+export * from "./attribute-events.js";
+export * from "./event-map.js";
+export * from "./signal-events.js";
+export * from "./system-events.js";
+export * from "./update-events.js";
+export * from "./workflow-events.js";

package/dist/core/events/signal-events.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Fired on the {@link Engine} when a signal is delivered to a workflow via
+ * `engine.signal` or `handle.signal`. Read `e.workflowId`, `e.signalName`,
+ * and `e.payload` to observe signal delivery.
+ *
+ * @example
+ * ```ts
+ * import { Engine, SignalReceivedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('signal:received', (e: Event) => {
+ *   const ev = e as SignalReceivedEvent;
+ *   console.log(ev.workflowId, 'received signal', ev.signalName);
+ * });
+ * ```
+ */
+export declare class SignalReceivedEvent extends Event {
+    static readonly type: "signal:received";
+    readonly workflowId: string;
+    readonly signalName: string;
+    readonly payload: unknown;
+    constructor(workflowId: string, signalName: string, payload: unknown);
+}
+/**
+ * Fired on the {@link Engine} when a pending `waitForSignal` operation in a
+ * workflow is resolved by the delivered signal. Emitted after the signal
+ * unblocks the workflow and resumes execution.
+ *
+ * @example
+ * ```ts
+ * import { Engine, SignalDeliveredEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('signal:delivered', (e: Event) => {
+ *   const ev = e as SignalDeliveredEvent;
+ *   console.log('signal', ev.signalName, 'delivered to', ev.workflowId);
+ * });
+ * ```
+ */
+export declare class SignalDeliveredEvent extends Event {
+    static readonly type: "signal:delivered";
+    readonly workflowId: string;
+    readonly signalName: string;
+    constructor(workflowId: string, signalName: string);
+}

package/dist/core/events/signal-events.js

@@ -0,0 +1,23 @@
+export class SignalReceivedEvent extends Event {
+  static type = "signal:received";
+  workflowId;
+  signalName;
+  payload;
+  constructor(workflowId, signalName, payload) {
+    super(SignalReceivedEvent.type);
+    this.workflowId = workflowId;
+    this.signalName = signalName;
+    this.payload = payload;
+  }
+}
+
+export class SignalDeliveredEvent extends Event {
+  static type = "signal:delivered";
+  workflowId;
+  signalName;
+  constructor(workflowId, signalName) {
+    super(SignalDeliveredEvent.type);
+    this.workflowId = workflowId;
+    this.signalName = signalName;
+  }
+}

package/dist/core/events/system-events.d.ts

@@ -0,0 +1,149 @@
+import type { ConstraintViolation } from '../constraint.ts';
+/**
+ * Fired on the {@link Engine} when a serialized checkpoint exceeds the
+ * configured size threshold ({@link DEFAULT_CHECKPOINT_SIZE_WARNING_THRESHOLD}).
+ * Read `e.sizeBytes` and `e.step` to identify the offending workflow step.
+ *
+ * @example
+ * ```ts
+ * import { Engine, CheckpointSizeWarningEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine({ checkpointSizeWarningThreshold: 32_000 });
+ * engine.addEventListener('checkpoint:size-warning', (e: Event) => {
+ *   const ev = e as CheckpointSizeWarningEvent;
+ *   console.warn(ev.workflowId, 'checkpoint at step', ev.step, 'is', ev.sizeBytes, 'bytes');
+ * });
+ * ```
+ */
+export declare class CheckpointSizeWarningEvent extends Event {
+    static readonly type: "checkpoint:size-warning";
+    readonly workflowId: string;
+    readonly sizeBytes: number;
+    readonly step: number;
+    constructor(workflowId: string, sizeBytes: number, step: number);
+}
+/**
+ * Fired on the {@link Engine} (in development mode) when the engine detects
+ * a potentially non-deterministic value in the workflow state — such as a Date
+ * object, a function, or a class instance. Read `e.message` and `e.fieldPaths`
+ * to locate the offending fields.
+ *
+ * @example
+ * ```ts
+ * import { Engine, DevelopmentWarningEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine({ development: true });
+ * engine.addEventListener('development:warning', (e: Event) => {
+ *   const ev = e as DevelopmentWarningEvent;
+ *   console.warn('[dev]', ev.message, 'paths:', ev.fieldPaths);
+ * });
+ * ```
+ */
+export declare class DevelopmentWarningEvent extends Event {
+    static readonly type: "development:warning";
+    readonly workflowId: string;
+    readonly message: string;
+    readonly fieldPaths: string[];
+    constructor(workflowId: string, message: string, fieldPaths: string[]);
+}
+export declare class CleanupWarningEvent extends Event {
+    static readonly type: "cleanup:warning";
+    readonly source: string;
+    readonly error: Error;
+    readonly workflowId: string | undefined;
+    constructor(source: string, error: Error, workflowId?: string);
+}
+/**
+ * Fired on the {@link Engine} when the engine measures its total storage
+ * footprint during a retention sweep. Read `e.sizeBytes` to track storage
+ * growth over time.
+ *
+ * @example
+ * ```ts
+ * import { Engine, StorageSizeReportedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('storage:size-reported', (e: Event) => {
+ *   const ev = e as StorageSizeReportedEvent;
+ *   console.log('total storage:', ev.sizeBytes, 'bytes');
+ * });
+ * ```
+ */
+export declare class StorageSizeReportedEvent extends Event {
+    static readonly type: "storage:size-reported";
+    readonly sizeBytes: number;
+    constructor(sizeBytes: number);
+}
+/**
+ * Fired on the {@link Engine} when a built-in alert metric breaches its
+ * threshold. Read `e.metric`, `e.threshold`, `e.currentValue`, and
+ * optionally `e.window` to understand which alert triggered.
+ *
+ * @example
+ * ```ts
+ * import { Engine, AlertFiredEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('alert:fired', (e: Event) => {
+ *   const ev = e as AlertFiredEvent;
+ *   console.warn('alert fired:', ev.metric, 'current:', ev.currentValue, 'threshold:', ev.threshold);
+ * });
+ * ```
+ */
+export declare class AlertFiredEvent extends Event {
+    static readonly type: "alert:fired";
+    readonly metric: string;
+    readonly threshold: number;
+    readonly currentValue: number;
+    readonly window: string | undefined;
+    constructor(metric: string, threshold: number, currentValue: number, window?: string);
+}
+/**
+ * Fired on the {@link Engine} when a previously fired alert returns below its
+ * threshold. Mirrors {@link AlertFiredEvent} — read `e.metric`,
+ * `e.currentValue`, and `e.threshold` to confirm the recovery.
+ *
+ * @example
+ * ```ts
+ * import { Engine, AlertResolvedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('alert:resolved', (e: Event) => {
+ *   const ev = e as AlertResolvedEvent;
+ *   console.log('alert resolved:', ev.metric, 'value back to', ev.currentValue);
+ * });
+ * ```
+ */
+export declare class AlertResolvedEvent extends Event {
+    static readonly type: "alert:resolved";
+    readonly metric: string;
+    readonly threshold: number;
+    readonly currentValue: number;
+    readonly window: string | undefined;
+    constructor(metric: string, threshold: number, currentValue: number, window?: string);
+}
+/**
+ * Fired on the {@link Engine} when a domain constraint's `check` function
+ * returns `false`. Read `e.constraintName`, `e.scope`, and `e.onViolation`
+ * to identify which constraint fired and what action the engine took.
+ *
+ * @example
+ * ```ts
+ * import { Engine, ConstraintViolatedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('constraint:violated', (e: Event) => {
+ *   const ev = e as ConstraintViolatedEvent;
+ *   console.warn('constraint', ev.constraintName, 'violated in', ev.workflowId,
+ *     'action:', ev.onViolation);
+ * });
+ * ```
+ */
+export declare class ConstraintViolatedEvent extends Event {
+    static readonly type: "constraint:violated";
+    readonly workflowId: string;
+    readonly constraintName: string;
+    readonly scope: string;
+    readonly onViolation: ConstraintViolation;
+    constructor(workflowId: string, constraintName: string, scope: string, onViolation: ConstraintViolation);
+}

package/dist/core/events/system-events.js

@@ -0,0 +1,92 @@
+export class CheckpointSizeWarningEvent extends Event {
+  static type = "checkpoint:size-warning";
+  workflowId;
+  sizeBytes;
+  step;
+  constructor(workflowId, sizeBytes, step) {
+    super(CheckpointSizeWarningEvent.type);
+    this.workflowId = workflowId;
+    this.sizeBytes = sizeBytes;
+    this.step = step;
+  }
+}
+
+export class DevelopmentWarningEvent extends Event {
+  static type = "development:warning";
+  workflowId;
+  message;
+  fieldPaths;
+  constructor(workflowId, message, fieldPaths) {
+    super(DevelopmentWarningEvent.type);
+    this.workflowId = workflowId;
+    this.message = message;
+    this.fieldPaths = fieldPaths;
+  }
+}
+
+export class CleanupWarningEvent extends Event {
+  static type = "cleanup:warning";
+  source;
+  error;
+  workflowId;
+  constructor(source, error, workflowId) {
+    super(CleanupWarningEvent.type);
+    this.source = source;
+    this.error = error;
+    this.workflowId = workflowId;
+  }
+}
+
+export class StorageSizeReportedEvent extends Event {
+  static type = "storage:size-reported";
+  sizeBytes;
+  constructor(sizeBytes) {
+    super(StorageSizeReportedEvent.type);
+    this.sizeBytes = sizeBytes;
+  }
+}
+
+export class AlertFiredEvent extends Event {
+  static type = "alert:fired";
+  metric;
+  threshold;
+  currentValue;
+  window;
+  constructor(metric, threshold, currentValue, window) {
+    super(AlertFiredEvent.type);
+    this.metric = metric;
+    this.threshold = threshold;
+    this.currentValue = currentValue;
+    this.window = window;
+  }
+}
+
+export class AlertResolvedEvent extends Event {
+  static type = "alert:resolved";
+  metric;
+  threshold;
+  currentValue;
+  window;
+  constructor(metric, threshold, currentValue, window) {
+    super(AlertResolvedEvent.type);
+    this.metric = metric;
+    this.threshold = threshold;
+    this.currentValue = currentValue;
+    this.window = window;
+  }
+}
+
+export class ConstraintViolatedEvent extends Event {
+  static type = "constraint:violated";
+  workflowId;
+  constraintName;
+  scope;
+  onViolation;
+  constructor(workflowId, constraintName, scope, onViolation) {
+    super(ConstraintViolatedEvent.type);
+    this.workflowId = workflowId;
+    this.constraintName = constraintName;
+    this.scope = scope;
+    this.onViolation = onViolation;
+  }
+}

package/dist/core/events/update-events.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Fired on the {@link Engine} when an update request is received for a workflow.
+ * Contains the `updateId`, `name`, and `payload`. Precedes a corresponding
+ * {@link UpdateCompletedEvent} once the workflow handler processes the update.
+ *
+ * @example
+ * ```ts
+ * import { Engine, UpdateReceivedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('update:received', (e: Event) => {
+ *   const ev = e as UpdateReceivedEvent;
+ *   console.log('update', ev.name, 'received for', ev.workflowId, '(id:', ev.updateId, ')');
+ * });
+ * ```
+ */
+export declare class UpdateReceivedEvent extends Event {
+    static readonly type: "update:received";
+    readonly updateId: string;
+    readonly workflowId: string;
+    readonly name: string;
+    readonly payload: unknown;
+    constructor(updateId: string, workflowId: string, name: string, payload: unknown);
+}
+/**
+ * Fired on the {@link Engine} when a workflow update handler returns a result
+ * (or throws an error). Check `e.error` to distinguish success from failure;
+ * on success, `e.result` holds the handler's return value.
+ *
+ * @example
+ * ```ts
+ * import { Engine, UpdateCompletedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('update:completed', (e: Event) => {
+ *   const ev = e as UpdateCompletedEvent;
+ *   if (ev.error) {
+ *     console.error('update', ev.name, 'failed:', ev.error);
+ *   } else {
+ *     console.log('update', ev.name, 'result:', ev.result);
+ *   }
+ * });
+ * ```
+ */
+export declare class UpdateCompletedEvent extends Event {
+    static readonly type: "update:completed";
+    readonly updateId: string;
+    readonly workflowId: string;
+    readonly name: string;
+    readonly result: unknown;
+    readonly error: string | undefined;
+    constructor(updateId: string, workflowId: string, name: string, result: unknown, error?: string);
+}