@lostgradient/weft 0.2.0

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

@@ -0,0 +1,153 @@
+/**
+ * Transport-neutral fault model for the operation pipeline.
+ *
+ * `OperationFault` is what `executeOperation` returns when a request fails.
+ * It carries a stable `code` (the discriminator), a human-readable `message`
+ * for logs, and a typed `data` payload narrowed per-code via discriminated
+ * union — so transport adapters can serialize the fault into the exact
+ * wire shape their protocol expects without a string-sniffing layer.
+ *
+ * Two pure mapper functions translate the fault into a transport-specific
+ * shape:
+ *   - `faultToHttpResponse(fault)` for REST.
+ *   - `faultToJsonRpcError(fault)` for the JSON-RPC transports.
+ * Both consume `OperationFault` directly; serialization is not a method on
+ * the fault class because that would force every transport to know about
+ * every other transport's wire shape.
+ *
+ * **Scope.** The union covers operation-pipeline faults — what
+ * `executeOperation` produces. Pure protocol-frame errors (JSON parse
+ * failure, invalid JSON-RPC request envelope) live in the JSON-RPC parser
+ * and use the spec-mandated reserved codes (-32700 / -32600); they do NOT
+ * pass through this fault model. The v1 union is open for additive
+ * extension — future codes (e.g. `PreconditionFailed`, `PayloadTooLarge`,
+ * `ResourceExhausted`) can be added without breaking existing serializers
+ * because the per-code mapping tables are exhaustive `Record<FaultCode, T>`
+ * and the JSON-RPC payload extractor is an exhaustive switch.
+ *
+ * **Every fault has a `data` field.** Even codes with no payload-specific
+ * detail (`NotImplemented`, `EngineFailure`) carry `data: {}` so transport
+ * adapters never branch on `data === undefined`. This uniformity is what
+ * lets the exhaustive switch in `extractFaultDataPayload` stay small.
+ *
+ * See Track 8 design decision 4.
+ */
+import type { FaultCode } from '../core/fault-code.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. */
+export type FlattenedZodIssue = {
+    readonly path: ReadonlyArray<string | number>;
+    readonly message: string;
+    readonly code: string;
+};
+/**
+ * Transport-neutral fault returned by `executeOperation`. Each variant has a
+ * typed `data` payload — transport adapters destructure on `code` to access
+ * the shape they need.
+ */
+export type OperationFault = {
+    code: 'Unauthorized';
+    message: string;
+    data: {
+        reason: string;
+    };
+} | {
+    code: 'Forbidden';
+    message: string;
+    data: {
+        reason: string;
+    };
+} | {
+    code: 'NotFound';
+    message: string;
+    data: {
+        resource: string;
+        identifier?: string | undefined;
+    };
+} | {
+    code: 'Conflict';
+    message: string;
+    data: {
+        reason: string;
+        missingTypes?: readonly string[] | undefined;
+        missingWorkflowCount?: number | undefined;
+        samplesTruncated?: boolean | undefined;
+    };
+} | {
+    code: 'Unprocessable';
+    message: string;
+    data: {
+        reason: string;
+    };
+} | {
+    code: 'Timeout';
+    message: string;
+    data: {
+        operationName?: string | undefined;
+    };
+} | {
+    code: 'NotImplemented';
+    message: string;
+    data: Record<string, never>;
+} | {
+    code: 'UnsupportedTransport';
+    message: string;
+    data: {
+        transport: TransportKind;
+        supported: ReadonlyArray<TransportKind>;
+    };
+} | {
+    code: 'SubscriptionOverflow';
+    message: string;
+    data: {
+        subscriptionId: string;
+        droppedCount: number;
+    };
+} | {
+    code: 'InvalidParams';
+    message: string;
+    data: {
+        issues: ReadonlyArray<FlattenedZodIssue>;
+    };
+} | {
+    code: 'MethodNotFound';
+    message: string;
+    data: {
+        method: string;
+    };
+} | {
+    code: 'EngineFailure';
+    message: string;
+    data: Record<string, never>;
+};
+/**
+ * HTTP status code for each fault, used by `faultToHttpResponse`. Values
+ * align with REST conventions; both `NotImplemented` and
+ * `UnsupportedTransport` map to 501 because the caller asked for something
+ * the server cannot fulfill.
+ */
+export declare const FAULT_CODE_TO_HTTP_STATUS: Readonly<Record<FaultCode, number>>;
+/**
+ * Format an `InvalidParams` fault as a single human-readable error string
+ * suitable for the body of a JSON response. Joins each Zod issue as
+ * `path: message` (or just `message` at the root) with `; ` separators.
+ */
+export declare function formatInvalidParamsMessage(fault: Extract<OperationFault, {
+    code: 'InvalidParams';
+}>): string;
+/**
+ * Map an `OperationFault` to a JSON `Response` with an `{ error }` body.
+ * Treats `InvalidParams` as 400 with a flattened issues message, masks
+ * `EngineFailure` as `Internal server error` at 500, and uses
+ * {@link FAULT_CODE_TO_HTTP_STATUS} for every other code. Used by REST
+ * bindings that serve a single resource and want a uniform error shape.
+ */
+export declare function shapeOperationFaultAsJson(fault: OperationFault): Response;
+/**
+ * JSON-RPC error code for each fault. Reserved codes (-32700..-32603) keep
+ * the spec meanings (`InvalidParams`, `MethodNotFound`); Weft domain codes
+ * live in -32010..-32099 documented per design decision 4.
+ */
+export declare const FAULT_CODE_TO_JSON_RPC_CODE: Readonly<Record<FaultCode, number>>;

