@lostgradient/weft 0.13.0 → 0.14.0

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/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[];
 }>;
 /**

package/dist/diagnostics/validate.js

@@ -24,14 +24,11 @@ function checkStatefulWithoutCompensator(workflowType, activity) {
 }
 export function validateRegistrations(registrations, activities = []) {
   const issues = [], workflowTypes = Object.keys(registrations);
-  for (const activity of activities) {
-    const retryIssue = checkUnboundedRetry("(standalone)", activity);
-    if (retryIssue)
-      issues.push(retryIssue);
-    const compensatorIssue = checkStatefulWithoutCompensator("(standalone)", activity);
-    if (compensatorIssue)
-      issues.push(compensatorIssue);
-  }
+  for (const definition of Object.values(registrations))
+    for (const activity of workflowActivities(definition))
+      appendActivityIssues(issues, definition.name, activity);
+  for (const activity of activities)
+    appendActivityIssues(issues, "(standalone)", activity);
   const hasErrors = issues.some((i) => i.severity === "error");
   return {
     workflowCount: workflowTypes.length,
@@ -39,26 +36,91 @@ export function validateRegistrations(registrations, activities = []) {
     valid: !hasErrors
   };
 }
+function appendActivityIssues(issues, workflowType, activity) {
+  const retryIssue = checkUnboundedRetry(workflowType, activity);
+  if (retryIssue)
+    issues.push(retryIssue);
+  const compensatorIssue = checkStatefulWithoutCompensator(workflowType, activity);
+  if (compensatorIssue)
+    issues.push(compensatorIssue);
+}
+function workflowActivities(definition) {
+  if (!("activities" in definition) || !isObject(definition.activities))
+    return [];
+  return Object.values(definition.activities).filter(isActivityDefinition);
+}
 function collectFromExports(entries, registrations, activities, options) {
   for (const [key, value] of entries)
-    if (isWorkflowRegistration(value)) {
-      if (options.allowOverwrite || !(key in registrations))
-        registrations[key] = value;
-    } else if (isActivityDefinition(value)) {
-      if (options.allowOverwrite || !activities.includes(value))
-        activities.push(value);
-    }
+    collectExport(key, value, registrations, activities, options);
+}
+function collectExport(key, value, registrations, activities, options) {
+  if (isWorkflowDefinition(value)) {
+    if (options.allowOverwrite || !Object.hasOwn(registrations, value.name))
+      registrations[value.name] = value;
+    return;
+  }
+  if (isActivityDefinition(value)) {
+    if (options.allowOverwrite || !activities.includes(value))
+      activities.push(value);
+    return;
+  }
+  if (!isObject(value))
+    return;
+  if (options.depth === 0 && isDefinitionMap(value)) {
+    collectFromExports(Object.entries(value), registrations, activities, {
+      ...options,
+      depth: options.depth + 1
+    });
+    return;
+  }
+  assertNotRemovedWorkflowShape(key, value);
 }
 export async function loadRegistrationsFromModule(modulePath) {
-  const mod = await import(resolve(process.cwd(), modulePath)), registrations = {}, activities = [], defaultExport = mod.default;
-  if (defaultExport !== null && typeof defaultExport === "object")
-    collectFromExports(Object.entries(defaultExport), registrations, activities, { allowOverwrite: !0 });
+  const mod = await import(resolve(process.cwd(), modulePath)), registrations = Object.create(null), activities = [], defaultExport = mod.default;
+  if (defaultExport !== void 0)
+    collectFromExports([["default", defaultExport]], registrations, activities, {
+      allowOverwrite: !0,
+      depth: 0
+    });
   const namedEntries = Object.entries(mod).filter(([key]) => key !== "default");
-  collectFromExports(namedEntries, registrations, activities, { allowOverwrite: !1 });
+  collectFromExports(namedEntries, registrations, activities, {
+    allowOverwrite: !1,
+    depth: 0
+  });
   return { registrations, activities };
 }
-function isWorkflowRegistration(value) {
-  return typeof value === "object" && value !== null && "handler" in value && typeof value.handler === "function";
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isRemovedWorkflowShape(value) {
+  if (!isObject(value) || !Object.hasOwn(value, "handler"))
+    return !1;
+  const handler = value.handler;
+  if (typeof handler !== "function")
+    return !1;
+  const functionKind = Object.prototype.toString.call(handler);
+  if (functionKind === "[object AsyncGeneratorFunction]")
+    return !0;
+  if ([
+    "version",
+    "description",
+    "tags",
+    "inputSchema",
+    "outputSchema",
+    "searchAttributes"
+  ].some((key) => Object.hasOwn(value, key)))
+    return !0;
+  return functionKind === "[object Function]" && Object.keys(value).length === 1;
+}
+function assertNotRemovedWorkflowShape(exportName, value) {
+  if (isRemovedWorkflowShape(value))
+    throw TypeError(`Workflow export "${exportName}" must be a builder-produced workflow definition with its own name. Create it with \`workflow({ name }).execute(handler)\`.`);
+}
+function isDefinitionMap(value) {
+  return Object.values(value).some((entry) => isWorkflowDefinition(entry) || isActivityDefinition(entry) || isRemovedWorkflowShape(entry));
+}
+function isWorkflowDefinition(value) {
+  return isObject(value) && typeof value.name === "string" && "handler" in value && typeof value.handler === "function";
 }
 function isActivityDefinition(value) {
   if (value === null || typeof value !== "object" && typeof value !== "function")

package/dist/diagnostics/version-check.d.ts

@@ -7,9 +7,9 @@
  *
  * @module diagnostics/version-check
  */
