@lostgradient/weft 0.2.0

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

@@ -0,0 +1,31 @@
+export class UpdateReceivedEvent extends Event {
+  static type = "update:received";
+  updateId;
+  workflowId;
+  name;
+  payload;
+  constructor(updateId, workflowId, name, payload) {
+    super(UpdateReceivedEvent.type);
+    this.updateId = updateId;
+    this.workflowId = workflowId;
+    this.name = name;
+    this.payload = payload;
+  }
+}
+
+export class UpdateCompletedEvent extends Event {
+  static type = "update:completed";
+  updateId;
+  workflowId;
+  name;
+  result;
+  error;
+  constructor(updateId, workflowId, name, result, error) {
+    super(UpdateCompletedEvent.type);
+    this.updateId = updateId;
+    this.workflowId = workflowId;
+    this.name = name;
+    this.result = result;
+    this.error = error;
+  }
+}

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

@@ -0,0 +1,198 @@
+import type { TerminationReason } from '../types/history-policy.ts';
+/**
+ * Fired on the {@link Engine} when a new workflow execution begins. Listen via
+ * `engine.addEventListener('workflow:started', handler)` and read
+ * `e.workflowId`, `e.workflowType`, and `e.input` directly off the event.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, WorkflowStartedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('workflow:started', (e: Event) => {
+ *   const ev = e as WorkflowStartedEvent;
+ *   console.log('started', ev.workflowId, ev.workflowType);
+ * });
+ * engine.register(workflow({ name: 'ping' }).execute(async function* () { return 'pong'; }));
+ * await engine.start('ping', null);
+ * ```
+ */
+export declare class WorkflowStartedEvent extends Event {
+    static readonly type: "workflow:started";
+    readonly workflowId: string;
+    readonly workflowType: string;
+    readonly input: unknown;
+    constructor(workflowId: string, workflowType: string, input: unknown);
+}
+/**
+ * Fired on the {@link Engine} when a workflow finishes successfully. Contains
+ * the `result` and wall-clock `duration` in milliseconds. Read `e.workflowId`,
+ * `e.result`, and `e.duration` directly off the event object.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, WorkflowCompletedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('workflow:completed', (e: Event) => {
+ *   const ev = e as WorkflowCompletedEvent;
+ *   console.log('completed in', ev.duration, 'ms, result:', ev.result);
+ * });
+ * engine.register(workflow({ name: 'ping' }).execute(async function* () { return 'pong'; }));
+ * await (await engine.start('ping', null)).result();
+ * ```
+ */
+export declare class WorkflowCompletedEvent extends Event {
+    static readonly type: "workflow:completed";
+    readonly workflowId: string;
+    readonly result: unknown;
+    readonly duration: number;
+    constructor(workflowId: string, result: unknown, duration: number);
+}
+/**
+ * Fired on the {@link Engine} when a workflow terminates with an unhandled error.
+ * The `error` property holds the thrown `Error` object. Listen to diagnose
+ * failures without polling `handle.state()`.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, WorkflowFailedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('workflow:failed', (e: Event) => {
+ *   const ev = e as WorkflowFailedEvent;
+ *   console.error('workflow', ev.workflowId, 'failed:', ev.error.message);
+ * });
+ * engine.register(workflow({ name: 'boom' }).execute(async function* () { throw new Error('oops'); }));
+ * await engine.start('boom', null).then(h => h.result()).catch(() => undefined);
+ * ```
+ */
+export declare class WorkflowFailedEvent extends Event {
+    static readonly type: "workflow:failed";
+    readonly workflowId: string;
+    readonly error: Error;
+    constructor(workflowId: string, error: Error);
+}
+/**
+ * Fired on the {@link Engine} when a workflow is cancelled via
+ * `engine.cancel(workflowId)` or `handle.cancel()`. Contains only
+ * `e.workflowId` since there is no result or error.
+ *
+ * @example
+ * ```ts
+ * import { Engine, workflow, WorkflowCancelledEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('workflow:cancelled', (e: Event) => {
+ *   const ev = e as WorkflowCancelledEvent;
+ *   console.log('cancelled', ev.workflowId);
+ * });
+ * engine.register(
+ *   workflow({ name: 'slow' }).execute(async function* (
+ *     _ctx: import('@lostgradient/weft').WorkflowContext,
+ *     _input: unknown,
+ *   ) {
+ *     await new Promise(() => {}); // never resolves
+ *   }),
+ * );
+ * const handle = await engine.start('slow', null);
+ * await handle.cancel();
+ * ```
+ */
+export declare class WorkflowCancelledEvent extends Event {
+    static readonly type: "workflow:cancelled";
+    readonly workflowId: string;
+    constructor(workflowId: string);
+}
+/**
+ * Fired on the {@link Engine} when a workflow exceeds its execution or run
+ * timeout. Read `e.timeoutType` (`'execution'` or `'run'`) and `e.elapsed`
+ * (milliseconds) to understand which limit was hit. `e.reason` is populated
+ * only when the workflow was forced to `timed-out` by the history circuit
+ * breaker (it is `undefined` for ordinary deadline timeouts), so operators
+ * reading the event stream can distinguish the two.
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowTimedOutEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('workflow:timed-out', (e: Event) => {
+ *   const ev = e as WorkflowTimedOutEvent;
+ *   console.log(ev.workflowId, 'timed out after', ev.elapsed, 'ms (', ev.timeoutType, ')');
+ * });
+ * ```
+ */
+export declare class WorkflowTimedOutEvent extends Event {
+    static readonly type: "workflow:timed-out";
+    readonly workflowId: string;
+    readonly timeoutType: 'execution' | 'run';
+    readonly elapsed: number;
+    readonly reason?: TerminationReason;
+    constructor(workflowId: string, timeoutType: 'execution' | 'run', elapsed: number, reason?: TerminationReason);
+}
+/**
+ * The workflow lifecycle event types that terminate a workflow. Derived from
+ * the terminal event classes so the set cannot drift from their declared
+ * `type`s. The single source of truth for "is this event terminal?" across the
+ * engine's handle iterator and both client transports' live event streams — add
+ * a new terminal event class here and every consumer picks it up.
+ */
+export declare const WORKFLOW_TERMINAL_EVENT_TYPES: ReadonlySet<string>;
+/**
+ * Fired whenever a workflow resumes execution — after a signal, update, sleep,
+ * activity completion, or process restart recovery.
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowResumedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener('workflow:resumed', (e: Event) => {
+ *   const ev = e as WorkflowResumedEvent;
+ *   console.log('resumed', ev.workflowId, 'from step', ev.fromStep);
+ * });
+ * ```
+ */
+export declare class WorkflowResumedEvent extends Event {
+    static readonly type: "workflow:resumed";
+    readonly workflowId: string;
+    readonly fromStep: number;
+    constructor(workflowId: string, fromStep: number);
+}
+/**
+ * Reason carried by {@link WorkflowRecoverySkippedEvent}.
+ *
+ * @example
+ * ```ts
+ * import type { WorkflowRecoverySkippedReason } from '@lostgradient/weft';
+ *
+ * const reason: WorkflowRecoverySkippedReason = 'type-not-registered';
+ * void reason;
+ * ```
+ */
+export type WorkflowRecoverySkippedReason = 'type-not-registered';
+/**
+ * Fired during acknowledged recovery when a running workflow is intentionally
+ * skipped because its workflow type is not registered on this engine. This
+ * event is only emitted when `recoverAll({ acknowledgeUnknownWorkflowTypes:
+ * true })` is used.
+ *
+ * @example
+ * ```ts
+ * import { Engine, WorkflowRecoverySkippedEvent } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.addEventListener(WorkflowRecoverySkippedEvent.type, (event) => {
+ *   const skipped = event as WorkflowRecoverySkippedEvent;
+ *   console.warn('skipped recovery for', skipped.workflowType);
+ * });
+ * ```
+ */
+export declare class WorkflowRecoverySkippedEvent extends Event {
+    static readonly type: "workflow:recovery-skipped";
+    readonly workflowId: string;
+    readonly workflowType: string;
+    readonly reason: WorkflowRecoverySkippedReason;
+    constructor(workflowId: string, workflowType: string, reason: WorkflowRecoverySkippedReason);
+}

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

