@lostgradient/weft 0.2.0

package/dist/core/types/workflow-function.d.ts

@@ -0,0 +1,330 @@
+import { type WorkflowBuilderOptions } from './workflow-builder-runtime.ts';
+import type { InitialBuilderState, WorkflowBuilder } from './workflow-builder.ts';
+import type { WorkflowContext } from './workflow-context.ts';
+export { WorkflowBuilderError, type WorkflowBuilderOptions } from './workflow-builder-runtime.ts';
+export type { WorkflowDefinition } from './workflow-definition.ts';
+/**
+ * Signature of a durable workflow generator function registered via
+ * {@link Engine.register}. The engine calls it with a {@link WorkflowContext}
+ * and the start `input`, then drives the generator by feeding operation
+ * results back via `next`. Use `yield*` (delegated yield) when calling
+ * context methods (`ctx.run(...)`, `ctx.sleep(...)`, `ctx.review(...)`);
+ * a bare `yield` will not produce the operation results expected by the
+ * engine.
+ *
+ * @example
+ * ```ts
+ * import { workflow, activity, Engine, type WorkflowContext, type WorkflowFunction } from '@lostgradient/weft';
+ *
+ * const greet = activity({ name: 'greet', execute: async (input: string) => `hello ${input}` });
+ *
+ * const myWorkflow: WorkflowFunction<string, string> =
+ *   async function* (ctx: WorkflowContext, input: string) {
+ *     return yield* ctx.run(greet, input);
+ *   };
+ *
+ * const engine = new Engine();
+ * engine.register(workflow({ name: 'myWorkflow' }).execute(myWorkflow));
+ * void engine;
+ * ```
+ */
+export type WorkflowFunction<TInput = unknown, TOutput = unknown> = (context: WorkflowContext, input: TInput) => AsyncGenerator<unknown, TOutput, unknown>;
+/**
+ * Simplified context for step-based ("progressive disclosure") workflows.
+ * Instead of yielding operations via a generator, write a plain `async`
+ * function and call `ctx.step(name, fn)` for each durable step. Compile the
+ * function to a generator via {@link compileStepWorkflow}.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, compileStepWorkflow, type StepWorkflowContext } from '@lostgradient/weft';
+ *
+ * async function myStepWorkflow(ctx: StepWorkflowContext, input: unknown) {
+ *   const result = await ctx.step('fetchData', async () => {
+ *     return { data: input };
+ *   });
+ *   return result;
+ * }
+ *
+ * const engine = new Engine();
+ * engine.register(workflow({ name: 'stepWorkflow' }).execute(compileStepWorkflow(myStepWorkflow)));
+ * void engine;
+ * ```
+ */
+export interface StepWorkflowContext {
+    readonly workflowId: string;
+    readonly signal: AbortSignal;
+    step<T>(name: string, fn: () => Promise<T> | T): Promise<T>;
+}
+/**
+ * Type alias for a plain async function that uses {@link StepWorkflowContext}
+ * instead of a generator. Use with {@link compileStepWorkflow} to register
+ * it on the engine. This is the "progressive disclosure" API for users who
+ * prefer async/await over generator syntax.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, compileStepWorkflow, type StepWorkflowFunction } from '@lostgradient/weft';
+ *
+ * const process: StepWorkflowFunction = async (ctx, input) => {
+ *   return ctx.step('transform', () => (input as string).toUpperCase());
+ * };
+ *
+ * const engine = new Engine();
+ * engine.register(workflow({ name: 'process' }).execute(compileStepWorkflow(process)));
+ * void engine;
+ * ```
+ */
+export type StepWorkflowFunction<TInput = unknown, TOutput = unknown> = (context: StepWorkflowContext, input: TInput) => Promise<TOutput>;
+/**
+ * Returned by composition operators on {@link WorkflowContext} and durable
+ * operation methods on {@link Context} (run, sleep, race, offload, etc.).
+ * Use `yield*` to consume it inside a workflow generator function; the result
+ * type is `TResult`.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, type WorkflowOperation, type WorkflowContext } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.register(
+ *   workflow({ name: 'parent' }).execute(async function* (ctx: WorkflowContext, input: unknown) {
+ *     const items = input as string[];
+ *     const op: WorkflowOperation<string[]> = ctx.map(items, 'child');
+ *     return yield* op;
+ *   }),
+ * );
+ * engine.register(
+ *   workflow({ name: 'child' }).execute(async function* (_ctx: WorkflowContext, s: unknown) {
+ *     return String(s).toUpperCase();
+ *   }),
+ * );
+ * void engine;
+ * ```
+ */
+export type WorkflowOperation<TResult> = Generator<unknown, TResult, unknown>;
+/**
+ * Accepted forms for specifying a child workflow in composition operators
+ * (`ctx.pipe`, `ctx.map`, `ctx.reduce`): a registered workflow name string,
+ * a {@link WorkflowFunction} reference, or a {@link StepWorkflowFunction}
+ * reference. The engine resolves the actual workflow type at runtime.
+ *
+ * Prefer the workflow name string. Identity-based lookup of a function
+ * reference only succeeds if the engine's `workflowTypesByHandler` map
+ * contains the exact function passed in — but the builder API wraps the
+ * user-supplied `fn` inside `workflow({ name }).execute(fn)` before storing
+ * it on the definition, so the registered handler is not the same reference
+ * as `fn`. Passing the bare `fn` to a composition operator after registering
+ * via the builder will throw at runtime as an unregistered function. Use
+ * the workflow name string (`ctx.pipe(['stage-one', 'stage-two'], input)`)
+ * or the `definition.handler` of an already-built workflow definition.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, type ChildWorkflowTarget, type WorkflowContext } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.register(
+ *   workflow({ name: 'transform' }).execute(async function* (_ctx: WorkflowContext, input: unknown) {
+ *     return String(input).toUpperCase();
+ *   }),
+ * );
+ *
+ * const target: ChildWorkflowTarget<unknown, string> = 'transform';
+ * engine.register(
+ *   workflow({ name: 'parent' }).execute(async function* (ctx: WorkflowContext, input: unknown) {
+ *     return yield* ctx.map([input], target);
+ *   }),
+ * );
+ * void engine;
+ * ```
+ */
+export type ChildWorkflowTarget<TInput = unknown, TOutput = unknown> = string | WorkflowFunction<TInput, TOutput> | StepWorkflowFunction<TInput, TOutput>;
+/**
+ * Options passed to child workflow invocations within `ctx.pipe`, `ctx.map`,
+ * or `ctx.reduce`. Currently accepts an optional `id` to control the child
+ * workflow ID.
+ */
+export type ChildWorkflowOptions = {
+    id?: string;
+};
+/**
+ * A single stage in a `ctx.pipe(stages, input)` composition chain. Pairs a
+ * {@link ChildWorkflowTarget} with optional {@link ChildWorkflowOptions} such
+ * as a custom child workflow ID. Use the object form when you need to pass
+ * per-stage options; otherwise a bare {@link ChildWorkflowTarget} also works.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, type WorkflowPipeStage, type WorkflowContext } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.register(workflow({ name: 'step1' }).execute(async function* (_ctx: WorkflowContext, i: unknown) { return String(i); }));
+ * engine.register(workflow({ name: 'step2' }).execute(async function* (_ctx: WorkflowContext, i: unknown) { return (i as string).trim(); }));
+ *
+ * engine.register(
+ *   workflow({ name: 'pipeline' }).execute(async function* (ctx: WorkflowContext, input: unknown) {
+ *     const stages: [WorkflowPipeStage, WorkflowPipeStage] = [
+ *       { type: 'step1' },
+ *       { type: 'step2', options: { id: 'trim-step' } },
+ *     ];
+ *     return yield* ctx.pipe(stages, input);
+ *   }),
+ * );
+ * void engine;
+ * ```
+ */
+export interface WorkflowPipeStage<TInput = unknown, TOutput = unknown> {
+    type: ChildWorkflowTarget<TInput, TOutput>;
+    options?: ChildWorkflowOptions;
+}
+/**
+ * Union of the two accepted formats for each stage passed to `ctx.pipe`:
+ * either a full {@link WorkflowPipeStage} object with a `type` and optional
+ * `options`, or a bare {@link ChildWorkflowTarget} (a string name or function
+ * reference). The engine normalises both forms before executing.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, type WorkflowPipeStageDefinition, type WorkflowContext } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.register(
+ *   workflow({ name: 'upper' }).execute(async function* (_ctx: WorkflowContext, i: unknown) {
+ *     return String(i).toUpperCase();
+ *   }),
+ * );
+ * engine.register(
+ *   workflow({ name: 'trim' }).execute(async function* (_ctx: WorkflowContext, i: unknown) {
+ *     return String(i).trim();
+ *   }),
+ * );
+ *
+ * const stages: [WorkflowPipeStageDefinition, WorkflowPipeStageDefinition] = ['upper', 'trim'];
+ * engine.register(
+ *   workflow({ name: 'pipeline' }).execute(async function* (ctx: WorkflowContext, input: unknown) {
+ *     return yield* ctx.pipe(stages, input);
+ *   }),
+ * );
+ * void engine;
+ * ```
+ */
+export type WorkflowPipeStageDefinition<TInput = unknown, TOutput = unknown> = WorkflowPipeStage<TInput, TOutput> | ChildWorkflowTarget<TInput, TOutput>;
+/**
+ * Options for `ctx.map(items, workflowType, options)`. Controls the maximum
+ * number of child workflows that run simultaneously. Defaults to running all
+ * items in parallel when `concurrency` is not set.
+ * The actual fan-out is also bounded by `EngineOptions.maxNestingDepth`
+ * (default 10) — passing a `concurrency` higher than the remaining nesting
+ * budget will surface a runtime error, not silently throttle.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, type WorkflowMapOptions, type WorkflowContext } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.register(
+ *   workflow({ name: 'processItem' }).execute(async function* (_ctx: WorkflowContext, item: unknown) {
+ *     return String(item).toUpperCase();
+ *   }),
+ * );
+ * engine.register(
+ *   workflow({ name: 'batchProcess' }).execute(async function* (ctx: WorkflowContext, input: unknown) {
+ *     const items = input as string[];
+ *     const options: WorkflowMapOptions = { concurrency: 3 };
+ *     return yield* ctx.map(items, 'processItem', options);
+ *   }),
+ * );
+ * void engine;
+ * ```
+ */
+export interface WorkflowMapOptions {
+    concurrency?: number;
+}
+/**
+ * Input shape passed to each child workflow invocation within `ctx.reduce`.
+ * Contains the running `accumulator`, the current `item`, and its zero-based
+ * `index`. The child workflow's return value becomes the next accumulator.
+ *
+ * @example
+ * ```ts
+ * import { Engine, workflow, type WorkflowReduceInput, type WorkflowContext } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.register(
+ *   workflow({ name: 'sumStep' }).execute(async function* (
+ *     _ctx: WorkflowContext,
+ *     input: WorkflowReduceInput<number, number>,
+ *   ) {
+ *     const { accumulator, item } = input;
+ *     return accumulator + item;
+ *   }),
+ * );
+ *
+ * engine.register(
+ *   workflow({ name: 'sumAll' }).execute(async function* (ctx: WorkflowContext, input: unknown) {
+ *     const items = input as number[];
+ *     return yield* ctx.reduce(items, 'sumStep', 0);
+ *   }),
+ * );
+ * void engine;
+ * ```
+ */
+export interface WorkflowReduceInput<TAccumulator, TItem> {
+    accumulator: TAccumulator;
+    item: TItem;
+    index: number;
+}
+/**
+ * Options for `ctx.reduce(items, workflowType, initialValue, options)`.
+ * Supply `idPrefix` to give each generated child workflow ID a deterministic
+ * prefix, which helps with idempotency and debugging.
+ *
+ * @example
+ * ```ts
+ * import { Engine, workflow, type WorkflowReduceOptions, type WorkflowContext } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.register(
+ *   workflow({ name: 'merge' }).execute(async function* (
+ *     _ctx: WorkflowContext,
+ *     input: { accumulator: string[]; item: string },
+ *   ) {
+ *     const { accumulator, item } = input;
+ *     return [...accumulator, item];
+ *   }),
+ * );
+ * engine.register(
+ *   workflow({ name: 'collect' }).execute(async function* (ctx: WorkflowContext, input: unknown) {
+ *     const items = input as string[];
+ *     const opts: WorkflowReduceOptions = { idPrefix: 'collect-merge' };
+ *     return yield* ctx.reduce(items, 'merge', [], opts);
+ *   }),
+ * );
+ * void engine;
+ * ```
+ */
+export interface WorkflowReduceOptions extends Record<string, unknown> {
+    idPrefix?: string;
+}
+/**
+ * Create a workflow via the chained builder API.
+ *
+ * @example
+ * ```ts
+ * import { workflow, signal } from '@lostgradient/weft';
+ *
+ * const welcome = workflow({ name: 'welcome' })
+ *   .activities({
+ *     formatGreeting: async ({ name }: { name: string }) => `Hello, ${name}!`,
+ *   })
+ *   .signals({ approve: signal<{ approverId: string }>('approve') })
+ *   .execute(async function* (ctx, input: { name: string }) {
+ *     const greeting = yield* ctx.run('formatGreeting', input);
+ *     const { approverId } = yield* ctx.waitForSignal('approve');
+ *     return { greeting, approverId };
+ *   });
+ * void welcome;
+ * ```
+ */
+export declare function workflow<const TName extends string>(options: WorkflowBuilderOptions<TName>): WorkflowBuilder<TName, {}, {}, {}, {}, {}, InitialBuilderState>;

