@lostgradient/weft 0.15.0 → 0.17.0

package/dist/server/dashboard-assets.js

@@ -0,0 +1,209 @@
+import * as fileSystem from "node:fs";
+import { isAbsolute, join, relative, resolve as resolvePath, sep } from "node:path";
+import { API_PREFIX, DIRECT_HTTP_ROUTES, ROOT_API_PREFIX } from "./route-model.js";
+function overlapsDashboardPageRoute(prefix, route) {
+  if (route.endsWith("/*")) {
+    const base = route.slice(0, -2);
+    return prefix === base || prefix.startsWith(`${base}/`);
+  }
+  return prefix === route;
+}
+function overlapsWildcardRoute(prefix, route) {
+  return prefix === route || prefix.startsWith(`${route}/`) || route.startsWith(`${prefix}/`);
+}
+function hasInvalidPrefixShape(prefix) {
+  return prefix.length === 0 || prefix === "/" || !prefix.startsWith("/") || prefix.endsWith("/") || ["?", "#", "%", "*", ":", "\\"].some((character) => prefix.includes(character));
+}
+function validateAssetPrefixShape(prefix) {
+  if (hasInvalidPrefixShape(prefix))
+    throw Error("dashboardAssets.prefix must be an absolute path prefix without a trailing slash, wildcard, parameter, query, fragment, percent escape, or backslash");
+  if (prefix.split("/").slice(1).some((segment) => segment.length === 0 || segment === "." || segment === ".."))
+    throw Error("dashboardAssets.prefix must contain only concrete, non-empty path segments");
+  const serializedPathname = new URL(prefix, "http://weft.invalid").pathname;
+  if (serializedPathname !== prefix)
+    throw Error(`dashboardAssets.prefix must round-trip through URL serialization unchanged; ${prefix} serializes as ${serializedPathname}`);
+}
+function validateAssetPrefixReservations(prefix, pageRoutes) {
+  if ([
+    API_PREFIX,
+    ROOT_API_PREFIX,
+    ...DIRECT_HTTP_ROUTES.map(({ path }) => path)
+  ].some((reserved) => overlapsWildcardRoute(prefix, reserved)))
+    throw Error("dashboardAssets.prefix must not overlap the /api, /v1, or direct HTTP route spaces");
+  if (pageRoutes.some((route) => overlapsDashboardPageRoute(prefix, route)))
+    throw Error("dashboardAssets.prefix must not overlap dashboard page routes");
+}
+function validateAssetPrefix(prefix, pageRoutes) {
+  validateAssetPrefixShape(prefix);
+  validateAssetPrefixReservations(prefix, pageRoutes);
+}
+export function resolveDashboardAssets(value, pageRoutes) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw Error("dashboardAssets must be an object with prefix and directory strings");
+  if (!("prefix" in value) || !("directory" in value))
+    throw Error("dashboardAssets.prefix and dashboardAssets.directory must be strings");
+  const { prefix, directory } = value;
+  if (typeof prefix !== "string" || typeof directory !== "string")
+    throw Error("dashboardAssets.prefix and dashboardAssets.directory must be strings");
+  validateAssetPrefix(prefix, pageRoutes);
+  const resolvedDirectory = resolvePath(directory);
+  let directoryStats;
+  try {
+    directoryStats = fileSystem.statSync(resolvedDirectory);
+  } catch {
+    throw Error(`dashboardAssets.directory does not exist: ${directory}`);
+  }
+  if (!directoryStats.isDirectory())
+    throw Error(`dashboardAssets.directory must be a directory: ${directory}`);
+  return { prefix, directory: fileSystem.realpathSync(resolvedDirectory) };
+}
+function isWithinDirectory(directory, path) {
+  const pathRelativeToDirectory = relative(directory, path);
+  return pathRelativeToDirectory.length > 0 && pathRelativeToDirectory !== ".." && !pathRelativeToDirectory.startsWith(`..${sep}`) && !isAbsolute(pathRelativeToDirectory);
+}
+function hasSameFileIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+function resolveAssetPath(directory, prefix, request) {
+  if (request.signal.aborted)
+    return;
+  const rawWildcardPath = new URL(request.url).pathname.slice(prefix.length + 1);
+  let wildcardPath;
+  try {
+    wildcardPath = decodeURIComponent(rawWildcardPath);
+  } catch {
+    return;
+  }
+  if (wildcardPath.length === 0)
+    return;
+  const pathSegments = wildcardPath.split(/[\\/]/);
+  if (pathSegments.some((segment) => segment === ".." || segment.length === 0))
+    return;
+  const assetPath = resolvePath(join(directory, ...pathSegments));
+  if (!isWithinDirectory(directory, assetPath))
+    return;
+  return assetPath;
+}
+function isVerifiedAssetDescriptor(request, directory, canonicalStats, openedStats, postOpenStats, postOpenAssetPath, openedAssetPath) {
+  return !request.signal.aborted && isWithinDirectory(directory, postOpenAssetPath) && (openedAssetPath === void 0 || isWithinDirectory(directory, openedAssetPath)) && canonicalStats.isFile() && openedStats.isFile() && postOpenStats.isFile() && hasSameFileIdentity(openedStats, canonicalStats) && hasSameFileIdentity(openedStats, postOpenStats);
+}
+function resolveOpenedDescriptorPath(descriptor, assetFileSystem) {
+  for (const descriptorPath of [`/proc/self/fd/${descriptor}`, `/dev/fd/${descriptor}`])
+    try {
+      const resolvedPath = assetFileSystem.realpathSync(descriptorPath);
+      if (resolvedPath.startsWith("/proc/self/fd/") || resolvedPath.startsWith("/dev/fd/"))
+        continue;
+      return resolvedPath;
+    } catch {}
+  return;
+}
+function createAssetStream(descriptor, verifiedSize, assetFileSystem) {
+  let closed = !1, cancelled = !1, position = 0, remainingBytes = verifiedSize, inFlightRead;
+  const close = () => {
+    if (!closed) {
+      closed = !0;
+      assetFileSystem.closeSync(descriptor);
+    }
+  };
+  return { stream: new ReadableStream({
+    async pull(controller) {
+      if (cancelled)
+        return;
+      if (remainingBytes === 0) {
+        close();
+        controller.close();
+        return;
+      }
+      const buffer = Buffer.allocUnsafe(Math.min(65536, remainingBytes)), read = assetFileSystem.read(descriptor, buffer, 0, buffer.byteLength, position);
+      inFlightRead = read;
+      try {
+        const bytesRead = await read;
+        if (cancelled) {
+          close();
+          return;
+        }
+        if (bytesRead === 0) {
+          close();
+          controller.error(Error("Dashboard asset ended before its verified content length was read."));
+          return;
+        }
+        const boundedBytesRead = Math.min(bytesRead, remainingBytes);
+        position += boundedBytesRead;
+        remainingBytes -= boundedBytesRead;
+        controller.enqueue(buffer.subarray(0, boundedBytesRead));
+        if (remainingBytes === 0) {
+          close();
+          controller.close();
+        }
+      } catch (error) {
+        close();
+        if (!cancelled)
+          controller.error(error);
+      } finally {
+        if (inFlightRead === read)
+          inFlightRead = void 0;
+      }
+    },
+    async cancel() {
+      cancelled = !0;
+      try {
+        await inFlightRead;
+      } catch {}
+      close();
+    }
+  }), close };
+}
+function readAssetDescriptor(descriptor, buffer, offset, length, position) {
+  return new Promise((_resolve, reject) => {
+    fileSystem.read(descriptor, buffer, offset, length, position, (error, bytesRead) => {
+      if (error)
+        reject(error);
+      else
+        _resolve(bytesRead);
+    });
+  });
+}
+function assetResponse(directory, prefix, request, assetFileSystem) {
+  const assetPath = resolveAssetPath(directory, prefix, request);
+  if (assetPath === void 0)
+    return new Response("Not Found", { status: 404 });
+  let descriptor;
+  try {
+    const realAssetPath = assetFileSystem.realpathSync(assetPath);
+    if (!isWithinDirectory(directory, realAssetPath))
+      return new Response("Not Found", { status: 404 });
+    const canonicalStats = assetFileSystem.statSync(realAssetPath);
+    descriptor = assetFileSystem.openSync(realAssetPath, assetFileSystem.constants.O_RDONLY | assetFileSystem.constants.O_NOFOLLOW | assetFileSystem.constants.O_NONBLOCK);
+    const fileStats = assetFileSystem.fstatSync(descriptor), postOpenAssetPath = assetFileSystem.realpathSync(realAssetPath), postOpenStats = assetFileSystem.statSync(postOpenAssetPath), openedAssetPath = resolveOpenedDescriptorPath(descriptor, assetFileSystem);
+    if (!isVerifiedAssetDescriptor(request, directory, canonicalStats, fileStats, postOpenStats, postOpenAssetPath, openedAssetPath))
+      return new Response("Not Found", { status: 404 });
+    const headers = {
+      "content-length": String(fileStats.size),
+      "content-type": Bun.file(realAssetPath).type
+    };
+    if (request.method === "HEAD")
+      return new Response(null, { headers });
+    const assetStream = createAssetStream(descriptor, fileStats.size, assetFileSystem);
+    try {
+      const response = new Response(assetStream.stream, { headers });
+      descriptor = void 0;
+      return response;
+    } catch {
+      assetStream.close();
+      descriptor = void 0;
+      return new Response("Not Found", { status: 404 });
+    }
+  } catch {
+    return new Response("Not Found", { status: 404 });
+  } finally {
+    if (descriptor !== void 0)
+      assetFileSystem.closeSync(descriptor);
+  }
+}
+export function createDashboardAssetRoute(assets, assetFileSystem) {
+  const fileSystemForAsset = assetFileSystem ?? {
+    ...fileSystem,
+    read: readAssetDescriptor
+  }, handler = (request) => assetResponse(assets.directory, assets.prefix, request, fileSystemForAsset);
+  return { GET: handler, HEAD: handler };
+}