@@ -0,0 +1,91 @@
+export class WorkflowStartedEvent extends Event {
+  static type = "workflow:started";
+  workflowId;
+  workflowType;
+  input;
+  constructor(workflowId, workflowType, input) {
+    super(WorkflowStartedEvent.type);
+    this.workflowId = workflowId;
+    this.workflowType = workflowType;
+    this.input = input;
+  }
+}
+
+export class WorkflowCompletedEvent extends Event {
+  static type = "workflow:completed";
+  workflowId;
+  result;
+  duration;
+  constructor(workflowId, result, duration) {
+    super(WorkflowCompletedEvent.type);
+    this.workflowId = workflowId;
+    this.result = result;
+    this.duration = duration;
+  }
+}
+
+export class WorkflowFailedEvent extends Event {
+  static type = "workflow:failed";
+  workflowId;
+  error;
+  constructor(workflowId, error) {
+    super(WorkflowFailedEvent.type);
+    this.workflowId = workflowId;
+    this.error = error;
+  }
+}
+
+export class WorkflowCancelledEvent extends Event {
+  static type = "workflow:cancelled";
+  workflowId;
+  constructor(workflowId) {
+    super(WorkflowCancelledEvent.type);
+    this.workflowId = workflowId;
+  }
+}
+
+export class WorkflowTimedOutEvent extends Event {
+  static type = "workflow:timed-out";
+  workflowId;
+  timeoutType;
+  elapsed;
+  reason;
+  constructor(workflowId, timeoutType, elapsed, reason) {
+    super(WorkflowTimedOutEvent.type);
+    this.workflowId = workflowId;
+    this.timeoutType = timeoutType;
+    this.elapsed = elapsed;
+    if (reason !== void 0)
+      this.reason = reason;
+  }
+}
+export const WORKFLOW_TERMINAL_EVENT_TYPES = new Set([
+  WorkflowCompletedEvent.type,
+  WorkflowFailedEvent.type,
+  WorkflowCancelledEvent.type,
+  WorkflowTimedOutEvent.type
+]);
+
+export class WorkflowResumedEvent extends Event {
+  static type = "workflow:resumed";
+  workflowId;
+  fromStep;
+  constructor(workflowId, fromStep) {
+    super(WorkflowResumedEvent.type);
+    this.workflowId = workflowId;
+    this.fromStep = fromStep;
+  }
+}
+
+export class WorkflowRecoverySkippedEvent extends Event {
+  static type = "workflow:recovery-skipped";
+  workflowId;
+  workflowType;
+  reason;
+  constructor(workflowId, workflowType, reason) {
+    super(WorkflowRecoverySkippedEvent.type);
+    this.workflowId = workflowId;
+    this.workflowType = workflowType;
+    this.reason = reason;
+  }
+}