package/dist/core/types/workflow-function.js

@@ -0,0 +1,9 @@
+import { validateWorkflowOrActivityName } from "./name-grammar.js";
+import { WorkflowBuilderImpl } from "./workflow-builder-runtime.js";
+export { WorkflowBuilderError } from "./workflow-builder-runtime.js";
+export function workflow(options) {
+  if (!options.name)
+    throw Error("workflow() requires an options object with a name.");
+  validateWorkflowOrActivityName(options.name, "workflow");
+  return new WorkflowBuilderImpl(options);
+}

package/dist/core/types/workflow-registries.d.ts

@@ -0,0 +1,203 @@
+import type { ActivityContext, ActivityDefinition, ActivityFunction } from './activity.ts';
+import type { StepWorkflowFunction, WorkflowDefinition, WorkflowFunction } from './workflow-function.ts';
+/**
+ * Module-augmentation target for typed workflow names. Add entries with
+ * `input` and `output` fields to make `engine.register`, `engine.start`, and
+ * `WorkflowHandle.result()` type-safe for string workflow names.
+ *
+ * @example
+ * ```ts
+ * import type { WorkflowRegistry } from '@lostgradient/weft';
+ *
+ * interface WelcomeInput {
+ *   name: string;
+ * }
+ *
+ * interface WelcomeOutput {
+ *   greeting: string;
+ * }
+ *
+ * declare module '@lostgradient/weft' {
+ *   interface WorkflowRegistry {
+ *     welcome: { input: WelcomeInput; output: WelcomeOutput };
+ *   }
+ * }
+ *
+ * const welcomeInput: WorkflowRegistry['welcome']['input'] = { name: 'Ada' };
+ * void welcomeInput;
+ * ```
+ */
+export interface WorkflowRegistry {
+}
+export type WorkflowRegistryEntry = {
+    input: unknown;
+    output: unknown;
+};
+declare const defaultWorkflowRegistry: unique symbol;
+declare const defaultActivityTypes: unique symbol;
+/**
+ * Default workflow registry carried by `new Engine()` when no local registry
+ * type parameters are supplied. It preserves module-augmented workflow names
+ * without adding a hidden dynamic-name fallback.
+ */
+export type DefaultWorkflowRegistry = WorkflowRegistry & {
+    readonly [defaultWorkflowRegistry]: true;
+};
+/**
+ * Default activity registry carried by `new Engine()` when no local activity
+ * type parameter is supplied. After the global `ActivityTypes` augmentation
+ * surface was removed, an engine constructed without explicit activity type
+ * parameters carries no known activity names; users opt in via the chained
+ * builder API (`workflow({...}).activities({...})`) or `Engine.create({ activities })`.
+ */
+export type DefaultActivityTypes = {
+    readonly [defaultActivityTypes]: true;
+};
+export type IsDefaultWorkflowRegistry<TRegistry extends object> = TRegistry extends DefaultWorkflowRegistry ? true : false;
+/**
+ * Broad workflow-definition constraint used by {@link Engine.create} and the
+ * typed builder methods. `never` in the input position lets concrete
+ * definitions such as `WorkflowDefinition<string, string>` satisfy the
+ * constraint under strict function variance.
+ *
+ * @example
+ * ```ts
+ * import { workflow, type AnyWorkflowDefinition } from '@lostgradient/weft';
+ *
+ * const greet = workflow({ name: 'greet' }).execute(async function* (_ctx, input: string) {
+ *   return `Hello, ${input}`;
+ * });
+ * const definition: AnyWorkflowDefinition = greet;
+ * void definition;
+ * ```
+ */
+export type AnyWorkflowDefinition = {
+    readonly name: string;
+    readonly handler: WorkflowFunction<never> | StepWorkflowFunction<never>;
+};
+/**
+ * Broad activity-definition constraint used by {@link Engine.create} and
+ * `Engine.register`. It models the callable values returned by
+ * {@link activity} so registration keeps colocated retry, timeout, schema,
+ * and middleware metadata attached to the function object.
+ *
+ * @example
+ * ```ts
+ * import { activity, type AnyActivityDefinition } from '@lostgradient/weft';
+ *
+ * const greet = activity({ name: 'greet', execute: async (name: string) => `Hello, ${name}` });
+ * const definition: AnyActivityDefinition = greet;
+ * void definition;
+ * ```
+ */
+export type AnyActivityDefinition = {
+    readonly name: string;
+    readonly execute: ActivityFunction<never>;
+} & ((input: never, context?: ActivityContext) => Promise<unknown>);
+export type WorkflowInput<TRegistry extends object, TName extends string> = TName extends keyof TRegistry ? TRegistry[TName] extends {
+    input: infer TInput;
+} ? TInput : unknown : unknown;
+export type WorkflowOutput<TRegistry extends object, TName extends string> = TName extends keyof TRegistry ? TRegistry[TName] extends {
+    output: infer TOutput;
+} ? TOutput : unknown : unknown;
+export type ActivityArguments<TActivities extends object, TName extends string> = TName extends keyof TActivities ? TActivities[TName] extends () => unknown ? [] : TActivities[TName] extends (input: infer TInput) => unknown ? [input: TInput] : [input: unknown] : [input?: unknown];
+export type ActivityResult<TActivities extends object, TName extends string> = TName extends keyof TActivities ? TActivities[TName] extends (...arguments_: infer _TArguments) => infer TResult ? Awaited<TResult> : unknown : unknown;
+export type RegisteredActivityFunction<TActivities extends object, TName extends string> = TName extends keyof TActivities ? TActivities[TName] extends () => infer TResult ? () => TResult : TActivities[TName] extends (input: infer TInput) => infer TResult ? (input: TInput) => TResult : never : never;
+type UnionToIntersection<TUnion> = (TUnion extends unknown ? (value: TUnion) => void : never) extends (value: infer TIntersection) => void ? TIntersection : never;
+type MergeDefinitionEntries<TUnion> = [TUnion] extends [never] ? {} : UnionToIntersection<TUnion> extends infer TIntersection ? TIntersection extends object ? TIntersection : {} : {};
+/**
+ * Infer a workflow registry entry from one concrete workflow definition. This
+ * is used by `Engine.register`, where the definition's literal `name`
+ * carries the registry key.
+ *
+ * @example
+ * ```ts
+ * import { workflow, type InferWorkflowEntry } from '@lostgradient/weft';
+ *
+ * const greet = workflow({ name: 'greet' }).execute(async function* (_ctx, input: string) {
+ *   return `Hello, ${input}`;
+ * });
+ * type GreetWorkflow = InferWorkflowEntry<typeof greet>;
+ * const input: GreetWorkflow['greet']['input'] = 'Ada';
+ * void input;
+ * ```
+ */
+export type InferWorkflowEntry<TDefinition extends AnyWorkflowDefinition> = TDefinition extends WorkflowDefinition<infer TInput, infer TOutput, infer TName extends string> ? {
+    [Name in TName]: {
+        input: TInput;
+        output: TOutput;
+    };
+} : never;
+type InferWorkflowEntryForKey<TName extends string, TDefinition extends AnyWorkflowDefinition> = TDefinition extends WorkflowDefinition<infer TInput, infer TOutput> ? {
+    [Name in TName]: {
+        input: TInput;
+        output: TOutput;
+    };
+} : never;
+/**
+ * Infer a workflow registry from a definition map. Map keys are the source of
+ * truth for `Engine.create`, and runtime creation validates each key against
+ * `definition.name` before registration.
+ *
+ * @example
+ * ```ts
+ * import { workflow, type InferWorkflowEntries } from '@lostgradient/weft';
+ *
+ * const greet = workflow({ name: 'greet' }).execute(async function* (_ctx, input: string) {
+ *   return `Hello, ${input}`;
+ * });
+ * type Workflows = InferWorkflowEntries<{ greet: typeof greet }>;
+ * const output: Workflows['greet']['output'] = 'Hello, Ada';
+ * void output;
+ * ```
+ */
+export type InferWorkflowEntries<TDefinitions extends Record<string, AnyWorkflowDefinition>> = [
+    keyof TDefinitions & string
+] extends [never] ? {} : MergeDefinitionEntries<{
+    [Name in keyof TDefinitions & string]: InferWorkflowEntryForKey<Name, TDefinitions[Name]>;
+}[keyof TDefinitions & string]>;
+type ActivityDefinitionFunction<TInput, TOutput> = [TInput] extends [void] ? () => Promise<Awaited<TOutput>> : (input: TInput) => Promise<Awaited<TOutput>>;
+type ActivityEntryForDefinition<TName extends string, TInput, TOutput> = Record<TName, ActivityDefinitionFunction<TInput, TOutput>>;
+/**
+ * Infer an activity registry entry from one concrete activity definition.
+ * The signature intentionally routes through {@link ActivityArguments} and
+ * {@link ActivityResult} so zero-input activities remain zero-argument
+ * entries instead of widening to optional-input functions.
+ *
+ * @example
+ * ```ts
+ * import { activity, type InferActivityEntry } from '@lostgradient/weft';
+ *
+ * const ping = activity({ name: 'ping', execute: async () => 'pong' });
+ * type PingActivity = InferActivityEntry<typeof ping>;
+ * const run: PingActivity['ping'] = async () => 'pong';
+ * void run;
+ * ```
+ */
+export type InferActivityEntry<TDefinition extends AnyActivityDefinition> = TDefinition extends ActivityDefinition<infer TInput, infer TOutput, infer TName extends string> ? {
+    [Name in TName]: (...arguments_: ActivityArguments<ActivityEntryForDefinition<Name, TInput, TOutput>, Name>) => Promise<Awaited<ActivityResult<ActivityEntryForDefinition<Name, TInput, TOutput>, Name>>>;
+} : never;
+type InferActivityEntryForKey<TName extends string, TDefinition extends AnyActivityDefinition> = TDefinition extends ActivityDefinition<infer TInput, infer TOutput> ? {
+    [Name in TName]: (...arguments_: ActivityArguments<ActivityEntryForDefinition<Name, TInput, TOutput>, Name>) => Promise<Awaited<ActivityResult<ActivityEntryForDefinition<Name, TInput, TOutput>, Name>>>;
+} : never;
+/**
+ * Infer an activity registry from a definition map. Map keys are the source of
+ * truth for `Engine.create`, and runtime creation validates each key against
+ * `definition.name` before registration.
+ *
+ * @example
+ * ```ts
+ * import { activity, type InferActivityEntries } from '@lostgradient/weft';
+ *
+ * const greet = activity({ name: 'greet', execute: async (name: string) => `Hello, ${name}` });
+ * type Activities = InferActivityEntries<{ greet: typeof greet }>;
+ * const run: Activities['greet'] = async (name) => `Hello, ${name}`;
+ * void run;
+ * ```
+ */
+export type InferActivityEntries<TDefinitions extends Record<string, AnyActivityDefinition>> = [
+    keyof TDefinitions & string
+] extends [never] ? {} : MergeDefinitionEntries<{
+    [Name in keyof TDefinitions & string]: InferActivityEntryForKey<Name, TDefinitions[Name]>;
+}[keyof TDefinitions & string]>;
+export {};

