@lostgradient/weft 0.12.0 → 0.14.0

package/dist/core/registry-snapshot.js

@@ -49,8 +49,32 @@ function buildWorkflowEntry(definition) {
     entry.description = definition.description;
   if (definition.tags.length > 0)
     entry.tags = [...definition.tags];
+  addWorkflowMessageEntries(entry, definition);
   return entry;
 }
+function addWorkflowMessageEntries(entry, definition) {
+  if (definition.signals !== void 0 && Object.keys(definition.signals).length > 0)
+    entry.signals = buildMessageEntries(definition.type, "signal", definition.signals);
+  if (definition.updates !== void 0 && Object.keys(definition.updates).length > 0)
+    entry.updates = buildMessageEntries(definition.type, "update", definition.updates);
+  if (definition.queries !== void 0 && Object.keys(definition.queries).length > 0)
+    entry.queries = buildMessageEntries(definition.type, "query", definition.queries);
+}
+function buildMessageEntries(workflowType, messageKind, definitions) {
+  const entries = Object.create(null);
+  for (const name of Object.keys(definitions).toSorted()) {
+    const definition = definitions[name];
+    if (definition === void 0)
+      continue;
+    const entry = {}, entityName = `${workflowType}.${messageKind}.${name}`;
+    if (definition.inputSchema !== void 0)
+      entry.inputSchema = convertSchema("workflow", entityName, "inputSchema", definition.inputSchema);
+    if (definition.outputSchema !== void 0)
+      entry.outputSchema = convertSchema("workflow", entityName, "outputSchema", definition.outputSchema);
+    entries[name] = entry;
+  }
+  return entries;
+}
 function buildActivityEntry(metadata) {
   const entry = { queue: metadata.queue };
   if (metadata.inputSchema !== void 0)
@@ -59,6 +83,10 @@ function buildActivityEntry(metadata) {
     entry.outputSchema = convertSchema("activity", metadata.name, "outputSchema", metadata.outputSchema);
   if (metadata.description !== void 0)
     entry.description = metadata.description;
+  if (metadata.retry !== void 0)
+    entry.retry = metadata.retry;
+  if (metadata.timeout !== void 0)
+    entry.timeout = metadata.timeout;
   return entry;
 }
 function convertSchema(entityKind, entityName, field, schema) {

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

@@ -6,6 +6,7 @@
  *
  * @module human-review
  */
+import { z } from 'zod';
 import type { BatchOperation, Storage } from '../../storage/interface.ts';
 import { WeftError } from '../weft-error.ts';
 /**
@@ -43,7 +44,7 @@ export interface ReviewRequest {
  * The `decision` field is the binary outcome; `sectionDecisions` carries
  * per-section verdicts when `allowPartial` is enabled on the request.
  */
-export interface ReviewDecision {
+export interface ReviewDecisionRecord {
     reviewId: string;
     decision: 'approved' | 'rejected' | 'needs-changes';
     reviewer: string;
@@ -51,6 +52,92 @@ export interface ReviewDecision {
     sectionDecisions?: Record<string, 'approved' | 'rejected'>;
     timestamp: number;
 }
+/** Canonical schema for a persisted review request without its storage envelope. */
+export declare const reviewRequestSchema: z.ZodObject<{
+    reviewId: z.ZodString;
+    workflowId: z.ZodString;
+    artifact: z.ZodNonOptional<z.ZodUnknown>;
+    reviewType: z.ZodString;
+    reviewers: z.ZodArray<z.ZodString>;
+    allowPartial: z.ZodBoolean;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    webhookUrl: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+}, z.core.$strip>;
+/** Canonical schema for a pending review entry returned by review list surfaces. */
+export declare const pendingReviewEntrySchema: z.ZodObject<{
+    reviewId: z.ZodString;
+    workflowId: z.ZodString;
+    artifact: z.ZodNonOptional<z.ZodUnknown>;
+    reviewType: z.ZodString;
+    reviewers: z.ZodArray<z.ZodString>;
+    allowPartial: z.ZodBoolean;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    webhookUrl: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    status: z.ZodLiteral<"pending">;
+}, z.core.$strip>;
+/** Canonical schema for a completed review entry returned by review list surfaces. */
+export declare const completedReviewEntrySchema: z.ZodObject<{
+    decision: z.ZodEnum<{
+        approved: "approved";
+        rejected: "rejected";
+        "needs-changes": "needs-changes";
+    }>;
+    reviewer: z.ZodString;
+    feedback: z.ZodOptional<z.ZodString>;
+    sectionDecisions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        approved: "approved";
+        rejected: "rejected";
+    }>>>;
+    timestamp: z.ZodNumber;
+    reviewId: z.ZodString;
+    workflowId: z.ZodString;
+    artifact: z.ZodNonOptional<z.ZodUnknown>;
+    reviewType: z.ZodString;
+    reviewers: z.ZodArray<z.ZodString>;
+    allowPartial: z.ZodBoolean;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    webhookUrl: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    status: z.ZodLiteral<"completed">;
+}, z.core.$strip>;
+/** Canonical schema for the discriminated review list-entry union. */
+export declare const reviewListEntrySchema: z.ZodUnion<readonly [z.ZodObject<{
+    reviewId: z.ZodString;
+    workflowId: z.ZodString;
+    artifact: z.ZodNonOptional<z.ZodUnknown>;
+    reviewType: z.ZodString;
+    reviewers: z.ZodArray<z.ZodString>;
+    allowPartial: z.ZodBoolean;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    webhookUrl: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    status: z.ZodLiteral<"pending">;
+}, z.core.$strip>, z.ZodObject<{
+    decision: z.ZodEnum<{
+        approved: "approved";
+        rejected: "rejected";
+        "needs-changes": "needs-changes";
+    }>;
+    reviewer: z.ZodString;
+    feedback: z.ZodOptional<z.ZodString>;
+    sectionDecisions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        approved: "approved";
+        rejected: "rejected";
+    }>>>;
+    timestamp: z.ZodNumber;
+    reviewId: z.ZodString;
+    workflowId: z.ZodString;
+    artifact: z.ZodNonOptional<z.ZodUnknown>;
+    reviewType: z.ZodString;
+    reviewers: z.ZodArray<z.ZodString>;
+    allowPartial: z.ZodBoolean;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    webhookUrl: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    status: z.ZodLiteral<"completed">;
+}, z.core.$strip>]>;
 /**
  * One step in a {@link ReviewOptions.escalation} chain. Either reassigns the
  * pending review to a new owner (`to`) or auto-decides it (`action`) after
@@ -119,7 +206,7 @@ export interface HumanReviewOptions extends ReviewOptions {
 }
 /**
  * The decision payload returned to the workflow from `ctx.review()`.
- * Alias for {@link ReviewDecision}.
+ * Alias for {@link ReviewDecisionRecord}.
  *
  * @example
  * ```ts
@@ -134,7 +221,7 @@ export interface HumanReviewOptions extends ReviewOptions {
  * void result;
  * ```
  */
-export type HumanReviewResult = ReviewDecision;
+export type HumanReviewResult = ReviewDecisionRecord;
 /**
  * The action returned by {@link ReviewCoordinator.checkEscalations} when an
  * escalation step has fired. Either reassigns the review to a new owner or
@@ -253,7 +340,7 @@ export declare class ReviewCoordinator {
     /** Create a review request and persist it. */
     createReview(workflowId: string, options: ReviewOptions): Promise<ReviewRequest>;
     /** Submit a review decision. */
-    submitDecision(reviewId: string, decision: Omit<ReviewDecision, 'reviewId' | 'timestamp'>): Promise<ReviewDecision>;
+    submitDecision(reviewId: string, decision: Omit<ReviewDecisionRecord, 'reviewId' | 'timestamp'>): Promise<ReviewDecisionRecord>;
     /** Get a pending review. */
     getReview(workflowId: string, reviewId: string): Promise<ReviewRequest | null>;
     /** List pending reviews. */

package/dist/core/review/index.js

@@ -1,7 +1,36 @@
+import { z } from "zod";
 import { KEYS } from "../../storage/interface.js";
 import { decode, encode } from "../codec.js";
 import { WeftError } from "../weft-error.js";
 import { ReviewRequestedEvent } from "./events.js";
+const reviewRequestFields = {
+  reviewId: z.string(),
+  workflowId: z.string(),
+  artifact: z.unknown().nonoptional(),
+  reviewType: z.string(),
+  reviewers: z.array(z.string()),
+  allowPartial: z.boolean(),
+  timeout: z.number().optional(),
+  webhookUrl: z.string().optional(),
+  createdAt: z.number()
+}, reviewDecisionFields = {
+  decision: z.enum(["approved", "rejected", "needs-changes"]),
+  reviewer: z.string(),
+  feedback: z.string().optional(),
+  sectionDecisions: z.record(z.string(), z.enum(["approved", "rejected"])).optional(),
+  timestamp: z.number()
+};
+export const reviewRequestSchema = z.object(reviewRequestFields), pendingReviewEntrySchema = z.object({
+  status: z.literal("pending"),
+  ...reviewRequestFields
+}), completedReviewEntrySchema = z.object({
+  status: z.literal("completed"),
+  ...reviewRequestFields,
+  ...reviewDecisionFields
+}), reviewListEntrySchema = z.union([
+  pendingReviewEntrySchema,
+  completedReviewEntrySchema
+]);
 
 export class ReviewTimeoutError extends WeftError {
   reviewId;

package/dist/core/types/activity.d.ts

@@ -116,16 +116,18 @@ export interface ActivityContext {
      * `client.activity.*` methods).
      *
      * The durable task token is announced on the engine as an
-     * `activity:async-pending` event (listen for it to receive the token).
-     * The token is deterministic and survives engine restart: it is re-minted
-     * identically when the activity replays after recovery.
+     * `activity:async-pending` event and remains discoverable through
+     * `engine.listPendingAsyncActivities(workflowId)` or
+     * `client.activity.listPending(workflowId)`. The token is deterministic and
+     * survives engine restart: it is re-minted identically on recovery.
      *
      * Security: the token is a deterministic identifier, NOT a secret. When the
      * completion endpoint is reachable by untrusted callers, anyone who can infer
      * a workflow id can forge this activity's result or error. Treat the completed
      * value as hostile external input (validate it as you would a signal payload),
-     * and gate the mutating surface with `serve({ auth })` if completions must not
-     * be anonymous.
+     * The transport query requires `workflows:read`; completion and failure require
+     * `workflows:write`. Configure `serve({ auth })` with those scopes before
+     * exposing the routes.
      *
      * `completeAsync()` never returns normally — it throws an internal sentinel
      * that the engine recognizes to park the activity. Call it as the last
@@ -148,6 +150,51 @@ export interface ActivityContext {
      */
     completeAsync(): never;
 }
+/**
+ * Durable metadata for one activity awaiting out-of-band completion.
+ * @example
+ * ```ts
+ * import type { PendingAsyncActivityInfo } from '@lostgradient/weft';
+ * declare const pending: PendingAsyncActivityInfo; console.log(pending.token, pending.activityName);
+ * ```
+ */
+export interface PendingAsyncActivityInfo {
+    readonly token: string;
+    readonly operationId: string;
+    readonly activityName: string;
+    readonly step: number;
+    readonly attempt: number;
+    readonly createdAt: number;
+}
+/**
+ * Bounded cursor options for listing a workflow's pending async activities.
+ * @example
+ * ```ts
+ * import type { PendingAsyncActivityListOptions } from '@lostgradient/weft';
+ * const options: PendingAsyncActivityListOptions = { limit: 25 };
+ * void options;
+ * ```
+ */
+export interface PendingAsyncActivityListOptions {
+    /** Maximum records to inspect for this page. Defaults to 50 and cannot exceed 200. */
+    readonly limit?: number;
+    /** Opaque continuation cursor returned by the previous page. */
+    readonly cursor?: string;
+}
+/**
+ * One deterministic page of pending async activities.
+ * @example
+ * ```ts
+ * import type { PendingAsyncActivityPage } from '@lostgradient/weft';
+ * const page: PendingAsyncActivityPage = { items: [] };
+ * void page;
+ * ```
+ */
+export interface PendingAsyncActivityPage {
+    readonly items: PendingAsyncActivityInfo[];
+    /** Present when another page of durable records may remain. */
+    readonly nextCursor?: string;
+}
 /**
  * Per-invocation overrides when calling an activity from a workflow via
  * `ctx.run(activity, input, options)`. Any field overrides the

package/dist/core/types/bulk.d.ts

@@ -52,6 +52,7 @@ export type BulkOperationPrincipal = {
 export type BulkOperationFilterSummary = {
     status?: WorkflowStatus | WorkflowStatus[];
     type?: string;
+    scheduleId?: string;
     tags?: string[];
     attributes?: Array<{
         key: string;

package/dist/core/types/list-options.d.ts

@@ -43,6 +43,12 @@ export interface ListFilter {
      * ```
      */
     type?: string;
+    /** Match workflow runs launched by this recurring schedule. */
+    scheduleId?: string;
+    /** Match direct child workflows launched by this parent workflow id. */
+    parentWorkflowId?: string;
+    /** Narrow `parentWorkflowId` to one concrete parent run generation. */
+    parentWorkflowExecutionToken?: string;
     /** Match workflows that carry every listed tag. */
     tags?: string[];
     /** Filter on indexed search attributes (equality, string any-of, or range). */

package/dist/core/types/options.d.ts

@@ -446,14 +446,15 @@ export interface EngineOptions<TServices = unknown> {
     resolveWorkflowServices?: (info: WorkflowServicesResolverInfo) => WorkflowServicesResolution<TServices> | Promise<WorkflowServicesResolution<TServices>>;
     /**
      * Optional host sink for `ctx.log` records. When provided, every non-replayed
-     * record from inline workflow execution is routed here (into your pino / winston
-     * / OpenTelemetry stack, etc.) **instead of** the console; when omitted, records
-     * fall back to the matching `console` method, preserving the default behavior.
+     * record from inline and worker workflow execution is routed here (into your
+     * pino / winston / OpenTelemetry stack, etc.) **instead of** the console; when
+     * omitted, records fall back to the matching process console.
      *
      * Engine-scoped infrastructure: set once at construction, never per run. The sink
      * is not invoked for records suppressed during replay, so a recovered run does
-     * not re-emit its replayed prefix. Worker-mode records still log to the worker
-     * process's console — routing them back to the host is tracked separately.
+     * not re-emit its replayed prefix. Weft does not persist these records or expose
+     * a log-history API; the sink is the integration point for retention and remote
+     * log queries.
      */
     onLog?: (record: WorkflowLogRecord) => void;
 }

package/dist/core/types/reviews.d.ts

@@ -1,4 +1,4 @@
-import type { ReviewDecision as CompletedReviewDecision, ReviewRequest } from '../review/index.ts';
+import type { ReviewDecisionRecord, ReviewRequest } from '../review/index.ts';
 /**
  * Outcome of a human review step initiated by `ctx.waitForReview`. Pass as
  * the `decision` field in {@link SubmitReviewOptions} when calling
@@ -125,7 +125,7 @@ export interface PendingReviewEntry extends ReviewRequest {
  * void entry;
  * ```
  */
-export interface CompletedReviewEntry extends CompletedReviewDecision {
+export interface CompletedReviewEntry extends ReviewDecisionRecord {
     status: 'completed';
     workflowId: string;
     artifact: unknown;

package/dist/core/types/schedules.d.ts

@@ -23,6 +23,29 @@ export type ScheduleStatus = 'active' | 'paused' | 'cancelled';
  * ```
  */
 export type ScheduleOverlapPolicy = 'skip' | 'queue' | 'cancel-running' | 'allow';
+/**
+ * One occurrence waiting behind the active run of a `queue` overlap schedule.
+ * `workflowId` is reserved when the occurrence enters the durable queue and is
+ * used when it eventually starts. No workflow record exists for that id until
+ * the queue drains, so `engine.get(workflowId)` returns `null` while it waits.
+ *
+ * @example
+ * ```ts
+ * import type { ScheduleQueuedRun } from '@lostgradient/weft';
+ *
+ * const queuedRun: ScheduleQueuedRun = {
+ *   workflowId: 'daily-report-queued-1',
+ *   queuedAt: Date.now(),
+ * };
+ * void queuedRun;
+ * ```
+ */
+export interface ScheduleQueuedRun {
+    workflowId: string;
+    queuedAt: number;
+    /** Nominal cadence timestamp retained from the occurrence that was queued. */
+    occurrence?: number;
+}
 /**
  * Recurrence specification for a schedule. A schedule fires either on a cron
  * cadence (`{ cron: '0 9 * * *' }`) or at a fixed interval
@@ -95,6 +118,24 @@ export interface ScheduleOptions {
      */
     jitter?: Duration;
 }
+/**
+ * Mutable options accepted when updating an existing schedule. Omitted fields
+ * retain their persisted values. Schedule identity, workflow type, and input
+ * are intentionally excluded.
+ *
+ * @example
+ * ```ts
+ * import { Engine, workflow, type ScheduleUpdateOptions } from '@lostgradient/weft';
+ *
+ * const engine = new Engine();
+ * engine.register(workflow({ name: 'report' }).execute(async function* () { return 'done'; }));
+ * await engine.schedule('report', null, '0 9 * * *', { id: 'daily-report' });
+ * const options: ScheduleUpdateOptions = { overlap: 'queue', jitter: '30s' };
+ * await engine.updateSchedule('daily-report', '30 9 * * *', options);
+ * engine[Symbol.dispose]();
+ * ```
+ */
+export type ScheduleUpdateOptions = Pick<ScheduleOptions, 'description' | 'overlap' | 'backfill' | 'jitter'>;
 /**
  * Declarative recurring schedule definition returned by {@link schedule}. Supply
  * exactly one of `cron` (cron cadence) or `every` (fixed interval).
@@ -176,7 +217,8 @@ export interface ScheduleState {
     missedFireCount: number;
     nextFireAt: number | null;
     currentWorkflowId?: string;
-    queuedRuns: number;
+    /** Ordered durable occurrences waiting behind `currentWorkflowId`. */
+    queuedRuns: ScheduleQueuedRun[];
 }
 /**
  * Lightweight summary of a recurring schedule returned by list operations.
@@ -208,7 +250,8 @@ export interface ScheduleSummary {
     missedFireCount: number;
     nextFireAt: number | null;
     currentWorkflowId?: string;
-    queuedRuns: number;
+    /** Ordered durable occurrences waiting behind `currentWorkflowId`. */
+    queuedRuns: ScheduleQueuedRun[];
 }
 /**
  * Filter criteria for `engine.listSchedules`. All fields are optional.

package/dist/core/types/services-resolution.d.ts

@@ -50,11 +50,11 @@ export interface WorkflowServicesResolverLaunchOptions {
 }
 /**
  * Schedule context passed to {@link EngineOptions.resolveWorkflowServices} for
- * scheduled occurrences. New scheduled runs persist this context with the
- * workflow record, so a fresh-process recovery receives the same schedule id and
- * known occurrence timestamp as the live launch path. Runs from older stores
- * that predate the metadata may omit it, and queue-drained runs may omit
- * `occurrence` because their original grid timestamp was not retained.
+ * scheduled occurrences. Scheduled runs persist this context with the workflow
+ * record, so a fresh-process recovery receives the same schedule id and known
+ * occurrence timestamp as the live launch path. Queue entries retain the
+ * occurrence timestamp through drain; runs from older stores that predate this
+ * metadata may omit the context or occurrence.
  *
  * @example
  * ```ts

package/dist/core/types/state.d.ts

@@ -66,6 +66,10 @@ export interface WorkflowState {
      * tree.
      */
     executionStateOwnerId?: string;
+    /** Immediate parent workflow id for runs launched through `ctx.startChild()`. */
+    parentWorkflowId?: WorkflowId;
+    /** Concrete parent run token, used to distinguish stable-id reuse generations. */
+    parentWorkflowExecutionToken?: string;
     createdAt: number;
     startedAt?: number;
     updatedAt: number;
@@ -76,6 +80,30 @@ export interface WorkflowState {
      * another workflow checkpoint. Absent for workflows started normally.
      */
     forkedFrom?: ForkLineage;
+    /** Immediate terminal run displaced when this run was created with `start-new`. */
+    restartedFrom?: RestartLineage;
+}
+/**
+ * Immediate predecessor recorded when `onTerminalConflict: 'start-new'` reuses
+ * a stable workflow id. The execution token identifies the concrete displaced
+ * run because both runs share the same workflow id.
+ *
+ * @example
+ * ```ts
+ * import type { RestartLineage } from '@lostgradient/weft';
+ *
+ * const lineage: RestartLineage = {
+ *   workflowId: 'nightly-reconciliation',
+ *   workflowExecutionToken: 'prior-run-token',
+ *   replacedAt: Date.now(),
+ * };
+ * void lineage;
+ * ```
+ */
+export interface RestartLineage {
+    workflowId: WorkflowId;
+    workflowExecutionToken?: string;
+    replacedAt: number;
 }
 /**
  * Lineage metadata recorded when a workflow was created by forking another
@@ -92,6 +120,32 @@ export interface ForkLineage {
  * whole workflow. Used in {@link WorkflowTimelineEntry}.
  */
 export type WorkflowTimelineStatus = 'running' | 'completed' | 'failed' | 'cancelled' | 'timed-out';
+/**
+ * Bounded metadata describing one direct operation inside a timeline coordinator.
+ *
+ * @example
+ * ```ts
+ * import type { WorkflowTimelineOperationDetail } from '@lostgradient/weft';
+ *
+ * const winner: WorkflowTimelineOperationDetail = {
+ *   index: 0,
+ *   operationId: 'race:0:0',
+ *   operationType: 'activity',
+ *   operationLabel: 'fetchPrimary',
+ *   outcome: 'won',
+ * };
+ * void winner;
+ * ```
+ */
+export type WorkflowTimelineOperationDetail = {
+    index: number;
+    key?: string;
+    operationId: string;
+    operationType: string;
+    operationLabel: string;
+    outcome: 'fulfilled' | 'rejected' | 'won' | 'lost';
+    errorSummary?: string;
+};
 /**
  * A single chronological entry in a workflow's execution timeline, summarising
  * one operation (activity call, sleep, signal wait, etc.). Returned by
@@ -110,6 +164,16 @@ export type WorkflowTimelineEntry = {
     timestamp: number;
     status: WorkflowTimelineStatus;
     versionTuple?: WorkflowVersionTuple;
+    /** Direct branch metadata for `ctx.all`, `ctx.runAll`, and `ctx.race`. */
+    branches?: WorkflowTimelineOperationDetail[];
+    /** Number of direct branches omitted from `branches` by the durable size bound. */
+    branchesOmitted?: number;
+    /** Ordered direct operations yielded by `ctx.speculate`. */
+    children?: WorkflowTimelineOperationDetail[];
+    /** Number of direct speculative children omitted from `children` by the durable size bound. */
+    childrenOmitted?: number;
+    /** Whether the speculative child context committed or rolled back. */
+    speculationOutcome?: 'committed' | 'rolled-back';
 };
 /**
  * Options accepted by `ctx.state.session(key, options)`.

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

@@ -22,8 +22,9 @@ export type WorkflowLogLevel = 'debug' | 'info' | 'warn' | 'error';
  * fields (`level`, `message`, `workflowId`, `workflowType`, `timestamp`) are
  * engine-owned and always present; caller `attributes` nest under their own key so
  * they can never shadow an envelope field. `timestamp` is wall-clock ms at emit —
- * observability metadata, never checkpointed or replayed. Type a host sink
- * installed via `EngineOptions.onLog` with this record.
+ * observability metadata, never checkpointed or replayed. Weft does not retain
+ * records for later engine/client/transport queries; a host that needs history
+ * persists records received through `EngineOptions.onLog` in its logging system.
  *
  * @example
  * ```ts

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

@@ -0,0 +1,50 @@
+/**
+ * The recurring schedule occurrence that launched a workflow run.
+ *
+ * @example
+ * ```ts
+ * import { type WorkflowScheduleProvenance } from '@lostgradient/weft';
+ *
+ * const provenance: WorkflowScheduleProvenance = {
+ *   scheduleId: 'nightly-cleanup',
+ *   occurrence: Date.UTC(2026, 0, 1),
+ * };
+ * void provenance;
+ * ```
+ */
+export interface WorkflowScheduleProvenance {
+    scheduleId: string;
+    occurrence?: number;
+}
+/**
+ * Durable progress and outcome of a workflow's post-terminal finalizer.
+ *
+ * @example
+ * ```ts
+ * import { type WorkflowFinalizerStatus } from '@lostgradient/weft';
+ *
+ * const finalizer: WorkflowFinalizerStatus = {
+ *   status: 'succeeded',
+ *   attempts: 1,
+ *   completedAt: Date.now(),
+ * };
+ * void finalizer;
+ * ```
+ */
+export type WorkflowFinalizerStatus = {
+    status: 'pending';
+    attempts: number;
+} | {
+    status: 'running';
+    attempts: number;
+    startedAt: number;
+} | {
+    status: 'succeeded';
+    attempts: number;
+    completedAt: number;
+} | {
+    status: 'failed';
+    attempts: number;
+    failedAt: number;
+    error: string;
+};

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

@@ -1,4 +1,5 @@
 import type { DefinitionSchema } from './definition-schema.ts';
+import type { QueryDefinition, SignalDefinition, UpdateDefinition } from './message-handles.ts';
 import type { SearchAttributeSchema } from './search-attributes.ts';
 import type { WorkflowConcurrencyOptions } from './workflow-concurrency.ts';
 /**
@@ -27,6 +28,12 @@ export interface RegisteredWorkflowDefinition<TInput = unknown, TOutput = unknow
     inputSchema?: DefinitionSchema<unknown, TInput>;
     /** Optional output schema metadata for introspection; core execution does not validate output against it. */
     outputSchema?: DefinitionSchema<unknown, TOutput>;
+    /** Statically registered signal definitions keyed by their public names. */
+    signals?: Readonly<Record<string, Readonly<SignalDefinition<unknown>>>>;
+    /** Statically registered update definitions keyed by their public names. */
+    updates?: Readonly<Record<string, Readonly<UpdateDefinition<unknown>>>>;
+    /** Statically registered query definitions keyed by their public names. */
+    queries?: Readonly<Record<string, Readonly<QueryDefinition<unknown>>>>;
     /** Optional search attribute schema used for indexing and runtime validation. */
     searchAttributes?: SearchAttributeSchema;
     /** Optional start admission policy for this workflow type. */

package/dist/core/types.d.ts

@@ -28,6 +28,7 @@ export * from './types/workflow-concurrency.ts';
 export * from './types/workflow-context.ts';
 export * from './types/workflow-function.ts';
 export * from './types/workflow-log.ts';
+export * from './types/workflow-observability.ts';
 export * from './types/workflow-registries.ts';
 export * from './types/workflow-registry.ts';
 export * from './types/workflow-snapshot.ts';

package/dist/core/types.js

@@ -28,6 +28,7 @@ export * from "./types/workflow-concurrency.js";
 export * from "./types/workflow-context.js";
 export * from "./types/workflow-function.js";
 export * from "./types/workflow-log.js";
+export * from "./types/workflow-observability.js";
 export * from "./types/workflow-registries.js";
 export * from "./types/workflow-registry.js";
 export * from "./types/workflow-snapshot.js";