+import type { WorkflowDefinition } from '../core/types.ts';
 import type { Storage } from '../storage/interface.ts';
 import type { VersionCheckReport } from './types.ts';
-import type { WorkflowRegistration } from './validate.ts';
 /**
  * Scans active (running and pending) workflows in `storage`, groups them by
  * type, and compares stored workflow versions against currently registered
@@ -31,4 +31,4 @@ import type { WorkflowRegistration } from './validate.ts';
  * console.log(report.overallVerdict); // 'safe'
  * ```
  */
-export declare function runVersionCheck(storage: Storage, registrations: Record<string, WorkflowRegistration>): Promise<VersionCheckReport>;
+export declare function runVersionCheck(storage: Storage, registrations: Record<string, WorkflowDefinition>): Promise<VersionCheckReport>;

package/dist/http.js

@@ -1,2 +1,2 @@
-function N(F){let G=[];for(let J=0;J<F.length;J+=512)G.push(String.fromCharCode(...F.subarray(J,J+512)));return btoa(G.join(""))}function B(F){let G=atob(F),J=new Uint8Array(G.length);for(let Q=0;Q<G.length;Q+=1)J[Q]=G.charCodeAt(Q);return J}function q(F){return typeof F==="object"&&F!==null&&!Array.isArray(F)}async function j(F,G){return await F.get(G)!==null}async function*X(F,G,J){for await(let[Q]of F.scan(G,J))yield Q}async function _(F,G){let J=0;for await(let Q of X(F,G))J++;return J}async function H(F,G){let J=[];for await(let Q of X(F,G))J.push({type:"delete",key:Q});if(J.length===0)return 0;return await F.batch(J),J.length}async function L(F,G,J){let Q=[];for await(let Z of X(F,G,J))Q.push({type:"delete",key:Z});if(Q.length===0)return 0;return await F.batch(Q),Q.length}function R(F,G,J){if(!F.capabilities()[G])throw Error(`Feature "${J}" requires storage capability "${G}", but this storage backend does not provide it.`)}var D=1e4;class C extends Error{code="StorageBatchOperationLimitExceededError";cap=D;count;target;constructor(F,G){super(`${F} count ${G} exceeds MAX_BATCH_OPERATIONS (${D}).`);this.name="StorageBatchOperationLimitExceededError",this.target=F,this.count=G}}function M(F,G){if(G>D)throw new C(F,G)}function T(F){return F.length>0?F.slice(0,-1)+String.fromCharCode(F.charCodeAt(F.length-1)+1):"ÿ"}function o(F,G={}){if(G.gt!==void 0&&F<=G.gt)return!1;if(G.gte!==void 0&&F<G.gte)return!1;if(G.lt!==void 0&&F>=G.lt)return!1;if(G.lte!==void 0&&F>G.lte)return!1;return!0}function e(F,G){if(F===null||G===null)return F===G;if(F.byteLength!==G.byteLength)return!1;for(let J=0;J<F.byteLength;J++)if(F[J]!==G[J])return!1;return!0}async function P(F,G){if(F.has)return F.has(G);return j(F,G)}function K(F,G,J){if(F.keys)return F.keys(G,J);return X(F,G,J)}async function S(F,G){if(F.count)return F.count(G);return _(F,G)}async function O(F,G){if(F.deletePrefix)return F.deletePrefix(G);return H(F,G)}async function b(F,G,J){if(M("conditionalBatch conditions",G.length),M("conditionalBatch operations",J.length),R(F,"conditionalBatch","storageConditionalBatch"),!F.conditionalBatch)throw Error("This storage backend reports conditionalBatch capability but does not implement the conditionalBatch() method.");return F.conditionalBatch(G,J)}function g(F){if(F===void 0)return;if(typeof F!=="number"||!Number.isInteger(F)||F<0)throw Error("deleteRange limit must be a finite non-negative integer");return F===0?0:F}function V(F){let G={},J=!1;for(let Z of["gt","gte","lt","lte"]){let $=F[Z];if($===void 0)continue;if(typeof $!=="string")throw Error("deleteRange bounds must be strings");G[Z]=$,J=!0}if(!J)throw Error("deleteRange requires at least one of gt/gte/lt/lte; use deletePrefix to delete a whole prefix");let Q=g(F.limit);if(Q!==void 0)G.limit=Q;return G}async function v(F,G,J){let Q=V(J);if(F.deleteRange)return F.deleteRange(G,Q);return L(F,G,Q)}function y(F,G){let J={key:F,open:!1};if(G.gte!==void 0&&G.gte>J.key)J.key=G.gte,J.open=!1;if(G.gt!==void 0&&G.gt>=J.key)J.key=G.gt,J.open=!0;return J}function c(F,G){let J={key:T(F),open:!0};if(G.lt!==void 0&&G.lt<=J.key)J.key=G.lt,J.open=!0;if(G.lte!==void 0&&G.lte<J.key)J.key=G.lte,J.open=!1;return J}function QF(F,G){let J=y(F,G),Q=c(F,G);if(J.key>Q.key||J.key===Q.key&&(J.open||Q.open))return null;return{lower:J,upper:Q}}function E(F){return F.replaceAll(/:+$/g,"")}function I(F,G){let J=E(F),Q=E(G);if(J.length===0)return Q;if(Q.length===0)return J;return`${J}:${Q}`}class W{#G;#J;constructor(F,G){this.#G=F,this.#J=E(G)}#F(F){if(this.#J.length===0)return F;return F.length===0?`${this.#J}:`:`${this.#J}:${F}`}#Q(F){if(this.#J.length===0)return F;return F.slice(this.#J.length+1)}#Z(F={}){let G={};if(F.limit!==void 0)G.limit=F.limit;if(F.reverse!==void 0)G.reverse=F.reverse;if(F.gt!==void 0)G.gt=this.#F(F.gt);if(F.gte!==void 0)G.gte=this.#F(F.gte);if(F.lt!==void 0)G.lt=this.#F(F.lt);if(F.lte!==void 0)G.lte=this.#F(F.lte);return G}#M(F){let G={};if(F.limit!==void 0)G.limit=F.limit;if(F.gt!==void 0)G.gt=this.#F(F.gt);if(F.gte!==void 0)G.gte=this.#F(F.gte);if(F.lt!==void 0)G.lt=this.#F(F.lt);if(F.lte!==void 0)G.lte=this.#F(F.lte);return G}capabilities(){return this.#G.capabilities()}scoped(F){return new W(this.#G,I(this.#J,F))}async get(F){return this.#G.get(this.#F(F))}async put(F,G){await this.#G.put(this.#F(F),G)}async delete(F){await this.#G.delete(this.#F(F))}async*scan(F,G){for await(let[J,Q]of this.#G.scan(this.#F(F),this.#Z(G)))yield[this.#Q(J),Q]}async batch(F){M("batch operations",F.length),await this.#G.batch(F.map((G)=>{if(G.type==="put")return{type:"put",key:this.#F(G.key),value:G.value};return{type:"delete",key:this.#F(G.key)}}))}async conditionalBatch(F,G){return b(this.#G,F.map((J)=>({key:this.#F(J.key),expectedValue:J.expectedValue})),G.map((J)=>{if(J.type==="put")return{type:"put",key:this.#F(J.key),value:J.value};return{type:"delete",key:this.#F(J.key)}}))}async has(F){return P(this.#G,this.#F(F))}async deletePrefix(F){return O(this.#G,this.#F(F))}async deleteRange(F,G){let J=this.#M(V(G));return v(this.#G,this.#F(F),J)}async*keys(F,G){for await(let J of K(this.#G,this.#F(F),this.#Z(G)))yield this.#Q(J)}async count(F){return S(this.#G,this.#F(F))}[Symbol.dispose](){this.#G[Symbol.dispose]()}}function h(F,G){return new W(F,G)}var u=67108864;function m(F){if(F.type==="put")return{type:"put",key:F.key,value:N(F.value)};return{type:"delete",key:F.key}}function k(F){return{key:F.key,expectedValue:F.expectedValue===null?null:N(F.expectedValue)}}function w(F){if(!q(F)||typeof F.key!=="string"||typeof F.value!=="string")throw Error("HTTPStorage scan response contained an invalid NDJSON entry.");return{key:F.key,value:F.value}}function f(F){if(!q(F)||typeof F.applied!=="boolean")throw Error('HTTPStorage conditional batch response must include a boolean "applied" field.');return F.applied}function Y(F,G,J){if(J!==void 0)F.searchParams.set(G,String(J))}function l(F){if(F.trim().length===0)return null;let G=w(JSON.parse(F));return[G.key,B(G.value)]}function d(F){if(F>u)throw Error("HTTPStorage scan response exceeded the maximum allowed size.")}async function*p(F){if(F.body===null)return;let G=F.body.getReader(),J=new TextDecoder,Q="",Z=0,$=!1;try{while(!0){let{done:U,value:z}=await G.read();if(U){$=!0;break}Z+=z.byteLength,d(Z),Q+=J.decode(z,{stream:!0});let A=Q.split(`
-`);Q=A.pop()??"";for(let x of A)yield x}if(Q+=J.decode(),Q.length>0)yield Q}finally{try{if(!$)await G.cancel()}catch{}G.releaseLock()}}class a{#G;#J;#F;constructor(F){this.#G=F.baseUrl instanceof URL?F.baseUrl:new URL(F.baseUrl),this.#J={...F.headers},this.#F=F.remoteConditionalBatch??!1}capabilities(){return{persistence:"remote",readAfterWrite:"eventual",scanConsistency:"best-effort",atomicBatch:!0,conditionalBatch:this.#F,boundedRangeDelete:!1}}#Q(F){let G=this.#G.href.endsWith("/")?this.#G.href:`${this.#G.href}/`;return new URL(F.replace(/^\/+/,""),G)}#Z(F){return this.#Q(`/v1/storage/${encodeURIComponent(F)}`)}#M(F,G){let J=this.#Q("/v1/storage");return J.searchParams.set("prefix",F),Y(J,"limit",G.limit),Y(J,"reverse",G.reverse),Y(J,"gt",G.gt),Y(J,"gte",G.gte),Y(J,"lt",G.lt),Y(J,"lte",G.lte),J}async#$(F,G={},J=[]){let Q=new Headers(this.#J);for(let[$,U]of new Headers(G.headers).entries())Q.set($,U);let Z=await fetch(F,{...G,headers:Q});if(!Z.ok&&!J.includes(Z.status))throw Error(`HTTPStorage request failed: ${G.method??"GET"} ${F.pathname} returned ${String(Z.status)}.`);return Z}async get(F){let G=await this.#$(this.#Z(F),{method:"GET"},[404]);if(G.status===404)return null;return new Uint8Array(await G.arrayBuffer())}async put(F,G){await this.#$(this.#Z(F),{method:"PUT",headers:{"content-type":"application/octet-stream"},body:new Blob([G])})}async delete(F){await this.#$(this.#Z(F),{method:"DELETE"})}async*scan(F,G={}){let J=await this.#$(this.#M(F,G),{method:"GET",headers:{accept:"application/x-ndjson"}});for await(let Q of p(J)){let Z=l(Q);if(Z!==null)yield Z}}async batch(F){M("batch operations",F.length),await this.#$(this.#Q("/v1/storage/-/batch"),{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({operations:F.map(m)})})}async conditionalBatch(F,G){M("conditionalBatch conditions",F.length),M("conditionalBatch operations",G.length);let J=await this.#$(this.#Q("/v1/storage/-/conditional-batch"),{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({conditions:F.map(k),operations:G.map(m)})});return f(await J.json())}has(F){return j(this,F)}async*keys(F,G){yield*X(this,F,G)}count(F){return _(this,F)}deletePrefix(F){return H(this,F)}deleteRange(F,G){return L(this,F,V(G))}scoped(F){return h(this,F)}[Symbol.dispose](){}}export{a as HTTPStorage};
+async function*R(F,G){if(F.body===null)return;let J=F.body.getReader(),Q=new TextDecoder,Z="",$=0,j=!1;try{while(!0){let{done:y,value:z}=await J.read();if(y){j=!0;break}if($+=z.byteLength,$>G.maximumBytes)throw G.sizeLimitError();Z+=Q.decode(z,{stream:!0});let A=Z.split(`
+`);Z=A.pop()??"";for(let g of A)yield g}if(Z+=Q.decode(),Z.length>0)yield Z}finally{if(!j)try{await J.cancel()}catch{}J.releaseLock()}}function N(F){let G=[];for(let J=0;J<F.length;J+=512)G.push(String.fromCharCode(...F.subarray(J,J+512)));return btoa(G.join(""))}function B(F){let G=atob(F),J=new Uint8Array(G.length);for(let Q=0;Q<G.length;Q+=1)J[Q]=G.charCodeAt(Q);return J}function q(F){return typeof F==="object"&&F!==null&&!Array.isArray(F)}async function _(F,G){return await F.get(G)!==null}async function*X(F,G,J){for await(let[Q]of F.scan(G,J))yield Q}async function H(F,G){let J=0;for await(let Q of X(F,G))J++;return J}async function L(F,G){let J=[];for await(let Q of X(F,G))J.push({type:"delete",key:Q});if(J.length===0)return 0;return await F.batch(J),J.length}async function U(F,G,J){let Q=[];for await(let Z of X(F,G,J))Q.push({type:"delete",key:Z});if(Q.length===0)return 0;return await F.batch(Q),Q.length}function C(F,G,J){if(!F.capabilities()[G])throw Error(`Feature "${J}" requires storage capability "${G}", but this storage backend does not provide it.`)}var D=1e4;class T extends Error{code="StorageBatchOperationLimitExceededError";cap=D;count;target;constructor(F,G){super(`${F} count ${G} exceeds MAX_BATCH_OPERATIONS (${D}).`);this.name="StorageBatchOperationLimitExceededError",this.target=F,this.count=G}}function M(F,G){if(G>D)throw new T(F,G)}function S(F){return F.length>0?F.slice(0,-1)+String.fromCharCode(F.charCodeAt(F.length-1)+1):"ÿ"}function e(F,G={}){if(G.gt!==void 0&&F<=G.gt)return!1;if(G.gte!==void 0&&F<G.gte)return!1;if(G.lt!==void 0&&F>=G.lt)return!1;if(G.lte!==void 0&&F>G.lte)return!1;return!0}function FF(F,G){if(F===null||G===null)return F===G;if(F.byteLength!==G.byteLength)return!1;for(let J=0;J<F.byteLength;J++)if(F[J]!==G[J])return!1;return!0}async function K(F,G){if(F.has)return F.has(G);return _(F,G)}function P(F,G,J){if(F.keys)return F.keys(G,J);return X(F,G,J)}async function O(F,G){if(F.count)return F.count(G);return H(F,G)}async function b(F,G){if(F.deletePrefix)return F.deletePrefix(G);return L(F,G)}async function v(F,G,J){if(M("conditionalBatch conditions",G.length),M("conditionalBatch operations",J.length),C(F,"conditionalBatch","storageConditionalBatch"),!F.conditionalBatch)throw Error("This storage backend reports conditionalBatch capability but does not implement the conditionalBatch() method.");return F.conditionalBatch(G,J)}function c(F){if(F===void 0)return;if(typeof F!=="number"||!Number.isInteger(F)||F<0)throw Error("deleteRange limit must be a finite non-negative integer");return F===0?0:F}function V(F){let G={},J=!1;for(let Z of["gt","gte","lt","lte"]){let $=F[Z];if($===void 0)continue;if(typeof $!=="string")throw Error("deleteRange bounds must be strings");G[Z]=$,J=!0}if(!J)throw Error("deleteRange requires at least one of gt/gte/lt/lte; use deletePrefix to delete a whole prefix");let Q=c(F.limit);if(Q!==void 0)G.limit=Q;return G}async function h(F,G,J){let Q=V(J);if(F.deleteRange)return F.deleteRange(G,Q);return U(F,G,Q)}function I(F,G){let J={key:F,open:!1};if(G.gte!==void 0&&G.gte>J.key)J.key=G.gte,J.open=!1;if(G.gt!==void 0&&G.gt>=J.key)J.key=G.gt,J.open=!0;return J}function u(F,G){let J={key:S(F),open:!0};if(G.lt!==void 0&&G.lt<=J.key)J.key=G.lt,J.open=!0;if(G.lte!==void 0&&G.lte<J.key)J.key=G.lte,J.open=!1;return J}function ZF(F,G){let J=I(F,G),Q=u(F,G);if(J.key>Q.key||J.key===Q.key&&(J.open||Q.open))return null;return{lower:J,upper:Q}}function E(F){return F.replaceAll(/:+$/g,"")}function k(F,G){let J=E(F),Q=E(G);if(J.length===0)return Q;if(Q.length===0)return J;return`${J}:${Q}`}class W{#G;#J;constructor(F,G){this.#G=F,this.#J=E(G)}#F(F){if(this.#J.length===0)return F;return F.length===0?`${this.#J}:`:`${this.#J}:${F}`}#Q(F){if(this.#J.length===0)return F;return F.slice(this.#J.length+1)}#Z(F={}){let G={};if(F.limit!==void 0)G.limit=F.limit;if(F.reverse!==void 0)G.reverse=F.reverse;if(F.gt!==void 0)G.gt=this.#F(F.gt);if(F.gte!==void 0)G.gte=this.#F(F.gte);if(F.lt!==void 0)G.lt=this.#F(F.lt);if(F.lte!==void 0)G.lte=this.#F(F.lte);return G}#M(F){let G={};if(F.limit!==void 0)G.limit=F.limit;if(F.gt!==void 0)G.gt=this.#F(F.gt);if(F.gte!==void 0)G.gte=this.#F(F.gte);if(F.lt!==void 0)G.lt=this.#F(F.lt);if(F.lte!==void 0)G.lte=this.#F(F.lte);return G}capabilities(){return this.#G.capabilities()}scoped(F){return new W(this.#G,k(this.#J,F))}async get(F){return this.#G.get(this.#F(F))}async put(F,G){await this.#G.put(this.#F(F),G)}async delete(F){await this.#G.delete(this.#F(F))}async*scan(F,G){for await(let[J,Q]of this.#G.scan(this.#F(F),this.#Z(G)))yield[this.#Q(J),Q]}async batch(F){M("batch operations",F.length),await this.#G.batch(F.map((G)=>{if(G.type==="put")return{type:"put",key:this.#F(G.key),value:G.value};return{type:"delete",key:this.#F(G.key)}}))}async conditionalBatch(F,G){return v(this.#G,F.map((J)=>({key:this.#F(J.key),expectedValue:J.expectedValue})),G.map((J)=>{if(J.type==="put")return{type:"put",key:this.#F(J.key),value:J.value};return{type:"delete",key:this.#F(J.key)}}))}async has(F){return K(this.#G,this.#F(F))}async deletePrefix(F){return b(this.#G,this.#F(F))}async deleteRange(F,G){let J=this.#M(V(G));return h(this.#G,this.#F(F),J)}async*keys(F,G){for await(let J of P(this.#G,this.#F(F),this.#Z(G)))yield this.#Q(J)}async count(F){return O(this.#G,this.#F(F))}[Symbol.dispose](){this.#G[Symbol.dispose]()}}function m(F,G){return new W(F,G)}var w=67108864;function x(F){if(F.type==="put")return{type:"put",key:F.key,value:N(F.value)};return{type:"delete",key:F.key}}function f(F){return{key:F.key,expectedValue:F.expectedValue===null?null:N(F.expectedValue)}}function d(F){if(!q(F)||typeof F.key!=="string"||typeof F.value!=="string")throw Error("HTTPStorage scan response contained an invalid NDJSON entry.");return{key:F.key,value:F.value}}function l(F){if(!q(F)||typeof F.applied!=="boolean")throw Error('HTTPStorage conditional batch response must include a boolean "applied" field.');return F.applied}function Y(F,G,J){if(J!==void 0)F.searchParams.set(G,String(J))}function p(F){if(F.trim().length===0)return null;let G=d(JSON.parse(F));return[G.key,B(G.value)]}class a{#G;#J;#F;constructor(F){this.#G=F.baseUrl instanceof URL?F.baseUrl:new URL(F.baseUrl),this.#J={...F.headers},this.#F=F.remoteConditionalBatch??!1}capabilities(){return{persistence:"remote",readAfterWrite:"eventual",scanConsistency:"best-effort",atomicBatch:!0,conditionalBatch:this.#F,boundedRangeDelete:!1}}#Q(F){let G=this.#G.href.endsWith("/")?this.#G.href:`${this.#G.href}/`;return new URL(F.replace(/^\/+/,""),G)}#Z(F){return this.#Q(`/v1/storage/${encodeURIComponent(F)}`)}#M(F,G){let J=this.#Q("/v1/storage");return J.searchParams.set("prefix",F),Y(J,"limit",G.limit),Y(J,"reverse",G.reverse),Y(J,"gt",G.gt),Y(J,"gte",G.gte),Y(J,"lt",G.lt),Y(J,"lte",G.lte),J}async#$(F,G={},J=[]){let Q=new Headers(this.#J);for(let[$,j]of new Headers(G.headers).entries())Q.set($,j);let Z=await fetch(F,{...G,headers:Q});if(!Z.ok&&!J.includes(Z.status))throw Error(`HTTPStorage request failed: ${G.method??"GET"} ${F.pathname} returned ${String(Z.status)}.`);return Z}async get(F){let G=await this.#$(this.#Z(F),{method:"GET"},[404]);if(G.status===404)return null;return new Uint8Array(await G.arrayBuffer())}async put(F,G){await this.#$(this.#Z(F),{method:"PUT",headers:{"content-type":"application/octet-stream"},body:new Blob([G])})}async delete(F){await this.#$(this.#Z(F),{method:"DELETE"})}async*scan(F,G={}){let J=await this.#$(this.#M(F,G),{method:"GET",headers:{accept:"application/x-ndjson"}});for await(let Q of R(J,{maximumBytes:w,sizeLimitError:()=>Error("HTTPStorage scan response exceeded the maximum allowed size.")})){let Z=p(Q);if(Z!==null)yield Z}}async batch(F){M("batch operations",F.length),await this.#$(this.#Q("/v1/storage/-/batch"),{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({operations:F.map(x)})})}async conditionalBatch(F,G){M("conditionalBatch conditions",F.length),M("conditionalBatch operations",G.length);let J=await this.#$(this.#Q("/v1/storage/-/conditional-batch"),{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({conditions:F.map(f),operations:G.map(x)})});return l(await J.json())}has(F){return _(this,F)}async*keys(F,G){yield*X(this,F,G)}count(F){return H(this,F)}deletePrefix(F){return L(this,F)}deleteRange(F,G){return U(this,F,V(G))}scoped(F){return m(this,F)}[Symbol.dispose](){}}export{a as HTTPStorage};

package/dist/server/openapi-error-responses.js

@@ -10,20 +10,6 @@ export const ERROR_SCHEMA = {
       type: "string",
       description: "Fine-grained public Weft error code when one is available"
     },
-    missingTypes: {
-      type: "array",
-      items: { type: "string" },
-      description: "Established recovery-conflict field; also present under data"
-    },
-    missingWorkflowCount: {
-      type: "integer",
-      minimum: 0,
-      description: "Established recovery-conflict field; also present under data"
-    },
-    samplesTruncated: {
-      type: "boolean",
-      description: "Established recovery-conflict field; also present under data"
-    },
     data: {
       type: "object",
       description: "Audited fault-specific context; omitted when no fields are safe to expose",

package/dist/server/operation-catalog/index.d.ts

@@ -8,7 +8,7 @@
  *
  * @module server/operation-catalog
  */
-export type { FaultCode } from '../operation-fault.ts';
+export type { FaultCode } from '../../core/fault-code.ts';
 export { catalogActivities, catalogActivity } from './activity-adapter.ts';
 export type { CatalogActivityDefinition } from './activity-adapter.ts';
 export { DISPATCH_ALLOWLIST } from './dispatch-allowlist.ts';

package/dist/server/operation-catalog/raise-fault.d.ts

@@ -3,7 +3,8 @@
  *
  * @module server/operation-catalog/raise-fault
  */
-import type { FaultCode, OperationFault } from '../operation-fault.ts';
+import type { FaultCode } from '../../core/fault-code.ts';
+import type { OperationFault } from '../operation-fault.ts';
 import type { ErasedOperation } from './types.ts';
 /**
  * Fault codes that every operation can raise through the shared pipeline

package/dist/server/operation-catalog/types.d.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
+import type { FaultCode } from '../../core/fault-code.ts';
 import type { AccessPolicy } from '../authorization.ts';
-import type { FaultCode, OperationFault, TransportKind } from '../operation-fault.ts';
+import type { OperationFault, TransportKind } from '../operation-fault.ts';
 import type { Principal } from '../principal.ts';
 /**
  * Regex for the canonical `weft.<segment>(.<segment>)+` operation-name form.

package/dist/server/operation-fault.d.ts

@@ -36,7 +36,6 @@
  */
 import type { FaultCode } from '../core/fault-code.ts';
 import { type WeftErrorCode } from '../core/weft-error.ts';
-export type { FaultCode };
 /** Transport identifiers as seen by `executeOperation`. */
 export type TransportKind = 'http-rest' | 'jsonRpcHttp' | 'jsonRpcWebSocket' | 'jsonRpcStdio';
 /** A flattened zod issue, kept loose so we don't pin a zod version here. */
@@ -170,10 +169,8 @@ export type RestFaultBody = {
  * `{ "error": "Internal server error" }`, regardless of response overrides.
  */
 export declare function shapeOperationFaultAsJson(fault: OperationFault, options?: RestFaultResponseOptions): Response;
-/** Canonical flat REST response used by bindings and route-dispatch fallback. */
+/** Canonical REST response used by bindings and route-dispatch fallback. */
 export declare function shapeRestFaultAsJson(fault: OperationFault, options?: RestFaultResponseOptions): Response;
-/** Build the audited body for bespoke REST shapers that retain extra legacy fields. */
-export declare function shapeRestFaultBody(fault: OperationFault, message?: string): RestFaultBody;
 /**
  * JSON-RPC error code for each fault. Reserved codes (-32700..-32603) keep
  * the spec meanings (`InvalidParams`, `MethodNotFound`); Weft domain codes

package/dist/server/operation-fault.js

@@ -61,7 +61,7 @@ export function shapeRestFaultAsJson(fault, options = {}) {
     headers: { "Content-Type": "application/json" }
   });
 }
-export function shapeRestFaultBody(fault, message) {
+function shapeRestFaultBody(fault, message) {
   if (fault.code === "EngineFailure")
     return { error: "Internal server error" };
   const error = message ?? fault.message, weftCode = weftCodeFromFaultData(fault.data), data = restDataFromFault(fault), body = { error };

package/dist/server/operation-registry.d.ts

@@ -17,9 +17,9 @@
  *     cast required at the registry boundary.
  */
 import type { z } from 'zod';
+import type { FaultCode } from '../core/fault-code.ts';
 import type { AccessPolicy } from './authorization.ts';
 import type { AuthorizationDecision, McpToolMetadata, OperationContext, OperationDefinition, OperationInvocationResult, ParameterizedAccessHint, TransportAvailability, UnknownKeyPolicy } from './operation-catalog/types.ts';
-import type { FaultCode } from './operation-fault.ts';
 export { isValidOperationName, validateOperationName } from './operation-catalog.ts';
 /**
  * Input shape for `defineOperation`. Mirrors `OperationDefinition` but

package/dist/server/operations/list-reviews.js

@@ -1,29 +1,12 @@
 import { z } from "zod";
+import { reviewListEntrySchema } from "../../core/review/index.js";
 import { shapeOperationFaultAsJson } from "../operation-fault.js";
 import { defineOperation } from "../operation-registry.js";
 const reviewStatusSchema = z.enum(["pending", "completed"]), listReviewsInput = z.object({
   status: reviewStatusSchema.optional(),
   workflowId: z.string().min(1).optional(),
   reviewType: z.string().min(1).optional()
-}), pendingReviewEntrySchema = z.object({
-  status: z.literal("pending"),
-  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()
-}), completedReviewEntrySchema = pendingReviewEntrySchema.extend({
-  status: z.literal("completed"),
-  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()
-}), reviewListEntrySchema = z.union([pendingReviewEntrySchema, completedReviewEntrySchema]), listReviewsOutput = z.object({
+}), listReviewsOutput = z.object({
   items: z.array(reviewListEntrySchema)
 });
 export const listReviewsOperation = defineOperation({

package/dist/server/operations/recover-all.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { WorkflowTypeNotRegisteredForRecoveryError } from "../../core/engine.js";
-import { shapeRestFaultBody } from "../operation-fault.js";
 import { defineOperation } from "../operation-registry.js";
 import { shapeRestFault } from "./operation-helpers.js";
 const recoverAllInput = z.object({}), recoverAllOutput = z.object({
@@ -54,13 +53,5 @@ export const recoverAllOperation = defineOperation({
 function shapeRecoverAllFault(fault) {
   if (fault.code !== "Conflict" || fault.data.missingTypes === void 0)
     return shapeRestFault(fault);
-  return new Response(JSON.stringify({
-    ...shapeRestFaultBody(fault, "workflow_type_not_registered_for_recovery"),
-    missingTypes: fault.data.missingTypes,
-    missingWorkflowCount: fault.data.missingWorkflowCount,
-    samplesTruncated: fault.data.samplesTruncated
-  }), {
-    status: 409,
-    headers: { "Content-Type": "application/json" }
-  });
+  return shapeRestFault(fault, { message: "workflow_type_not_registered_for_recovery" });
 }

package/dist/server/operations/single-workflow-control-operation.d.ts

@@ -1,7 +1,8 @@
 import type { z } from 'zod';
 import type { Engine } from '../../core/engine.ts';
+import type { FaultCode } from '../../core/fault-code.ts';
 import type { OperationDefinition } from '../operation-catalog.ts';
-import type { FaultCode, OperationFault } from '../operation-fault.ts';
+import type { OperationFault } from '../operation-fault.ts';
 type SingleWorkflowControlInput = {
     readonly workflowId: string;
 };

package/dist/storage/bounded-ndjson-response.d.ts

@@ -0,0 +1,5 @@
+export type BoundedNdjsonResponseOptions = {
+    readonly maximumBytes: number;
+    readonly sizeLimitError: () => Error;
+};
+export declare function readBoundedNdjsonResponse(response: Response, options: BoundedNdjsonResponseOptions): AsyncIterable<string>;

package/dist/storage/bounded-ndjson-response.js

@@ -0,0 +1,33 @@
+export async function* readBoundedNdjsonResponse(response, options) {
+  if (response.body === null)
+    return;
+  const reader = response.body.getReader(), decoder = new TextDecoder;
+  let bufferedText = "", bytesRead = 0, reachedEndOfStream = !1;
+  try {
+    while (!0) {
+      const { done, value } = await reader.read();
+      if (done) {
+        reachedEndOfStream = !0;
+        break;
+      }
+      bytesRead += value.byteLength;
+      if (bytesRead > options.maximumBytes)
+        throw options.sizeLimitError();
+      bufferedText += decoder.decode(value, { stream: !0 });
+      const lines = bufferedText.split(`
+`);
+      bufferedText = lines.pop() ?? "";
+      for (const line of lines)
+        yield line;
+    }
+    bufferedText += decoder.decode();
+    if (bufferedText.length > 0)
+      yield bufferedText;
+  } finally {
+    if (!reachedEndOfStream)
+      try {
+        await reader.cancel();
+      } catch {}
+    reader.releaseLock();
+  }
+}