package/dist/server/index.d.ts

@@ -10,11 +10,13 @@ import type { PrometheusExporter } from '../observability/metrics.ts';
 import type { RoutingPolicy } from '../worker/registry.ts';
 import { WorkerRegistry } from '../worker/registry.ts';
 import type { AuthConfig, RateLimitConfig } from './authentication.ts';
+import { type DashboardAssets } from './dashboard-assets.ts';
 import type { DiscoveryInfo } from './discovery-info.ts';
 import type { CorsOptions } from './runtime/cors.ts';
 import type { SchedulingPolicy } from './task-queue-types.ts';
 import { TaskQueue } from './task-queue.ts';
 export { wireEventBroadcasting, type EventBroadcastingHandle, } from './runtime/event-broadcasting.ts';
+export type { DashboardAssets } from './dashboard-assets.ts';
 export type { CorsOptions } from './runtime/cors.ts';
 export { createRateLimiter, createRotatingApiKeyStore, defaultAuthAuditSink, isSensitiveHeader, redactCredential, redactHeaders, validateRateLimitConfig, type ApiKeyRegistration, type AuthAuditEvent, type AuthAuditSink, type AuthConfig, type RateLimitConfig, type RateLimitDecision, type RateLimiter, type RotatingApiKeyStore, } from './authentication.ts';
 export type { RetryPolicy } from '../core/types.ts';
