@lostgradient/weft 0.16.0 → 0.17.0

package/dist/server/dashboard-assets.js

@@ -1,14 +1,6 @@
-import { realpathSync, statSync } from "node:fs";
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
-const ROOT_API_PREFIXES = ["/api", "/v1"], DISCOVERY_DOCUMENTS = [
-  "/openapi.json",
-  "/openrpc.json",
-  "/asyncapi.json",
-  "/.well-known/mcp.json"
-];
-function hasPathPrefix(path, prefix) {
-  return path === prefix || path.startsWith(`${prefix}/`);
-}
+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);
@@ -16,6 +8,9 @@ function overlapsDashboardPageRoute(prefix, route) {
   }
   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));
 }
@@ -24,14 +19,19 @@ function validateAssetPrefixShape(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 (ROOT_API_PREFIXES.some((reserved) => hasPathPrefix(prefix, reserved)))
-    throw Error("dashboardAssets.prefix must not overlap the /api or /v1 route spaces");
+  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");
-  if (DISCOVERY_DOCUMENTS.some((document) => document === prefix))
-    throw Error("dashboardAssets.prefix must not overlap a discovery document route");
 }
 function validateAssetPrefix(prefix, pageRoutes) {
   validateAssetPrefixShape(prefix);
@@ -46,50 +46,164 @@ export function resolveDashboardAssets(value, pageRoutes) {
   if (typeof prefix !== "string" || typeof directory !== "string")
     throw Error("dashboardAssets.prefix and dashboardAssets.directory must be strings");
   validateAssetPrefix(prefix, pageRoutes);
-  const resolvedDirectory = resolve(directory);
+  const resolvedDirectory = resolvePath(directory);
   let directoryStats;
   try {
-    directoryStats = statSync(resolvedDirectory);
+    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: realpathSync(resolvedDirectory) };
+  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 assetResponse(directory, prefix, request) {
+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 new Response("Not Found", { status: 404 });
+    return;
   }
   if (wildcardPath.length === 0)
-    return new Response("Not Found", { status: 404 });
+    return;
   const pathSegments = wildcardPath.split(/[\\/]/);
   if (pathSegments.some((segment) => segment === ".." || segment.length === 0))
-    return new Response("Not Found", { status: 404 });
-  const assetPath = resolve(join(directory, ...pathSegments));
+    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 realAssetPath;
+  let descriptor;
   try {
-    realAssetPath = realpathSync(assetPath);
-    if (!statSync(realAssetPath).isFile())
+    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);
   }
-  if (!isWithinDirectory(directory, realAssetPath))
-    return new Response("Not Found", { status: 404 });
-  return new Response(Bun.file(realAssetPath));
 }
-export function createDashboardAssetRoute(assets) {
-  const handler = (request) => assetResponse(assets.directory, assets.prefix, request);
+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/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,6 +1,6 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
-import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { invalidParamsFault } from "./operation-helpers.js";
 import {
   mapScheduleErrorToFault,
   validateScheduleInputCadence,
@@ -101,6 +101,5 @@ export const createScheduleOperation = defineOperation({
       ...extractSharedScheduleRestFields(record)
     };
   },
-  success: { kind: "json", status: 201 },
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 201 }
 };

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
 import { readRestTextBody } from "../rest-body.js";
-import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { invalidParamsFault } from "./operation-helpers.js";
 const forkWorkflowInput = z.object({
   workflowId: z.string().min(1),
   fromStep: z.unknown().optional()
@@ -84,6 +84,5 @@ export const forkWorkflowOperation = defineOperation({
       fromStep: record.fromStep
     };
   },
-  success: { kind: "json", status: 201 },
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 201 }
 };

package/dist/server/operations/get-checkpoint-at.js

@@ -1,7 +1,6 @@
 import { z } from "zod";
 import { negotiatedResponse } from "../handler/response-helpers.js";
 import { defineOperation } from "../operation-registry.js";