package/dist/core/events.d.ts

@@ -0,0 +1 @@
+export * from './events/index.ts';

package/dist/core/events.js

@@ -0,0 +1 @@
+export * from "./events/index.js";

package/dist/core/execution-strategy.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Execution strategy interface for workflow execution.
+ *
+ * Defines the contract for how workflows are driven (inline on the main thread
+ * or in a Web Worker). The engine delegates generator lifecycle to a strategy
+ * and reacts uniformly to {@link WorkerOutboundMessage} regardless of where
+ * the workflow code actually runs.
+ *
+ * @remarks
+ * **`ExecutionStrategy` is the untrusted-workflow isolation boundary.** Workflows
+ * are user-supplied code. This interface is the single seam across which the engine
+ * drives that code, and the only place where "where does the workflow generator
+ * step?" is decided. `InlineExecutionStrategy` steps the generator in the engine's
+ * own isolate (no isolation — appropriate only for trusted workflows) and is the
+ * default when `workflowExecutionMode` is omitted.
+ * `WorkerExecutionStrategy` steps the generator inside a Web Worker and communicates
+ * with the engine through bounded `postMessage` turns, so untrusted workflow code
+ * never executes in the engine isolate. `workflowExecutionMode: 'worker'` is the
+ * hardened untrusted posture, must be requested explicitly (and requires
+ * `workerExecution`), and in that mode the engine's `inlineStrategy` is `null` —
+ * every code path that would step a workflow generator is guarded on
+ * `inlineStrategy` and therefore unreachable.
+ *
+ * **Security contract the boundary upholds for untrusted code (worker strategy):**
+ * - *Memory isolation (execution).* Workflow stepping and its generator
+ *   locals/closures/heap live in the Worker's isolate. The engine sees only
+ *   serialized checkpoint `ArrayBuffer`s crossing `postMessage`.
+ * - *No engine-heap access.* Worker-side workflow code cannot reach engine objects
+ *   (the registration map, checkpoints, scheduler, storage); it receives only what
+ *   crosses `postMessage` — its input, the checkpoint buffer, and operation results
+ *   in, checkpoint/completed/failed messages out.
+ * - *Crash containment.* A thrown error inside the worker becomes a `failed`
+ *   {@link WorkerOutboundMessage}; an outright worker crash is caught by the
+ *   strategy's worker `error` listener, surfaced as `failed`, and the worker is
+ *   discarded from the pool so it is never reused.
+ * - *Host liveness.* Hardened Worker mode arms a host-side wall-clock timeout for
+ *   each `run` and `resume` turn. If workflow code wedges the Worker event loop,
+ *   the strategy terminates and discards that Worker instead of waiting for
+ *   Worker-side timers.
+ * - *Bounded protocol messages.* Weft-owned Worker protocol envelopes are measured
+ *   before host-to-Worker sends, before Worker helper sends, and again at host
+ *   ingress. Oversized envelopes fail the affected workflow with a bounded
+ *   resource error instead of being persisted or routed to the engine.
+ *
+ * **Caveats.** This is an engine-isolate boundary, not a hostile-code sandbox.
+ * Workflow code runs in the same Worker global realm as the Worker entrypoint,
+ * so it can access APIs the runtime exposes there, including Worker globals,
+ * imports, network APIs, filesystem APIs in Bun, and environment APIs when
+ * present. Turn ids and protocol versions are race guards; they reject stale or
+ * malformed messages for the current turn but do not prove which code inside the
+ * Worker realm authored a message. Worker-side message preflight covers Weft's
+ * own outbound helper; direct calls to `globalThis.postMessage` can still make
+ * the host runtime allocate a structured clone before host-side validation runs.
+ *
+ * **Caveat — "holds the reference, never executes it."** Even under the worker
+ * strategy the engine still *holds* the workflow handler function in its
+ * registration map; it simply never *invokes* it. This is execution isolation, not
+ * a claim that the engine never possesses the workflow's code. How a given worker
+ * obtains its copy of the workflow code is a property of how the caller built the
+ * worker bundle (for example a bundle that serializes handlers via
+ * `Function.prototype.toString`), not of this interface.
+ *
+ * **Transport-agnostic.** The methods return `void` and all engine/strategy
+ * coupling flows through serializable messages plus {@link ExecutionStrategy.onMessage}.
+ * That shape is not Worker-specific: a future out-of-process or remote workflow
+ * worker could implement the same interface. (The existing RemoteWorker WebSocket
+ * protocol is activity dispatch and is not suitable for stateful workflow checkpoint
+ * execution, so it is not that transport.)
+ *
+ * @module core/execution-strategy
+ */
+import type { OperationOutcome, WorkerOutboundMessage } from './types.ts';
+export interface ExecutionStrategy extends Disposable, AsyncDisposable {
+    /**
+     * Start a new workflow execution from the beginning.
+     */
+    startWorkflow(parameters: {
+        workflowId: string;
+        workflowType: string;
+        input: unknown;
+        checkpoint: ArrayBuffer | Uint8Array;
+        nestingDepth?: number;
+        executionStateOwnerId?: string;
+        startedAt?: number;
+        sleepReferenceTime?: number;
+        deadline?: number;
+        headers?: [string, string][];
+    }): void;
+    /**
+     * Resume a suspended workflow by feeding an operation result back into it.
+     */
+    resumeWorkflow(parameters: {
+        workflowId: string;
+        checkpoint: ArrayBuffer | Uint8Array;
+        operationResult: OperationOutcome;
+    }): void;
+    /**
+     * Cancel an in-flight workflow, aborting its generator.
+     */
+    cancelWorkflow(workflowId: string): void;
+    /**
+     * Register a handler that receives all outbound messages from the strategy.
+     * The engine calls this once during setup; the handler persists for the
+     * lifetime of the strategy.
+     */
+    onMessage(handler: (message: WorkerOutboundMessage) => void | Promise<void>): void;
+}