@@ -32,6 +34,8 @@ export { TaskQueue } from './task-queue.ts';
  * They are intentionally specific (no blanket `/*`) so they cannot shadow the
  * API served under the `/api` prefix or the root-stable discovery endpoints —
  * those fall through to the `fetch` handler.
+ * The supported page routes are `/`, `/workflows`, `/workflows/*`, `/reviews`,
+ * `/workers`, `/schedules`, `/storage`, and `/system`.
  *
  * @example
  * ```ts
@@ -42,7 +46,7 @@ export { TaskQueue } from './task-queue.ts';
  * console.log(DASHBOARD_PAGE_ROUTES.includes('/workflows')); // true
  * ```
  */
-export declare const DASHBOARD_PAGE_ROUTES: readonly ["/", "/workflows", "/workflows/*", "/reviews", "/workers"];
+export declare const DASHBOARD_PAGE_ROUTES: readonly ["/", "/workflows", "/workflows/*", "/reviews", "/workers", "/schedules", "/storage", "/system"];
 /**
  * Route pattern owned by an externally supplied dashboard shell.
  *
@@ -129,6 +133,11 @@ export interface ServeOptions {
     development?: boolean;
     /** Optional external dashboard shell served at {@link DASHBOARD_PAGE_ROUTES}. */
     dashboard?: DashboardRouteTarget;