package/dist/server/operation-fault.js

@@ -0,0 +1,50 @@
+export const FAULT_CODE_TO_HTTP_STATUS = Object.freeze({
+  Unauthorized: 401,
+  Forbidden: 403,
+  NotFound: 404,
+  Conflict: 409,
+  Unprocessable: 422,
+  Timeout: 408,
+  NotImplemented: 501,
+  UnsupportedTransport: 501,
+  SubscriptionOverflow: 500,
+  InvalidParams: 400,
+  MethodNotFound: 404,
+  EngineFailure: 500
+});
+export function formatInvalidParamsMessage(fault) {
+  return fault.data.issues.map((issue) => {
+    const path = issue.path.join(".");
+    return path.length > 0 ? `${path}: ${issue.message}` : issue.message;
+  }).join("; ");
+}
+export function shapeOperationFaultAsJson(fault) {
+  if (fault.code === "InvalidParams")
+    return new Response(JSON.stringify({ error: formatInvalidParamsMessage(fault) }), {
+      status: 400,
+      headers: { "Content-Type": "application/json" }
+    });
+  if (fault.code === "EngineFailure")
+    return new Response(JSON.stringify({ error: "Internal server error" }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  return new Response(JSON.stringify({ error: fault.message }), {
+    status: FAULT_CODE_TO_HTTP_STATUS[fault.code],
+    headers: { "Content-Type": "application/json" }
+  });
+}
+export const FAULT_CODE_TO_JSON_RPC_CODE = Object.freeze({
+  Unauthorized: -32010,
+  Forbidden: -32011,
+  NotFound: -32020,
+  Conflict: -32021,
+  Unprocessable: -32022,
+  Timeout: -32023,
+  NotImplemented: -32025,
+  UnsupportedTransport: -32030,
+  SubscriptionOverflow: -32031,
+  EngineFailure: -32099,
+  InvalidParams: -32602,
+  MethodNotFound: -32601
+});

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

@@ -0,0 +1,100 @@
+/**
+ * Operation-name validation and the typed `defineOperation` builder.
+ *
+ * The full list of runtime operations (workflow start/signal/update/query,
+ * schedules, reviews, attributes, etc.) is populated incrementally by the
+ * transport-adapter phases (Phases 9-13). This module supplies:
+ *
+ *   - `validateOperationName` / `isValidOperationName` — the regex that
+ *     `OpenRPC` discovery and the JSON-RPC dispatcher both enforce.
+ *     Operation names must follow `weft.<segment>(.<segment>)+` with
+ *     lowercase ASCII segments. The form is single-source-of-truth here.
+ *
+ *   - `defineOperation` — a fully-typed builder that returns a concrete
+ *     `OperationDefinition<Input, Output>`. Use this when authoring
+ *     individual operations so the `Input`/`Output` types flow through
+ *     `authorize` and `invoke` without the `as unknown as ErasedOperation`
+ *     cast required at the registry boundary.
+ */
+import type { z } from 'zod';
+import type { AccessPolicy } from './authorization.ts';
+import { type OperationDefinition, type TransportAvailability, type UnknownKeyPolicy } from './operation-catalog.ts';
+import type { FaultCode } from './operation-fault.ts';
+export { isValidOperationName, validateOperationName } from './operation-catalog.ts';
+/**
+ * Input shape for `defineOperation`. Mirrors `OperationDefinition` but
+ * makes `tags` optional (default `[]`) so individual operation modules
+ * stay terse.
+ *
+ * `authorize` is optional. When absent, the operation's `access` policy
+ * is the sole authorization gate — `invoke` runs as soon as the policy
+ * passes. When present, BOTH `access` AND `authorize` must permit the
+ * call: the policy runs first, then the parameter-aware hook.
+ */
+type OperationDefinitionInputBase<Input, Output> = {
+    readonly name: string;
+    readonly mcpExposable: boolean;
+    readonly mcpTool?: OperationDefinition<Input, Output>['mcpTool'];
+    readonly summary: string;
+    /**
+     * Optional longer-form prose. See {@link OperationDefinition} for the
+     * contract and the surfaces (OpenAPI, OpenRPC, CLI `--describe`, MCP
+     * discovery) that read it. `summary` stays mandatory and short.
+     */
+    readonly description?: string;
+    readonly tags?: ReadonlyArray<string>;
+    /**
+     * Whether invoking this operation irreversibly mutates state. Required —
+     * there is deliberately no default, so every operation author must make
+     * the call explicitly. See {@link OperationDefinition} for the contract
+     * and the consumers that read it.
+     */
+    readonly destructive: boolean;
+    readonly inputSchema: z.ZodType<Input>;
+    readonly outputSchema: z.ZodType<Output>;
+    readonly access: AccessPolicy;
+    readonly producibleFaults?: ReadonlyArray<FaultCode>;
+    readonly discoverable?: boolean;
+    readonly transports: TransportAvailability;
+    readonly unknownKeyPolicy: UnknownKeyPolicy;
+    readonly authorize?: OperationDefinition<Input, Output>['authorize'];
+    readonly invoke: OperationDefinition<Input, Output>['invoke'];
+};
+/**
+ * Discriminated input for `defineOperation`, mirroring the discriminated
+ * union on `OperationDefinition`. Streaming and subscription kinds REQUIRE
+ * `eventSchema`; unary kinds forbid it. The compiler rejects shapes that
+ * don't satisfy this constraint, eliminating the runtime EngineFailure
+ * that would otherwise fire when a streaming operation tries to validate
+ * elements without a schema.
+ */
+export type OperationDefinitionInput<Input, Output> = (OperationDefinitionInputBase<Input, Output> & {
+    readonly kind?: 'unary';
+    readonly eventSchema?: never;
+}) | (OperationDefinitionInputBase<Input, Output> & {
+    readonly kind: 'stream';
+    readonly eventSchema: z.ZodType;
+}) | (OperationDefinitionInputBase<Input, Output> & {
+    readonly kind: 'subscription';
+    readonly eventSchema: z.ZodType;
+});
+/**
+ * Typed builder for a single operation. Validates the name at construction
+ * — registration-time errors then point at the offending source line, not
+ * at the eventual registry assembly. Defensively shallow-copies every
+ * mutable container in the input (`tags`, `access`, `transports`,
+ * `unknownKeyPolicy`) so that a caller mutating their original references
+ * after this call cannot change the returned definition. The registry
+ * deep-freezes these again at insertion as defense in depth.
+ *
+ * Returns a fully-typed `OperationDefinition<Input, Output>` so caller-
+ * side `Input`/`Output` types flow through to `authorize` / `invoke`
+ * without an `as` cast.
+ *
+ * Note: the registry re-validates `name` at assembly time. The
+ * duplication is deliberate — the registry accepts any
+ * `RegistrableOperation` (including hand-rolled object literals), and
+ * the assembly check is the trust boundary that OpenRPC discovery and
+ * JSON-RPC dispatch rely on.
+ */
+export declare function defineOperation<Input, Output>(input: OperationDefinitionInput<Input, Output>): OperationDefinition<Input, Output>;

package/dist/server/operation-registry.js

@@ -0,0 +1,56 @@
+import {
+  validateOperationName
+} from "./operation-catalog.js";
+export { isValidOperationName, validateOperationName } from "./operation-catalog.js";
+export function defineOperation(input) {
+  validateOperationName(input.name);
+  const baseFields = {
+    name: input.name,
+    mcpExposable: input.mcpExposable,
+    ...input.mcpTool === void 0 ? {} : { mcpTool: { workflowType: input.mcpTool.workflowType } },
+    summary: input.summary,
+    ...input.description === void 0 ? {} : { description: input.description },
+    tags: [...input.tags ?? []],
+    destructive: input.destructive,
+    inputSchema: input.inputSchema,
+    outputSchema: input.outputSchema,
+    ...input.producibleFaults === void 0 ? {} : { producibleFaults: [...input.producibleFaults] },
+    ...input.discoverable === void 0 ? {} : { discoverable: input.discoverable },
+    access: copyAccessPolicy(input.access),
+    transports: { ...input.transports },
+    unknownKeyPolicy: { ...input.unknownKeyPolicy },
+    ...input.authorize === void 0 ? {} : { authorize: input.authorize },
+    invoke: input.invoke
+  };
+  if (input.kind === "stream")
+    return { ...baseFields, kind: "stream", eventSchema: input.eventSchema };
+  if (input.kind === "subscription")
+    return { ...baseFields, kind: "subscription", eventSchema: input.eventSchema };
+  return {
+    ...baseFields
+  };
+}
+function copyAccessPolicy(policy) {
+  if (policy.kind === "scoped")
+    return {
+      kind: "scoped",
+      scopes: copyScopeRequirement(policy.scopes)
+    };
+  if (policy.kind === "scopedAlternatives")
+    return {
+      kind: "scopedAlternatives",
+      alternatives: policy.alternatives.map(copyScopeRequirement)
+    };
+  if (policy.kind === "optionalAuth")
+    return {
+      kind: "optionalAuth",
+      authenticatedScopes: copyScopeRequirement(policy.authenticatedScopes)
+    };
+  return { ...policy };
+}
+function copyScopeRequirement(requirement) {
+  return {
+    kind: requirement.kind,
+    scopes: [...requirement.scopes]
+  };
+}

package/dist/server/operations/add-workflow-tags.d.ts

@@ -0,0 +1,15 @@
+import { type SingleWorkflowTagMutationInput, type SingleWorkflowTagMutationOutput } from './single-workflow-tag-mutation.ts';
+export type AddWorkflowTagsInput = SingleWorkflowTagMutationInput;
+export type AddWorkflowTagsOutput = SingleWorkflowTagMutationOutput;
+export declare const addWorkflowTagsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+    tags?: unknown;
+}, {
+    ok: true;
+}>;
+export declare const addWorkflowTagsRestBinding: import("../rest-binding.ts").RestBinding<{
+    workflowId: string;
+    tags?: unknown;
+}, {
+    ok: true;
+}>;

package/dist/server/operations/add-workflow-tags.js

@@ -0,0 +1,13 @@
+import {
+  createSingleWorkflowTagMutationOperation,
+  createSingleWorkflowTagMutationRestBinding
+} from "./single-workflow-tag-mutation.js";
+export const addWorkflowTagsOperation = createSingleWorkflowTagMutationOperation({
+  name: "weft.workflows.tags.add",
+  summary: "Add workflow tags",
+  destructive: !1,
+  mutateTags: (engine, workflowId, tags) => engine.addTags(workflowId, ...tags)
+}), addWorkflowTagsRestBinding = createSingleWorkflowTagMutationRestBinding({
+  method: "POST",
+  operationName: addWorkflowTagsOperation.name
+});

package/dist/server/operations/aggregate-workflows.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import { type AggregateResult } from '../../core/engine/aggregate.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const aggregateWorkflowsInput: z.ZodObject<{
+    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<import("../../index.ts").WorkflowStatus, unknown, z.core.$ZodTypeInternals<import("../../index.ts").WorkflowStatus, unknown>>, z.ZodArray<z.ZodType<import("../../index.ts").WorkflowStatus, unknown, z.core.$ZodTypeInternals<import("../../index.ts").WorkflowStatus, unknown>>>]>>;
+    type: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    idPrefix: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodObject<{
+        gte: z.ZodOptional<z.ZodNumber>;
+        lte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
+        lt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+        value: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        gt: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        lt: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        gte: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        lte: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    }, z.core.$strip>>>;
+    updatedAt: z.ZodOptional<z.ZodObject<{
+        gte: z.ZodOptional<z.ZodNumber>;
+        lte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
+        lt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    executionDeadline: z.ZodOptional<z.ZodObject<{
+        gte: z.ZodOptional<z.ZodNumber>;
+        lte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
+        lt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    failureCategory: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<import("../../index.ts").FailureCategory, unknown, z.core.$ZodTypeInternals<import("../../index.ts").FailureCategory, unknown>>, z.ZodArray<z.ZodType<import("../../index.ts").FailureCategory, unknown, z.core.$ZodTypeInternals<import("../../index.ts").FailureCategory, unknown>>>]>>;
+    groupBy: z.ZodUnion<readonly [z.ZodLiteral<"status">, z.ZodLiteral<"type">, z.ZodLiteral<"failureCategory">, z.ZodObject<{
+        attribute: z.ZodString;
+    }, z.core.$strict>]>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type AggregateWorkflowsInput = z.infer<typeof aggregateWorkflowsInput>;
+export type AggregateWorkflowsOutput = AggregateResult;
+export declare const aggregateWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    groupBy: "status" | "type" | "failureCategory" | {
+        attribute: string;
+    };
+    status?: import("../../index.ts").WorkflowStatus | import("../../index.ts").WorkflowStatus[] | undefined;
+    type?: string | undefined;
+    tags?: string[] | undefined;
+    idPrefix?: string | undefined;
+    createdAt?: {
+        gte?: number | undefined;
+        lte?: number | undefined;
+        gt?: number | undefined;
+        lt?: number | undefined;
+    } | undefined;
+    attributes?: {
+        key: any;
+        value?: unknown;
+        gt?: unknown;
+        lt?: unknown;
+        gte?: unknown;
+        lte?: unknown;
+    }[] | undefined;
+    updatedAt?: {
+        gte?: number | undefined;
+        lte?: number | undefined;
+        gt?: number | undefined;
+        lt?: number | undefined;
+    } | undefined;
+    executionDeadline?: {
+        gte?: number | undefined;
+        lte?: number | undefined;
+        gt?: number | undefined;
+        lt?: number | undefined;
+    } | undefined;
+    failureCategory?: import("../../index.ts").FailureCategory | import("../../index.ts").FailureCategory[] | undefined;
+    limit?: number | undefined;
+}, AggregateResult>;
+export declare const aggregateWorkflowsRestBinding: UnknownRestBinding;
+export {};

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