-import { shapeRestFault } from "./operation-helpers.js";
 const getCheckpointAtInput = z.object({
   workflowId: z.string().min(1),
   step: z.number().int().nonnegative()
@@ -32,9 +31,6 @@ export const getCheckpointAtOperation = defineOperation({
 function shapeGetCheckpointAtSuccess(result, request) {
   return negotiatedResponse(request, result, 200);
 }
-function shapeGetCheckpointAtFault(fault) {
-  return shapeRestFault(fault);
-}
 export const getCheckpointAtRestBinding = {
   method: "GET",
   path: "/v1/workflows/:id/checkpoints/:step",
@@ -69,6 +65,5 @@ export const getCheckpointAtRestBinding = {
     };
   },
   success: { kind: "json", status: 200 },
-  shapeSuccess: (output, request) => shapeGetCheckpointAtSuccess(output, request),
-  shapeFault: shapeGetCheckpointAtFault
+  shapeSuccess: (output, request) => shapeGetCheckpointAtSuccess(output, request)
 };

package/dist/server/operations/get-registry.js

@@ -4,7 +4,6 @@ import {
   RegistrySchemaConversionError
 } from "../../core/registry-snapshot.js";
 import { defineOperation } from "../operation-registry.js";
-import { shapeRestFault } from "./operation-helpers.js";
 const getRegistryInput = z.object({}), objectValue = z.unknown().refine((value) => typeof value === "object" && value !== null && !Array.isArray(value), {
   message: "expected an object"
 }), getRegistryOutput = z.object({
@@ -47,10 +46,5 @@ export const getRegistryOperation = defineOperation({
   operationName: "weft.system.registry",
   inputSources: {},
   extractInput: async () => ({}),
-  success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => new Response(JSON.stringify(output), {
-    status: 200,
-    headers: { "Content-Type": "application/json" }
-  }),
-  shapeFault: shapeRestFault
+  success: { kind: "json", status: 200 }
 };

package/dist/server/operations/get-retention-overview.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
-import { shapeRestFault } from "./operation-helpers.js";
 const getRetentionOverviewInput = z.object({}), getRetentionOverviewOutput = z.unknown();
 export const getRetentionOverviewOperation = defineOperation({
   name: "weft.retention.get",
@@ -16,24 +15,12 @@ export const getRetentionOverviewOperation = defineOperation({
   invoke: async ({ engine }) => {
     return engine.getRetentionOverview();
   }
-});
-function shapeGetRetentionOverviewSuccess(result) {
-  return new Response(JSON.stringify(result), {
-    status: 200,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-function shapeGetRetentionOverviewFault(fault) {
-  return shapeRestFault(fault);
-}
-export const getRetentionOverviewRestBinding = {
+}), getRetentionOverviewRestBinding = {
   method: "GET",
   path: "/v1/retention",
   pathParamNames: [],
   operationName: "weft.retention.get",
   inputSources: {},
   extractInput: async () => ({}),
-  success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => shapeGetRetentionOverviewSuccess(output),
-  shapeFault: shapeGetRetentionOverviewFault
+  success: { kind: "json", status: 200 }
 };

package/dist/server/operations/get-review.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
-import { shapeRestFault } from "./operation-helpers.js";
 const getReviewInput = z.object({
   workflowId: z.string().min(1),
   reviewId: z.string().min(1)
@@ -28,17 +27,7 @@ export const getReviewOperation = defineOperation({
       };
     return review;
   }
-});
-function shapeGetReviewSuccess(result) {
-  return new Response(JSON.stringify(result), {
-    status: 200,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-function shapeGetReviewFault(fault) {
-  return shapeRestFault(fault);
-}
-export const getReviewRestBinding = {
+}), getReviewRestBinding = {
   method: "GET",
   path: "/v1/workflows/:id/review/:reviewId",
   pathParamNames: ["id", "reviewId"],
@@ -51,7 +40,5 @@ export const getReviewRestBinding = {
     workflowId: pathParams.id ?? "",
     reviewId: pathParams.reviewId ?? ""
   }),
-  success: { kind: "json", status: 200 },
-  shapeSuccess: (output) => shapeGetReviewSuccess(output),
-  shapeFault: shapeGetReviewFault
+  success: { kind: "json", status: 200 }
 };