+    /**
+     * Static files served below an explicit prefix for the supplied dashboard.
+     * The directory and prefix are validated synchronously before the port binds.
+     */
+    dashboardAssets?: DashboardAssets;
     /** Authentication configuration. When provided, all non-public endpoints require valid credentials. */
     auth?: AuthConfig;
     /**

package/dist/server/index.js

@@ -1,4 +1,8 @@
 import { WorkerRegistry } from "../worker/registry.js";
+import {
+  createDashboardAssetRoute,
+  resolveDashboardAssets
+} from "./dashboard-assets.js";
 import { createServerWebSocketHandlers } from "./runtime/authentication-bridge.js";
 import {
   wireEventBroadcasting
@@ -39,13 +43,18 @@ export const DASHBOARD_PAGE_ROUTES = [
   "/workflows",
   "/workflows/*",
   "/reviews",
-  "/workers"
+  "/workers",
+  "/schedules",
+  "/storage",
+  "/system"
 ];
 export function serve(options) {
-  const { port, hostname, development, tlsOptions, serverOptions, serverMetricsCollector } = resolveNetworkConfig(options), context = buildServerContext(serverOptions, serverMetricsCollector), boundCleanup = (operationId) => cleanupWorkflowIndex(context, operationId), routes = {};
+  const dashboardAssets = options.dashboardAssets === void 0 ? void 0 : resolveDashboardAssets(options.dashboardAssets, DASHBOARD_PAGE_ROUTES), { port, hostname, development, tlsOptions, serverOptions, serverMetricsCollector } = resolveNetworkConfig(options), context = buildServerContext(serverOptions, serverMetricsCollector), boundCleanup = (operationId) => cleanupWorkflowIndex(context, operationId), routes = {};
   if (options.dashboard != null)
     for (const path of DASHBOARD_PAGE_ROUTES)
       routes[path] = options.dashboard;
+  if (dashboardAssets !== void 0)
+    routes[`${dashboardAssets.prefix}/*`] = createDashboardAssetRoute(dashboardAssets);
   const serverHolder = { current: null }, server = Bun.serve(buildBunServeConfig(port, hostname, development, routes, tlsOptions, buildFetchHandler(serverHolder, context, serverOptions), createServerWebSocketHandlers(context, serverOptions, boundCleanup)));
   serverHolder.current = server;
   const stack = new AsyncDisposableStack;

package/dist/server/interactive-operations.js

@@ -1,4 +1,5 @@
 export const INTERACTIVE_OPERATION_NAMES = [
+  "weft.alerts.list",
   "weft.workflows.start",
   "weft.workflows.get",
   "weft.workflows.scheduleprovenance.get",

package/dist/server/operations/aggregate-workflows.js

@@ -79,12 +79,6 @@ function extractAggregateWorkflowsInput(request) {
     ...limitValue !== void 0 && Number.isFinite(limitValue) && limitValue >= 1 ? { limit: limitValue } : {}
   };
 }
-function shapeAggregateWorkflowsSuccess(result) {
-  return new Response(JSON.stringify(result), {
-    status: 200,
-    headers: { "Content-Type": "application/json" }
-  });
-}
 function shapeAggregateWorkflowsFault(fault) {
   if (fault.code === "Unprocessable")
     return shapeRestFault(fault, { status: 400 });
@@ -106,6 +100,5 @@ export const aggregateWorkflowsRestBinding = {
   },
   extractInput: async (request) => extractAggregateWorkflowsInput(request),
   success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => shapeAggregateWorkflowsSuccess(output),
   shapeFault: shapeAggregateWorkflowsFault
 };

package/dist/server/operations/async-activity.js

@@ -11,7 +11,7 @@ import { PayloadSizeExceededError } from "../../core/payload-size.js";
 import { raiseFault } from "../operation-catalog.js";
 import { defineOperation } from "../operation-registry.js";
 import { readRestJsonBody } from "../rest-body.js";
-import { invalidParamsFault, isOperationFault, shapeRestFault } from "./operation-helpers.js";
+import { invalidParamsFault, isOperationFault } from "./operation-helpers.js";
 const asyncActivityReadAccess = {
   kind: "scoped",
   scopes: { kind: "anyOf", scopes: ["workflows:read"] }
@@ -137,20 +137,7 @@ export const completeAsyncActivityOperation = defineOperation({
     }
     return { ok: !0 };
   }
-});
-function shapeAsyncActivitySuccess(output) {
-  return new Response(JSON.stringify(output), {
-    status: 200,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-function shapePendingAsyncActivitiesSuccess(output) {
-  return new Response(JSON.stringify(output), {
-    status: 200,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-export const listPendingAsyncActivitiesRestBinding = {
+}), listPendingAsyncActivitiesRestBinding = {
   method: "GET",
   path: "/v1/workflows/:id/pending-async-activities",
   pathParamNames: ["id"],
@@ -168,9 +155,7 @@ export const listPendingAsyncActivitiesRestBinding = {
       ...cursor === null ? {} : { cursor }
     };
   },
-  success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => shapePendingAsyncActivitiesSuccess(output),
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 200 }
 };
 async function readJsonObjectBody(request, context) {
   const body = await readRestJsonBody(request, context).catch((error) => {
@@ -198,9 +183,7 @@ export const completeAsyncActivityRestBinding = {
       ..."result" in body ? { result: body.result } : {}
     };
   },
-  success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => shapeAsyncActivitySuccess(output),
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 200 }
 }, failAsyncActivityRestBinding = {
   method: "POST",
   path: "/v1/activities/fail",
@@ -217,7 +200,5 @@ export const completeAsyncActivityRestBinding = {
       error: body.error
     };
   },
-  success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => shapeAsyncActivitySuccess(output),
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 200 }
 };

package/dist/server/operations/bulk-cancel-workflows.js

@@ -12,11 +12,8 @@ import {
   parseBulkOperationControlFromBody,
   readOptionalJsonBody
 } from "./bulk-filter-helpers.js";
-import {
-  shapeBulkJsonSuccess,
-  validatedListFilterFromBulkInput
-} from "./bulk-operation-helpers.js";
-import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { validatedListFilterFromBulkInput } from "./bulk-operation-helpers.js";
+import { invalidParamsFault } from "./operation-helpers.js";
 const bulkCancelWorkflowsInput = bulkListFilterInputSchema.merge(bulkOperationControlInputSchema), bulkCancelWorkflowsOutput = z.unknown();
 export const bulkCancelWorkflowsOperation = defineOperation({
   name: "weft.workflows.bulk.cancel",
@@ -58,7 +55,5 @@ export const bulkCancelWorkflowsOperation = defineOperation({
       throw invalidParamsFault(faultMessage(error));
     }
   },
-  success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => shapeBulkJsonSuccess(output),
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 200 }
 };

package/dist/server/operations/bulk-delete-workflows.js

@@ -16,11 +16,8 @@ import {
   readOptionalJsonBody,
   unprocessableFault
 } from "./bulk-filter-helpers.js";
-import {
-  shapeBulkJsonSuccess,
-  validatedListFilterFromBulkInput
-} from "./bulk-operation-helpers.js";
-import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { validatedListFilterFromBulkInput } from "./bulk-operation-helpers.js";
+import { invalidParamsFault } from "./operation-helpers.js";
 const bulkDeleteWorkflowsInput = bulkListFilterInputSchema.merge(bulkOperationControlInputSchema), bulkDeleteWorkflowsOutput = z.unknown();
 export const bulkDeleteWorkflowsOperation = defineOperation({
   name: "weft.workflows.bulk.delete",
@@ -65,7 +62,5 @@ export const bulkDeleteWorkflowsOperation = defineOperation({
       throw invalidParamsFault(faultMessage(error));
     }
   },
-  success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => shapeBulkJsonSuccess(output),
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 200 }
 };

package/dist/server/operations/bulk-mutate-workflow-tags.js

@@ -13,11 +13,8 @@ import {
   parseBulkOperationControlFromBody,
   readOptionalJsonBody
 } from "./bulk-filter-helpers.js";
-import {
-  shapeBulkJsonSuccess,
-  validatedListFilterFromBulkInput
-} from "./bulk-operation-helpers.js";
-import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { validatedListFilterFromBulkInput } from "./bulk-operation-helpers.js";
+import { invalidParamsFault } from "./operation-helpers.js";
 const bulkMutateWorkflowTagsInput = z.object({
   filter: bulkListFilterInputSchema.optional(),
   tags: z.array(z.string()),
@@ -94,7 +91,5 @@ export const bulkMutateWorkflowTagsRestBinding = {
       ...parseBulkOperationControlFromBody(body)
     };
   },
-  success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => shapeBulkJsonSuccess(output),
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 200 }
 };

package/dist/server/operations/bulk-operation-helpers.d.ts

@@ -1,4 +1,4 @@
-import type { BulkCancelResult, BulkDeleteResult, BulkOperationDryRunResult, BulkRetryFailedResult, BulkSignalResult, BulkTagResult, ListFilter, PurgeResult } from '../../core/types.ts';
+import type { ListFilter } from '../../core/types.ts';
 import { type BulkListFilterInput } from './bulk-filter-helpers.ts';
 /**
  * Coerces filter tags (label `Field "filter.tags"`), builds a `ListFilter`
@@ -13,15 +13,7 @@ import { type BulkListFilterInput } from './bulk-filter-helpers.ts';
  * runs.
  *
  * Not used by `purge-workflows.ts`: purge allows empty/unscoped filters and
- * shapes faults through `shapeRestFault` (sanitized) rather than passing
+ * uses the canonical REST fault fallback (sanitized) rather than passing
  * raw engine messages through unmasked.
  */
 export declare function validatedListFilterFromBulkInput(input: BulkListFilterInput): ListFilter;