package/dist/core/types/workflow-registry.d.ts

@@ -0,0 +1,31 @@
+import type { DefinitionSchema } from './definition-schema.ts';
+import type { SearchAttributeSchema } from './search-attributes.ts';
+/**
+ * Read-only metadata exposed by the engine for a registered workflow type.
+ *
+ * @example
+ * ```ts
+ * import { Engine, type RegisteredWorkflowDefinition } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * const definition: RegisteredWorkflowDefinition | undefined = engine.getWorkflowDefinition('greet');
+ *
+ * void definition;
+ * ```
+ */
+export interface RegisteredWorkflowDefinition<TInput = unknown, TOutput = unknown> {
+    /** Registered workflow type name. */
+    type: string;
+    /** Current registration version. */
+    version: string;
+    /** User-facing grouping tags for catalog and documentation surfaces. */
+    tags: ReadonlyArray<string>;
+    /** User-facing description for catalog, code generation, and tool surfaces. */
+    description?: string;
+    /** Optional input schema metadata for introspection; core execution does not validate input against it. */
+    inputSchema?: DefinitionSchema<unknown, TInput>;
+    /** Optional output schema metadata for introspection; core execution does not validate output against it. */
+    outputSchema?: DefinitionSchema<unknown, TOutput>;
+    /** Optional search attribute schema used for indexing and runtime validation. */
+    searchAttributes?: SearchAttributeSchema;
+}