package/dist/core/failure-categories.d.ts

@@ -0,0 +1,18 @@
+import type { FailureCategory, OperationOutcome } from './types.ts';
+export declare const FAILURE_CATEGORIES: readonly ["application", "timeout", "cancellation", "resource", "system"];
+export declare const timeoutFailureCategoryMarker: unique symbol;
+export interface FailureCategoryClassificationOptions {
+    /**
+     * Category to use for ordinary Error instances that do not match a known
+     * infrastructure name. Omit this at engine boundaries so unknown runtime
+     * failures stay classified as system failures.
+     */
+    defaultErrorCategory?: FailureCategory;
+}
+export declare function isFailureCategory(value: unknown): value is FailureCategory;
+export declare function normalizeFailureCategory(value: unknown): FailureCategory | undefined;
+export declare function failureCategorySearchValues(category: FailureCategory): readonly string[];
+export declare function classifyErrorAsFailureCategory(error: unknown, options?: FailureCategoryClassificationOptions): FailureCategory;
+export declare function errorFromFailedOperationOutcome(outcome: Extract<OperationOutcome, {
+    status: 'failed';
+}>): Error;

package/dist/core/failure-categories.js

@@ -0,0 +1,70 @@
+export const FAILURE_CATEGORIES = [
+  "application",
+  "timeout",
+  "cancellation",
+  "resource",
+  "system"
+];
+const currentFailureCategories = new Set(FAILURE_CATEGORIES), timeoutErrorNames = new Set([
+  "MCPToolTimeoutError",
+  "ReviewTimeoutError",
+  "UpdateTimeoutError",
+  "WorkflowTimeoutError",
+  "TimeoutError"
+]);
+export const timeoutFailureCategoryMarker = Symbol.for("weft.failure-category.timeout");
+const cancellationErrorNames = new Set([
+  "AbortError",
+  "CancelledError",
+  "CancellationError",
+  "WorkflowCancelledError"
+]), resourceErrorNames = new Set([
+  "QuotaExceededError",
+  "ResourceExhaustedError",
+  "OutOfMemoryError",
+  "StorageQuotaExceededError"
+]), legacyFailureCategoryMapping = {
+  action: "application",
+  memory: "resource",
+  planning: "application",
+  reflection: "application",
+  system: "system"
+}, failureCategorySearchAliases = {
+  application: ["application", "action", "planning", "reflection"],
+  timeout: ["timeout"],
+  cancellation: ["cancellation"],
+  resource: ["resource", "memory"],
+  system: ["system"]
+};
+export function isFailureCategory(value) {
+  return currentFailureCategories.has(value);
+}
+export function normalizeFailureCategory(value) {
+  if (isFailureCategory(value))
+    return value;
+  if (typeof value !== "string")
+    return;
+  return legacyFailureCategoryMapping[value];
+}
+export function failureCategorySearchValues(category) {
+  return failureCategorySearchAliases[category];
+}
+export function classifyErrorAsFailureCategory(error, options = {}) {
+  if (!(error instanceof Error))
+    return "system";
+  if (timeoutErrorNames.has(error.name))
+    return "timeout";
+  if (Object.prototype.hasOwnProperty.call(error, timeoutFailureCategoryMarker))
+    return "timeout";
+  if (cancellationErrorNames.has(error.name))
+    return "cancellation";
+  if (resourceErrorNames.has(error.name))
+    return "resource";
+  return options.defaultErrorCategory ?? "system";
+}
+export function errorFromFailedOperationOutcome(outcome) {
+  const error = Error(outcome.error);
+  if (outcome.errorName !== void 0)
+    error.name = outcome.errorName;
+  return error;
+}

