@lostgradient/weft 0.13.0 → 0.15.0

package/dist/core/context/parallel-operations.js

@@ -6,13 +6,6 @@ import {
   isParallelOperationCacheEntry
 } from "./parallel-cache-entry.js";
 import { captureCallerStack } from "./validation.js";
-
-export {
-  assertValidParallelOperationCacheEntry,
-  BranchTopologyChangedError,
-  createParallelOperationCacheEntry,
-  isParallelOperationCacheEntry
-};
 function reconstructAllResult(entry) {
   return entry.branches.map((slot) => {
     if (slot.status !== "fulfilled")

package/dist/core/engine/callback-checkpoint-persistence.d.ts

@@ -1,3 +1,5 @@
 import type { ContextOperationRequest } from '../context.ts';
+import { type PersistCheckpointCallbacks } from './checkpoint-io.ts';
 import type { Engine } from './index.ts';
+export declare function createCheckpointPersistenceCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): PersistCheckpointCallbacks;
 export declare function persistCheckpointForDataOperation<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, workflowId: string, operation: ContextOperationRequest): Promise<void>;

package/dist/core/engine/callback-checkpoint-persistence.js

@@ -9,8 +9,8 @@ import {
 import { getInternals } from "./internals.js";
 import { swallowPromiseRejection } from "./strategy-helpers.js";
 import { terminateWorkflow } from "./termination.js";
-export function persistCheckpointForDataOperation(engine, workflowId, operation) {
-  return persistCheckpoint(getInternals(engine), workflowId, operation, void 0, {
+export function createCheckpointPersistenceCallbacks(engine) {
+  return {
     appendTimelineBatchOperations: (id, checkpointOperation, step, timestamp, operations) => appendTimelineBatchOperations(getInternals(engine), id, checkpointOperation, step, timestamp, operations),
     swallowPromiseRejection: (promise) => {
       swallowPromiseRejection(promise);
@@ -21,5 +21,8 @@ export function persistCheckpointForDataOperation(engine, workflowId, operation)
       engine.dispatchEvent(event);
     },
     enforceHistoryCircuitBreaker: (id) => terminateWorkflow(getInternals(engine), id, "timed-out", createTerminationCallbacks(engine), HISTORY_CIRCUIT_BREAKER_REASON)
-  }, { timeline: "preserve-pending" });
+  };
+}
+export function persistCheckpointForDataOperation(engine, workflowId, operation) {
+  return persistCheckpoint(getInternals(engine), workflowId, operation, void 0, createCheckpointPersistenceCallbacks(engine), { timeline: "preserve-pending" });
 }

package/dist/core/engine/callback-creators.js

@@ -1,6 +1,5 @@
 import { KEYS } from "../../storage/interface.js";
-import { HISTORY_CIRCUIT_BREAKER_REASON } from "../types.js";
-import { validateAttributeValueSizes } from "./attributes-tags.js";
+import { createCheckpointPersistenceCallbacks } from "./callback-checkpoint-persistence.js";
 import {
   createConstraintCallbacks,
   createLifecycleCallbacks,
@@ -8,12 +7,7 @@ import {
   registerEnsureRetentionSweepInterval
 } from "./callback-creators-core.js";
 import { createOperationRouterCallbacks } from "./callback-creators-router.js";
-import {
-  appendTimelineBatchOperations,
-  persistCheckpoint,
-  pruneCheckpointHistory,
-  validateDevelopmentCheckpoint
-} from "./checkpoint-io.js";
+import { persistCheckpoint, validateDevelopmentCheckpoint } from "./checkpoint-io.js";
 import { evaluateConstraints } from "./constraints.js";
 import {
   getParkedWorkflowResumeDisposition,
@@ -30,8 +24,7 @@ import {
 } from "./retention.js";
 import { hasBufferedSignal } from "./signals.js";
 import { loadWorkflowState, runSerializedWorkflowStateWrite } from "./storage-io.js";
-import { swallowPromiseRejection } from "./strategy-helpers.js";
-import { cleanupWaiters, terminateWorkflow } from "./termination.js";
+import { cleanupWaiters } from "./termination.js";
 export { createUpdateCallbacks } from "./callback-creators-bundles.js";
 export {
   createBroadcastCallbacks,
@@ -64,18 +57,7 @@ export function createInlineParkingCallbacks(engine) {
   };
 }
 export function persistCheckpointForEngine(engine, workflowId, operation, workerCheckpointBytes) {
-  return persistCheckpoint(getInternals(engine), workflowId, operation, workerCheckpointBytes, {
-    appendTimelineBatchOperations: (id, checkpointOperation, step, timestamp, operations) => appendTimelineBatchOperations(getInternals(engine), id, checkpointOperation, step, timestamp, operations),
-    swallowPromiseRejection: (promise) => {
-      swallowPromiseRejection(promise);
-    },
-    validateAttributeValueSizes,
-    pruneCheckpointHistory: (id, step) => pruneCheckpointHistory(getInternals(engine), id, step),
-    dispatchEvent: (event) => {
-      engine.dispatchEvent(event);
-    },
-    enforceHistoryCircuitBreaker: (id) => terminateWorkflow(getInternals(engine), id, "timed-out", createTerminationCallbacks(engine), HISTORY_CIRCUIT_BREAKER_REASON)
-  });
+  return persistCheckpoint(getInternals(engine), workflowId, operation, workerCheckpointBytes, createCheckpointPersistenceCallbacks(engine));
 }
 function ensureRetentionSweepIntervalForEngine(engine) {
   ensureRetentionSweepInterval(getInternals(engine), {

package/dist/core/engine/checkpoint-io.d.ts

@@ -9,7 +9,7 @@ type PendingTimelineEntryValue = {
 export type PersistCheckpointOptions = {
     timeline?: 'record-operation' | 'preserve-pending';
 };
-type PersistCheckpointCallbacks = {
+export type PersistCheckpointCallbacks = {
     appendTimelineBatchOperations: (workflowId: string, operation: ContextOperationRequest, step: number, timestamp: number, operations: BatchOperation[]) => PendingTimelineEntryValue;
     swallowPromiseRejection: (promise: Promise<void>) => void;
     validateAttributeValueSizes: (attributes: Record<string, SearchAttributeValue>) => void;

package/dist/core/engine/operations-coordination.js

@@ -1,6 +1,6 @@
 import {
   isParallelOperationCacheEntry
-} from "../context/parallel-operations.js";
+} from "../context/parallel-cache-entry.js";
 import {
   executeRunAllBranches,
   executeRunAllBranchesSettled

package/dist/core/engine/parallel-dispatch.d.ts

@@ -25,7 +25,7 @@
  * checkpoint-write machinery — see the `parallel-execution.md` guide
  * for the precise durability contract.
  */
-import type { ParallelBranchSlot, ParallelOperationCacheEntry } from '../context/parallel-operations.ts';
+import type { ParallelBranchSlot, ParallelOperationCacheEntry } from '../context/parallel-cache-entry.ts';
 export type ParallelDispatchResult = {
     /** Final slot table — every entry is `fulfilled` or `rejected`. */
     slots: ParallelBranchSlot[];

package/dist/core/engine/parallel-dispatch.js

@@ -1,4 +1,4 @@
-import { createParallelOperationCacheEntry } from "../context/parallel-operations.js";
+import { createParallelOperationCacheEntry } from "../context/parallel-cache-entry.js";
 export function createFirstRejectionCapture() {
   return { hasFirstError: !1, firstError: void 0 };
 }

package/dist/core/engine/review-list-entries.d.ts

@@ -1,4 +1,4 @@
-import type { HumanReviewResult, ReviewRequest } from '../review/index.ts';
+import { type HumanReviewResult, type ReviewRequest } from '../review/index.ts';
 import type { CompletedReviewEntry, PendingReviewEntry } from '../types.ts';
 export declare function toPendingReviewEntry(review: ReviewRequest): PendingReviewEntry;
 export declare function parseStoredReviewRequest(value: Uint8Array): ReviewRequest | null;

package/dist/core/engine/review-list-entries.js

@@ -1,32 +1,8 @@
-import { z } from "zod";
 import { decode } from "../codec.js";
-const storedReviewRequestSchema = z.object({
-  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()
-}), persistedCompletedReviewEntrySchema = z.object({
-  status: z.literal("completed"),
-  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(),
-  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()
-});
+import {
+  completedReviewEntrySchema,
+  reviewRequestSchema
+} from "../review/index.js";
 function assignWhenDefined(target, key, value) {
   if (value !== void 0)
     target[key] = value;
@@ -58,7 +34,7 @@ export function parseStoredReviewRequest(value) {
   } catch {
     return null;
   }
-  const parsedReview = storedReviewRequestSchema.safeParse(decodedValue);
+  const parsedReview = reviewRequestSchema.safeParse(decodedValue);
   if (!parsedReview.success)
     return null;
   return normalizeStoredReviewRequest(parsedReview.data);
@@ -110,7 +86,7 @@ export function parseCompletedReviewEntry(value) {
   } catch {
     return null;
   }
-  const parsedReview = persistedCompletedReviewEntrySchema.safeParse(decodedValue);
+  const parsedReview = completedReviewEntrySchema.safeParse(decodedValue);
   if (!parsedReview.success)
     return null;
   return normalizeCompletedReviewEntry(parsedReview.data);

package/dist/core/engine/schedules.js

@@ -100,7 +100,10 @@ async function hasCurrentScheduleTimer(internals, state) {
 }
 export function toScheduleSummary(state) {
   const { input: _input, ...summary } = state;
-  return { ...summary, queuedRuns: summary.queuedRuns.map((queuedRun) => ({ ...queuedRun })) };
+  return {
+    ...summary,
+    queuedRuns: summary.queuedRuns.map((queuedRun) => ({ ...queuedRun }))
+  };
 }
 export async function pauseSchedule(internals, scheduleId) {
   const normalizedScheduleId = coerceScheduleId(scheduleId, "scheduleId"), state = await requireScheduleState(internals, normalizedScheduleId);

package/dist/core/engine/timeline-coordinator-detail.d.ts

@@ -1,5 +1,5 @@
 import type { ContextOperationRequest } from '../context.ts';
-import type { ParallelBranchSlot } from '../context/parallel-operations.ts';
+import type { ParallelBranchSlot } from '../context/parallel-cache-entry.ts';
 import type { WorkflowTimelineOperationDetail } from '../types.ts';
 import type { EngineInternals } from './internals.ts';
 export declare function operationTimelineDetail(operation: ContextOperationRequest, index: number, outcome: WorkflowTimelineOperationDetail['outcome'], options?: {

package/dist/core/inline-execution-strategy.js

@@ -128,11 +128,17 @@ export class InlineExecutionStrategy {
     this[Symbol.dispose]();
   }
   #driveGenerator(workflowId, generator, lastResult) {
+    return this.#advanceGenerator(workflowId, () => generator.next(lastResult), void 0);
+  }
+  #throwIntoGenerator(workflowId, generator, error, operationFailureCategory) {
+    return this.#advanceGenerator(workflowId, () => generator.throw(error), operationFailureCategory);
+  }
+  #advanceGenerator(workflowId, advance, fallbackFailureCategory) {
     return this.#trackWorkflowAdvance(workflowId, (async () => {
       try {
         if (this.#abortControllers.get(workflowId)?.signal.aborted)
           return;
-        const iterationResult = await generator.next(lastResult);
+        const iterationResult = await advance();
         if (iterationResult.done) {
           this.#cleanup(workflowId, {
             preserveTrackedAdvance: !0,
@@ -161,7 +167,7 @@ export class InlineExecutionStrategy {
           type: "failed",
           workflowId,
           error: error instanceof Error ? error.message : String(error),
-          failureCategory: classifyErrorAsFailureCategory(error, {
+          failureCategory: fallbackFailureCategory ?? classifyErrorAsFailureCategory(error, {
             defaultErrorCategory: "application"
           })
         };
@@ -171,50 +177,6 @@ export class InlineExecutionStrategy {
       }
     })());
   }
-  #throwIntoGenerator(workflowId, generator, error, operationFailureCategory) {
-    return this.#trackWorkflowAdvance(workflowId, (async () => {
-      try {
-        if (this.#abortControllers.get(workflowId)?.signal.aborted)
-          return;
-        const iterationResult = await generator.throw(error);
-        if (iterationResult.done) {
-          this.#cleanup(workflowId, {
-            preserveTrackedAdvance: !0,
-            preserveTrackedTurn: !0
-          });
-          this.#emit({
-            type: "completed",
-            workflowId,
-            result: iterationResult.value
-          });
-          return;
-        }
-        const operation = iterationResult.value;
-        this.#emit({
-          type: "checkpoint",
-          workflowId,
-          checkpoint: new ArrayBuffer(0),
-          operationRequest: operation
-        });
-      } catch (innerError) {
-        this.#cleanup(workflowId, {
-          preserveTrackedAdvance: !0,
-          preserveTrackedTurn: !0
-        });
-        const failedMessage = {
-          type: "failed",
-          workflowId,
-          error: innerError instanceof Error ? innerError.message : String(innerError),
-          failureCategory: operationFailureCategory ?? classifyErrorAsFailureCategory(innerError, {
-            defaultErrorCategory: "application"
-          })
-        };
-        if (innerError instanceof Error && innerError.stack !== void 0)
-          failedMessage.errorStack = innerError.stack;
-        this.#emit(failedMessage);
-      }
-    })());
-  }
   #trackWorkflowAdvance(workflowId, pendingAdvance) {
     const trackedAdvance = pendingAdvance.finally(() => {
       if (this.#workflowAdvances.get(workflowId) === trackedAdvance)

package/dist/core/list-filter-validation.d.ts

@@ -12,6 +12,7 @@ import { z } from 'zod';
 import { isFailureCategory } from './failure-categories.ts';
 import type { FailureCategory, WorkflowStatus } from './types/identity.ts';
 import type { ListFilter } from './types/list-options.ts';
+import { type ValidationIssue } from './validation-issues.ts';
 import { WeftError } from './weft-error.ts';
 /**
  * Concrete object schema for {@link ListFilter}. Supports `.omit()` and
@@ -56,11 +57,7 @@ export declare const listFilterObjectSchema: z.ZodObject<{
     failureCategory: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<FailureCategory, unknown, z.core.$ZodTypeInternals<FailureCategory, unknown>>, z.ZodArray<z.ZodType<FailureCategory, unknown, z.core.$ZodTypeInternals<FailureCategory, unknown>>>]>>;
 }, z.core.$strict>;
 /** A flattened Zod issue suitable for cross-transport serialization. */
-export type FilterValidationIssue = {
-    readonly path: ReadonlyArray<string | number>;
-    readonly message: string;
-    readonly code: string;
-};
+export type FilterValidationIssue = ValidationIssue;
 /**
  * Thrown by {@link normalizeListFilter} when the input fails validation.
  * Carries flattened Zod issues so transport adapters can map directly to the

package/dist/core/list-filter-validation.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { FAILURE_CATEGORIES, isFailureCategory } from "./failure-categories.js";
+import { flattenZodIssue } from "./validation-issues.js";
 import { WeftError } from "./weft-error.js";
 const WORKFLOW_STATUSES = [
   "pending",
@@ -48,15 +49,6 @@ export const listFilterObjectSchema = z.object({
   executionDeadline: timeRangeSchema.optional(),
   failureCategory: z.union([failureCategorySchema, z.array(failureCategorySchema).min(1)]).optional()
 }).strict();
-function flattenIssue(issue) {
-  const path = [];
-  for (const segment of issue.path)
-    if (typeof segment === "string" || typeof segment === "number")
-      path.push(segment);
-    else
-      path.push(String(segment));
-  return { path, message: issue.message, code: issue.code };
-}
 
 export class ListFilterValidationError extends WeftError {
   issues;
@@ -72,7 +64,7 @@ export class ListFilterValidationError extends WeftError {
 export function normalizeListFilter(input) {
   const result = listFilterObjectSchema.safeParse(input ?? {});
   if (!result.success)
-    throw new ListFilterValidationError(result.error.issues.map(flattenIssue));
+    throw new ListFilterValidationError(result.error.issues.map(flattenZodIssue));
   if (result.data.parentWorkflowExecutionToken !== void 0 && result.data.parentWorkflowId === void 0)
     throw new ListFilterValidationError([
       {

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';
 /**
@@ -51,6 +52,92 @@ export interface ReviewDecisionRecord {
     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

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/schedules.d.ts

@@ -181,14 +181,13 @@ export type ScheduleDefinition<TInput = unknown> = ScheduleSpec & {
  */
 export declare function schedule<TInput>(definition: ScheduleDefinition<TInput>): ScheduleDefinition<TInput>;
 /**
- * Full persisted state of a recurring schedule. Returned by `engine.getSchedule(id)`.
- * Use {@link ScheduleSummary} (returned by list operations and `engine.getSchedule()`)
- * for the lightweight variant — it omits `input` to keep payloads small.
+ * Metadata shared by persisted schedule state and lightweight schedule summaries.
+ * Persisted state and summaries extend this contract so metadata cannot drift
+ * between durable records and public lightweight responses.
  */
-export interface ScheduleState {
+export interface ScheduleMetadata {
     id: string;
     workflowType: string;
-    input: unknown;
     /** Human-readable operator description stored with this schedule. */
     description?: string;
     /**
@@ -220,38 +219,21 @@ export interface ScheduleState {
     /** Ordered durable occurrences waiting behind `currentWorkflowId`. */
     queuedRuns: ScheduleQueuedRun[];
 }
+/**
+ * Full persisted state of a recurring schedule. Returned by `engine.getSchedule(id)`.
+ * Use {@link ScheduleSummary} (returned by list operations and `engine.getSchedule()`)
+ * for the lightweight variant — it omits `input` to keep payloads small.
+ */
+export interface ScheduleState extends ScheduleMetadata {
+    input: unknown;
+}
 /**
  * Lightweight summary of a recurring schedule returned by list operations.
  * Contains cron expression, status, timing metadata, and the ID of the
  * currently running workflow (if any). For the full record including the
  * `input`, use {@link ScheduleState}.
  */
-export interface ScheduleSummary {
-    id: string;
-    workflowType: string;
-    /** Human-readable operator description stored with this schedule. */
-    description?: string;
-    /** Cron expression for cron-based schedules; absent for interval schedules. */
-    cronExpression?: string;
-    /** Interval period in milliseconds for interval-based schedules; absent for cron schedules. */
-    intervalMs?: number;
-    status: ScheduleStatus;
-    overlap: ScheduleOverlapPolicy;
-    backfill: boolean;
-    /** Normalized deterministic jitter window in milliseconds. */
-    jitterMs?: number;
-    createdAt: number;
-    updatedAt: number;
-    /** Most recent occurrence that started a scheduled workflow. */
-    lastFireAt?: number;
-    /** Most recent occurrence skipped because a non-backfill timer was late. */
-    lastMissedFireAt?: number;
-    /** Lifetime count of occurrences skipped because a non-backfill timer was late. */
-    missedFireCount: number;
-    nextFireAt: number | null;
-    currentWorkflowId?: string;
-    /** Ordered durable occurrences waiting behind `currentWorkflowId`. */
-    queuedRuns: ScheduleQueuedRun[];
+export interface ScheduleSummary extends ScheduleMetadata {
 }
 /**
  * Filter criteria for `engine.listSchedules`. All fields are optional.

package/dist/core/validation-issues.d.ts

@@ -0,0 +1,13 @@
+import type { ZodIssue } from 'zod';
+/** A flattened Zod issue suitable for cross-transport serialization. */
+export type ValidationIssue = {
+    readonly path: ReadonlyArray<string | number>;
+    readonly message: string;
+    readonly code: string;
+};
+/**
+ * Convert a Zod issue into the stable diagnostic shape used by core validators.
+ * Path segments outside the JSON-friendly string and number forms are rendered
+ * with their string representation, preserving the original issue order.
+ */
+export declare function flattenZodIssue(issue: ZodIssue): ValidationIssue;

package/dist/core/validation-issues.js

@@ -0,0 +1,9 @@
+export function flattenZodIssue(issue) {
+  const path = [];
+  for (const segment of issue.path)
+    if (typeof segment === "string" || typeof segment === "number")
+      path.push(segment);
+    else
+      path.push(String(segment));
+  return { path, message: issue.message, code: issue.code };
+}

package/dist/diagnostics/validate.d.ts

@@ -1,7 +1,7 @@
 /**
  * Design-time workflow validation for `weft validate`.
  *
- * Analyses workflow registrations for common anti-patterns:
+ * Analyses workflow definitions for common anti-patterns:
  *
  * 1. **Unbounded retry policy** — an activity whose `retry.maxAttempts` is
  *    `Infinity` (or the workflow registration specifies `retry.maxAttempts`
@@ -21,27 +21,7 @@
  *
  * @module diagnostics/validate
  */
-import type { ConstraintDefinition } from '../core/constraint.ts';
-import type { ActivityDefinition, DefinitionSchema, RetentionPolicy, SearchAttributeSchema, WorkflowFunction } from '../core/types.ts';
-/**
- * Loosely-typed workflow registration shape used only by the `weft validate`
- * and `weft schedule` CLIs when loading workflow modules from disk. This is
- * intentionally separate from the public `WorkflowDefinition` type because
- * loaded modules historically export bare `{ handler, ... }` objects that
- * do not carry a `name` field — the registration key comes from the export
- * key, not the object itself.
- */
-export interface WorkflowRegistration<TInput = unknown, TOutput = unknown> {
-    version?: string;
-    description?: string;
-    tags?: ReadonlyArray<string>;
-    inputSchema?: DefinitionSchema<unknown, TInput>;
-    outputSchema?: DefinitionSchema<unknown, TOutput>;
-    handler: WorkflowFunction<TInput, TOutput>;
-    searchAttributes?: SearchAttributeSchema;
-    retention?: RetentionPolicy;
-    constraints?: ConstraintDefinition[];
-}
+import type { ActivityDefinition, WorkflowDefinition } from '../core/types.ts';
 export type ValidationIssueSeverity = 'error' | 'warning';
 export type ValidationIssueCode = 'unbounded-retry' | 'stateful-without-compensator' | 'non-serializable-input';
 export interface ValidationIssue {
@@ -52,7 +32,7 @@ export interface ValidationIssue {
     message: string;
 }
 export interface ValidationReport {
-    /** Total number of workflow registrations scanned. */
+    /** Total number of workflow definitions scanned. */
     workflowCount: number;
     /** All detected issues across all registrations. */
     issues: ValidationIssue[];
@@ -60,16 +40,15 @@ export interface ValidationReport {
     valid: boolean;
 }
 /**
- * Validate a collection of workflow registrations for common anti-patterns.
+ * Validate a collection of workflow definitions for common anti-patterns.
  *
- * @param registrations A record of workflow type name → WorkflowRegistration.
- * @param activities    Optional list of ActivityDefinition objects to check.
- *                      Activities are not reachable from WorkflowRegistration
- *                      alone, so pass them explicitly when available.
+ * @param registrations A record of workflow type name to WorkflowDefinition.
+ * @param activities    Optional standalone ActivityDefinition objects to check
+ *                      in addition to activities embedded in workflow definitions.
  */
-export declare function validateRegistrations(registrations: Record<string, WorkflowRegistration>, activities?: ActivityDefinition[]): ValidationReport;
+export declare function validateRegistrations(registrations: Record<string, WorkflowDefinition>, activities?: ActivityDefinition[]): ValidationReport;
 export declare function loadRegistrationsFromModule(modulePath: string): Promise<{
-    registrations: Record<string, WorkflowRegistration>;
+    registrations: Record<string, WorkflowDefinition>;
     activities: ActivityDefinition[];
 }>;
 /**