package/dist/core/types.d.ts

@@ -0,0 +1,26 @@
+export * from './types/activity.ts';
+export * from './types/archive-adapter.ts';
+export * from './types/bulk.ts';
+export * from './types/checkpoint.ts';
+export * from './types/constants.ts';
+export * from './types/definition-schema-to-json.ts';
+export * from './types/definition-schema.ts';
+export * from './types/history-policy.ts';
+export * from './types/identity.ts';
+export * from './types/message-handles.ts';
+export * from './types/options.ts';
+export * from './types/payload-size-policy.ts';
+export * from './types/retry-retention.ts';
+export * from './types/reviews.ts';
+export * from './types/schedules.ts';
+export * from './types/search-attributes.ts';
+export * from './types/serializer.ts';
+export * from './types/standard-schema-validate.ts';
+export * from './types/state.ts';
+export * from './types/workflow-builder-helpers.ts';
+export * from './types/workflow-builder-runtime.ts';
+export * from './types/workflow-builder.ts';
+export * from './types/workflow-context.ts';
+export * from './types/workflow-function.ts';
+export * from './types/workflow-registries.ts';
+export * from './types/workflow-registry.ts';

package/dist/core/types.js

@@ -0,0 +1,26 @@
+export * from "./types/activity.js";
+export * from "./types/archive-adapter.js";
+export * from "./types/bulk.js";
+export * from "./types/checkpoint.js";
+export * from "./types/constants.js";
+export * from "./types/definition-schema-to-json.js";
+export * from "./types/definition-schema.js";
+export * from "./types/history-policy.js";
+export * from "./types/identity.js";
+export * from "./types/message-handles.js";
+export * from "./types/options.js";
+export * from "./types/payload-size-policy.js";
+export * from "./types/retry-retention.js";
+export * from "./types/reviews.js";
+export * from "./types/schedules.js";
+export * from "./types/search-attributes.js";
+export * from "./types/serializer.js";
+export * from "./types/standard-schema-validate.js";
+export * from "./types/state.js";
+export * from "./types/workflow-builder-helpers.js";
+export * from "./types/workflow-builder-runtime.js";
+export * from "./types/workflow-builder.js";
+export * from "./types/workflow-context.js";
+export * from "./types/workflow-function.js";
+export * from "./types/workflow-registries.js";
+export * from "./types/workflow-registry.js";