-export type BulkOperationSuccessResult = BulkCancelResult | BulkDeleteResult | BulkRetryFailedResult | BulkSignalResult | BulkTagResult | BulkOperationDryRunResult | PurgeResult;
-/**
- * Standard JSON 200 response shape for bulk-workflow operations. Used by
- * every bulk operation's REST `shapeSuccess`; the result types are unioned
- * rather than left as `unknown` so the type system catches accidental
- * `undefined` / `Response` / `Error` arguments at the call site.
- */
-export declare function shapeBulkJsonSuccess(result: BulkOperationSuccessResult): Response;

package/dist/server/operations/bulk-operation-helpers.js

@@ -21,9 +21,3 @@ export function validatedListFilterFromBulkInput(input) {
   }
   return filter;
 }
-export function shapeBulkJsonSuccess(result) {
-  return new Response(JSON.stringify(result), {
-    status: 200,
-    headers: { "Content-Type": "application/json" }
-  });
-}

package/dist/server/operations/bulk-retry-failed-workflows.js

@@ -12,11 +12,8 @@ import {
   parseBulkOperationControlFromBody,
   readOptionalJsonBody
 } from "./bulk-filter-helpers.js";
-import {
-  shapeBulkJsonSuccess,
-  validatedListFilterFromBulkInput
-} from "./bulk-operation-helpers.js";
-import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { validatedListFilterFromBulkInput } from "./bulk-operation-helpers.js";
+import { invalidParamsFault } from "./operation-helpers.js";
 const bulkRetryFailedWorkflowsInput = bulkListFilterInputSchema.merge(bulkOperationControlInputSchema), bulkRetryFailedWorkflowsOutput = z.unknown();
 export const bulkRetryFailedWorkflowsOperation = defineOperation({
   name: "weft.workflows.bulk.retryfailed",
@@ -58,7 +55,5 @@ export const bulkRetryFailedWorkflowsOperation = defineOperation({
       throw invalidParamsFault(faultMessage(error));
     }
   },
-  success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => shapeBulkJsonSuccess(output),
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 200 }
 };