@@ -0,0 +1,110 @@
+import { z } from "zod";
+import {
+  AggregateDistinctKeyCapExceededError,
+  AggregateOptionsValidationError,
+  aggregateOptionsObjectSchema
+} from "../../core/aggregate-validation.js";
+import {
+  UnknownAggregateAttributeError
+} from "../../core/engine/aggregate.js";
+import { WorkflowListScanCapExceededError } from "../../core/engine/workflow-indexes.js";
+import {
+  ListFilterValidationError,
+  listFilterObjectSchema
+} from "../../core/list-filter-validation.js";
+import { defineOperation } from "../operation-registry.js";
+import { extractListFilterFromQuery } from "./list-filter-query-extractor.js";
+import { jsonErrorResponse, shapeRestFault } from "./operation-helpers.js";
+const aggregateWorkflowsInput = listFilterObjectSchema.omit({ limit: !0, offset: !0 }).extend(aggregateOptionsObjectSchema.shape), aggregateWorkflowsOutput = z.object({
+  total: z.number().int().min(0),
+  groups: z.array(z.object({
+    key: z.union([z.string(), z.null()]),
+    count: z.number().int().min(0)
+  })),
+  truncated: z.boolean()
+});
+function toUnprocessable(message) {
+  return { code: "Unprocessable", message, data: { reason: message } };
+}
+export const aggregateWorkflowsOperation = defineOperation({
+  name: "weft.workflows.aggregate",
+  mcpExposable: !1,
+  summary: "Aggregate workflows by a single dimension",
+  destructive: !1,
+  tags: ["Workflows"],
+  inputSchema: aggregateWorkflowsInput,
+  outputSchema: aggregateWorkflowsOutput,
+  access: { kind: "public" },
+  producibleFaults: ["Unprocessable"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const engineHandle = engine, { groupBy, limit, ...filterFields } = input, filter = filterFields;
+    try {
+      return await engineHandle.aggregate(filter, {
+        groupBy,
+        ...limit !== void 0 && { limit }
+      });
+    } catch (error) {
+      if (error instanceof ListFilterValidationError || error instanceof AggregateOptionsValidationError || error instanceof UnknownAggregateAttributeError)
+        throw toUnprocessable(error.message);
+      if (error instanceof WorkflowListScanCapExceededError || error instanceof AggregateDistinctKeyCapExceededError)
+        throw toUnprocessable(error.message);
+      throw error;
+    }
+  }
+});
+function parseGroupByQuery(raw) {
+  if (raw === null)
+    return null;
+  const attributePrefix = "attribute:";
+  if (raw.startsWith(attributePrefix)) {
+    const attribute = raw.slice(attributePrefix.length);
+    if (attribute.length === 0)
+      return null;
+    return { attribute };
+  }
+  if (raw === "status" || raw === "type" || raw === "failureCategory")
+    return raw;
+  return null;
+}
+function extractAggregateWorkflowsInput(request) {
+  const url = new URL(request.url), groupByRaw = url.searchParams.get("group_by"), groupBy = parseGroupByQuery(groupByRaw);
+  if (groupBy === null)
+    throw toUnprocessable('group_by must be one of "status", "type", "failureCategory", or "attribute:<name>"');
+  const filter = extractListFilterFromQuery(url), limit = url.searchParams.get("limit"), limitValue = limit !== null ? Math.floor(Number(limit)) : void 0;
+  return {
+    ...filter,
+    groupBy,
+    ...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 jsonErrorResponse(fault.message, 400);
+  return shapeRestFault(fault);
+}
+export const aggregateWorkflowsRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/aggregate",
+  pathParamNames: [],
+  operationName: "weft.workflows.aggregate",
+  inputSources: {
+    status: { kind: "query", queryParam: "status", repeating: !0 },
+    type: { kind: "query", queryParam: "type" },
+    tags: { kind: "query", queryParam: "tag", repeating: !0 },
+    idPrefix: { kind: "query", queryParam: "id_prefix" },
+    limit: { kind: "query", queryParam: "limit" },
+    groupBy: { kind: "query", queryParam: "group_by" }
+  },
+  extractInput: async (request) => extractAggregateWorkflowsInput(request),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeAggregateWorkflowsSuccess(output),
+  shapeFault: shapeAggregateWorkflowsFault
+};