package/dist/core/fault-code.d.ts

@@ -0,0 +1,92 @@
+/**
+ * `FaultCode` is the stable, machine-readable discriminant that the server's
+ * operation pipeline attaches to every fault. Transport adapters serialize it
+ * onto the wire so clients can branch on the failure programmatically rather
+ * than string-matching a human message:
+ *
+ *   - REST: `{ error: { code, message, data? } }` (see `fault-to-http.ts`).
+ *   - JSON-RPC: `data.weftCode` (see `fault-to-json-rpc.ts`).
+ *
+ * The type lives in `core` — not `server` — because both the server (which
+ * produces faults) and the client (which consumes them off the wire) need it,
+ * and the client must not import from `server`. The server re-exports it from
+ * `operation-fault.ts` so its existing call sites are unaffected.
+ *
+ * `FAULT_CODE_TO_FAILURE_CATEGORY` is the single source of truth for mapping a
+ * wire fault code onto the coarser {@link FailureCategory} execution taxonomy.
+ * The category is a derived convenience: it is **not** carried on the wire, so
+ * a client computes it from `faultCode` rather than reading it from the body.
+ */
+import type { FailureCategory } from './types/identity.ts';
+/**
+ * Stable fault code names. The full vocabulary is closed for v1; new codes can
+ * be added additively, and the `satisfies` map below forces every new code to
+ * declare its failure category at compile time.
+ *
+ * @example
+ * ```ts
+ * import { HttpClientError, type FaultCode } from '@lostgradient/weft';
+ *
+ * function describe(error: HttpClientError): string {
+ *   const code: FaultCode | undefined = error.faultCode;
+ *   return code === 'NotFound' ? 'missing resource' : (code ?? 'unknown');
+ * }
+ * void describe;
+ * ```
+ */
+export type FaultCode = 'Unauthorized' | 'Forbidden' | 'NotFound' | 'Conflict' | 'Unprocessable' | 'Timeout' | 'NotImplemented' | 'UnsupportedTransport' | 'SubscriptionOverflow' | 'InvalidParams' | 'MethodNotFound' | 'EngineFailure';
+/**
+ * Maps each wire {@link FaultCode} onto a {@link FailureCategory}.
+ *
+ * There is deliberately no `cancellation` entry: cancellation never crosses
+ * the REST fault wire (HTTP has no fault code for an aborted request), so no
+ * fault code can derive that category.
+ *
+ * Declared with `satisfies` so adding a future `FaultCode` is a compile error
+ * until it is mapped here.
+ *
+ * @example
+ * ```ts
+ * import { FAULT_CODE_TO_FAILURE_CATEGORY } from '@lostgradient/weft';
+ *
+ * FAULT_CODE_TO_FAILURE_CATEGORY.Timeout; // 'timeout'
+ * ```
+ */
+export declare const FAULT_CODE_TO_FAILURE_CATEGORY: Readonly<{
+    readonly Unauthorized: "application";
+    readonly Forbidden: "application";
+    readonly NotFound: "application";
+    readonly Conflict: "application";
+    readonly Unprocessable: "application";
+    readonly InvalidParams: "application";
+    readonly MethodNotFound: "application";
+    readonly Timeout: "timeout";
+    readonly SubscriptionOverflow: "resource";
+    readonly NotImplemented: "system";
+    readonly UnsupportedTransport: "system";
+    readonly EngineFailure: "system";
+}>;
+/**
+ * Type guard: narrows an unknown wire value to a known {@link FaultCode}.
+ *
+ * @example
+ * ```ts
+ * import { isFaultCode } from '@lostgradient/weft';
+ *
+ * isFaultCode('NotFound'); // true
+ * isFaultCode('teapot'); // false
+ * ```
+ */
+export declare function isFaultCode(value: unknown): value is FaultCode;
+/**
+ * Returns the {@link FailureCategory} a given {@link FaultCode} belongs to.
+ *
+ * @example
+ * ```ts
+ * import { failureCategoryForFaultCode } from '@lostgradient/weft';
+ *
+ * failureCategoryForFaultCode('Timeout'); // 'timeout'
+ * failureCategoryForFaultCode('EngineFailure'); // 'system'
+ * ```
+ */
+export declare function failureCategoryForFaultCode(code: FaultCode): FailureCategory;

package/dist/core/fault-code.js

@@ -0,0 +1,21 @@
+export const FAULT_CODE_TO_FAILURE_CATEGORY = Object.freeze({
+  Unauthorized: "application",
+  Forbidden: "application",
+  NotFound: "application",
+  Conflict: "application",
+  Unprocessable: "application",
+  InvalidParams: "application",
+  MethodNotFound: "application",
+  Timeout: "timeout",
+  SubscriptionOverflow: "resource",
+  NotImplemented: "system",
+  UnsupportedTransport: "system",
+  EngineFailure: "system"
+});
+const faultCodes = new Set(Object.keys(FAULT_CODE_TO_FAILURE_CATEGORY));
+export function isFaultCode(value) {
+  return faultCodes.has(value);
+}
+export function failureCategoryForFaultCode(code) {
+  return FAULT_CODE_TO_FAILURE_CATEGORY[code];
+}