package/dist/server/operations/bulk-signal-workflows.js

@@ -12,11 +12,8 @@ import {
   parseBulkOperationControlFromBody,
   readOptionalJsonBody
 } from "./bulk-filter-helpers.js";
-import {
-  shapeBulkJsonSuccess,
-  validatedListFilterFromBulkInput
-} from "./bulk-operation-helpers.js";
-import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { validatedListFilterFromBulkInput } from "./bulk-operation-helpers.js";
+import { invalidParamsFault } from "./operation-helpers.js";
 const bulkSignalWorkflowsInput = bulkListFilterInputSchema.extend({
   name: z.string().min(1),
   payload: z.unknown().optional()
@@ -74,7 +71,5 @@ export const bulkSignalWorkflowsOperation = defineOperation({
       ...parseBulkOperationControlFromBody(body)
     };
   },
-  success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => shapeBulkJsonSuccess(output),
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 200 }
 };

package/dist/server/operations/cancel-schedule.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
-import { shapeRestFault } from "./operation-helpers.js";
 import { mapScheduleErrorToFault } from "./schedule-faults.js";
 const cancelScheduleInput = z.object({
   scheduleId: z.string().min(1)
@@ -38,6 +37,5 @@ export const cancelScheduleOperation = defineOperation({
   extractInput: async (_request, pathParams) => ({
     scheduleId: pathParams.id ?? ""
   }),
-  success: { kind: "empty", status: 204 },
-  shapeFault: shapeRestFault
+  success: { kind: "empty", status: 204 }
 };

package/dist/server/operations/cancel-workflow.js

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { shapeRestFault } from "./operation-helpers.js";
 import {
   createSingleWorkflowControlOperation,
   extractWorkflowIdFromPath
@@ -29,6 +28,5 @@ export const cancelWorkflowOperation = createSingleWorkflowControlOperation({
     workflowId: { kind: "path", pathParam: "id" }
   },
   extractInput: async (_request, pathParams) => extractWorkflowIdFromPath(pathParams),
-  success: { kind: "empty", status: 204 },
-  shapeFault: shapeRestFault
+  success: { kind: "empty", status: 204 }
 };

package/dist/server/operations/create-schedule.js

@@ -1,17 +1,16 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
-import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
-import { mapScheduleErrorToFault, validateScheduleInputCadence } from "./schedule-faults.js";
+import { invalidParamsFault } from "./operation-helpers.js";
+import {
+  mapScheduleErrorToFault,
+  validateScheduleInputCadence,
+  validateScheduleMutableOptions
+} from "./schedule-faults.js";
 import {
   extractSharedScheduleRestFields,
   parseScheduleRestBodyRequestRecord
 } from "./schedule-rest-body.js";
-const VALID_SCHEDULE_OVERLAP_POLICIES = new Set([
-  "skip",
-  "queue",
-  "cancel-running",
-  "allow"
-]), createScheduleInput = z.object({
+const createScheduleInput = z.object({
   type: z.unknown().describe("Workflow type name. Runtime validation requires a non-empty string."),
   cronExpression: z.unknown().optional().describe("Cron expression. Supply exactly one of cronExpression or every; runtime validation requires a non-empty string."),
   every: z.unknown().optional().describe("Interval period (duration string or milliseconds). Supply exactly one of cronExpression or every."),
@@ -29,43 +28,21 @@ function validateRequiredScheduleFields(input) {
     throw invalidParamsFault("Missing required field: type");
   return { type: input.type, spec: validateScheduleInputCadence(input) };
 }
+function validateScheduleId(value) {
+  if (value === void 0)
+    return;
+  if (typeof value !== "string" || value.length === 0)
+    throw invalidParamsFault('Field "id" must be a non-empty string');
+  return value;
+}
 function validateOptionalScheduleFields(input) {
-  let validatedId;
-  if (input.id !== void 0) {
-    if (typeof input.id !== "string" || input.id.length === 0)
-      throw invalidParamsFault('Field "id" must be a non-empty string');
-    validatedId = input.id;
-  }
-  let validatedDescription;
-  if (input.description !== void 0) {
-    if (typeof input.description !== "string")
-      throw invalidParamsFault('Field "description" must be a string');
-    validatedDescription = input.description;
-  }
-  let validatedOverlap;
-  if (input.overlap !== void 0) {
-    if (typeof input.overlap !== "string" || !isScheduleOverlapPolicy(input.overlap))
-      throw invalidParamsFault('Field "overlap" must be one of skip, queue, cancel-running, allow');
-    validatedOverlap = input.overlap;
-  }
-  let validatedBackfill;
-  if (input.backfill !== void 0) {
-    if (typeof input.backfill !== "boolean")
-      throw invalidParamsFault('Field "backfill" must be a boolean');
-    validatedBackfill = input.backfill;
-  }
-  let validatedJitter;
-  if (input.jitter !== void 0) {
-    if (typeof input.jitter !== "string" && typeof input.jitter !== "number")
-      throw invalidParamsFault('Field "jitter" must be a duration string or a number of milliseconds');
-    validatedJitter = input.jitter;
-  }
+  const validatedId = validateScheduleId(input.id), validatedOptions = validateScheduleMutableOptions(input);
   return {
     id: validatedId,
-    description: validatedDescription,
-    overlap: validatedOverlap,
-    backfill: validatedBackfill,
-    jitter: validatedJitter
+    description: validatedOptions.description,
+    overlap: validatedOptions.overlap,
+    backfill: validatedOptions.backfill,
+    jitter: validatedOptions.jitter
   };
 }
 function validateCreateScheduleInput(input) {
@@ -99,11 +76,7 @@ export const createScheduleOperation = defineOperation({
       throw mapScheduleErrorToFault(validated.id ?? "", error);
     }
   }
-});
-function isScheduleOverlapPolicy(value) {
-  return VALID_SCHEDULE_OVERLAP_POLICIES.has(value);
-}
-export const createScheduleRestBinding = {
+}), createScheduleRestBinding = {
   method: "POST",
   path: "/v1/schedules",
   pathParamNames: [],
@@ -128,6 +101,5 @@ export const createScheduleRestBinding = {
       ...extractSharedScheduleRestFields(record)
     };
   },
-  success: { kind: "json", status: 201 },
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 201 }
 };