package/dist/server/operations/async-activity.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const completeAsyncActivityInput: z.ZodObject<{
+    token: z.ZodString;
+    result: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * The failure payload is a *serializable* error description, not a live `Error`.
+ * The engine already reduces an async-activity failure to `message` + `name`
+ * before persisting it (`failAsyncActivity`), so nothing is lost by accepting
+ * the reduced shape over the wire — and a live `Error` cannot cross a transport
+ * boundary anyway.
+ */
+declare const failAsyncActivityInput: z.ZodObject<{
+    token: z.ZodString;
+    error: z.ZodObject<{
+        message: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const okOutput: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type CompleteAsyncActivityInput = z.infer<typeof completeAsyncActivityInput>;
+export type FailAsyncActivityInput = z.infer<typeof failAsyncActivityInput>;
+export type AsyncActivityOutput = z.infer<typeof okOutput>;
+export declare const completeAsyncActivityOperation: import("../operation-catalog.ts").OperationDefinition<{
+    token: string;
+    result?: unknown;
+}, {
+    ok: true;
+}>;
+export declare const failAsyncActivityOperation: import("../operation-catalog.ts").OperationDefinition<{
+    token: string;
+    error: {
+        message: string;
+        name?: string | undefined;
+    };
+}, {
+    ok: true;
+}>;
+export declare const completeAsyncActivityRestBinding: UnknownRestBinding;
+export declare const failAsyncActivityRestBinding: UnknownRestBinding;
+export {};