@setluca/mcp 0.2.1 → 0.3.0

package/dist/operations/groups/memory.js

@@ -4,24 +4,22 @@ export const memoryOperations = [
         id: "memory.list",
         title: "List what Luca remembers",
         description: "List what Luca remembers, filtered by lead, scope, source, trust level, or free text. The fact, the reasoning, and the quoted evidence are blanked for a redacted-tier key; trust level, lead, and dates always come back.",
-        redactedFields: [
-            "memories[].content",
-            "memories[].evidence",
-            "memories[].reason",
-        ],
     }),
     op({
         id: "memory.update",
         title: "Edit a memory",
+        mutatesExisting: true,
         // The corrected memory comes back in full, and a memory is a fact Luca
         // extracted from what a lead wrote.
         untrustedContent: true,
         description: "Correct one memory: edit the fact, flag it disputed when it turns out to be wrong, restore an archived one, or make it win over a conflicting memory.",
-        redactedFields: ["content", "evidence", "reason"],
     }),
     op({
         id: "memory.setArchived",
+        // Answers with ids and status flags only; no lead-authored text.
+        untrustedContent: false,
         title: "Archive or restore memories",
+        mutatesExisting: true,
         description: "Archive or restore several memories at once. Archiving stops Luca using a fact while the record and its provenance survive, so it is always reversible.",
     }),
 ];

package/dist/operations/groups/reports.js

@@ -8,7 +8,7 @@ export const reportsOperations = [
     op({
         id: "reports.morning",
         title: "Read the morning report",
+        untrustedContent: true,
         description: "Structured 24h review-queue digest (items + counts) for the coach. No model call; summarize client-side.",
-        redactedFields: ["items[].draftBody"],
     }),
 ];

package/dist/operations/groups/reviewQueue.js

@@ -4,44 +4,44 @@ export const reviewQueueOperations = [
         id: "reviewQueue.list",
         title: "List the review queue",
         description: "List review-queue items when the API key has review queue access.",
-        redactedFields: [
-            "items[].criticIssues",
-            "items[].draftBody",
-            "items[].draftParts",
-            "items[].leadDisplayName",
-            "items[].media",
-            "items[].mediaContext",
-            "items[].objectionVariants",
-            "items[].qualification",
-            "items[].safetyFindings",
-            "items[].signals",
-        ],
     }),
     op({
         id: "reviewQueue.explain",
         title: "Explain a queued draft",
         description: "Explain the signals behind a drafted reply: its voice-match score, any critic findings, and the qualification that motivated it.",
-        redactedFields: ["criticIssues", "draftBody", "qualification"],
     }),
     op({
         id: "reviewQueue.approve",
+        // Answers with ids and status flags only; no lead-authored text.
+        untrustedContent: false,
         title: "Approve and send a queued draft",
-        confirmRequired: true,
+        openWorld: true,
+        mutatesExisting: true,
+        confirm: "always",
         description: "Approve a pending draft for sending; dispatches through the lead's channel. Sends a real message.",
     }),
     op({
         id: "reviewQueue.reject",
+        // Answers with ids and status flags only; no lead-authored text.
+        untrustedContent: false,
         title: "Reject a queued draft",
+        mutatesExisting: true,
         description: "Reject a pending review-queue draft so it never sends. Stops any related booking-recovery cadence and emits review.rejected.",
     }),
     op({
         id: "reviewQueue.restore",
+        // Answers with ids and status flags only; no lead-authored text.
+        untrustedContent: false,
         title: "Restore a rejected draft",
+        mutatesExisting: true,
         description: "Restore a rejected review-queue item back to pending. Fails if it's a booking message whose recovery window already passed.",
     }),
     op({
         id: "reviewQueue.media.retry",
+        // Answers with ids and status flags only; no lead-authored text.
+        untrustedContent: false,
         title: "Retry a draft's failed media",
+        mutatesExisting: true,
         description: "Retry a failed voice-note transcription so the draft can be reviewed. Only re-transcribes; never redrafts or sends.",
     }),
     op({
@@ -51,7 +51,10 @@ export const reviewQueueOperations = [
     }),
     op({
         id: "reviewQueue.objectionVariant",
+        // Answers with ids and status flags only; no lead-authored text.
+        untrustedContent: false,
         title: "Record an objection variant choice",
+        mutatesExisting: true,
         description: "Record which objection-specialist variant was picked for one queued draft. It is how the objection tests learn which handling works, so record the variant the coach actually chose.",
     }),
 ];

package/dist/operations/groups/safety.js

@@ -3,6 +3,6 @@ export const safetyOperations = [
     op({
         id: "safety.accounts",
         title: "Check connected account safety",
-        description: "Read each connected channel account's safety status, 24-hour send count, and human-approval window. An account inside its approval window must not be automated against.",
+        description: "Read each connected channel account's safety status and 24-hour send count.",
     }),
 ];

package/dist/operations/groups/voice.js

@@ -9,6 +9,5 @@ export const voiceOperations = [
         id: "voice.corpus",
         title: "Read the coach's voice corpus",
         description: "List the coach's voice corpus: the writing every draft is matched against. Entry id, source, channel, and age always come back; the writing itself is blanked for a redacted-tier key.",
-        redactedFields: ["entries[].content"],
     }),
 ];

package/dist/operations/groups/webhooks.js

@@ -8,6 +8,10 @@ export const webhooksOperations = [
     op({
         id: "webhooks.subscriptions.create",
         title: "Create a webhook subscription",
+        openWorld: true,
+        mutatesExisting: true,
+        // Starts streaming workspace events to an outside URL.
+        confirm: "always",
         // Naturally idempotent: an active subscription with the same target URL
         // is updated in place (target URLs are unique per Zap/scenario webhook),
         // so this route requires no Idempotency-Key (see the matching comment on
@@ -17,6 +21,9 @@ export const webhooksOperations = [
     op({
         id: "webhooks.subscriptions.update",
         title: "Update a webhook subscription",
+        openWorld: true,
+        // Can point the event stream at a different outside URL.
+        confirm: "always",
         description: "Update an outbound webhook subscription.",
     }),
     op({
@@ -31,6 +38,8 @@ export const webhooksOperations = [
     op({
         id: "webhooks.testDelivery",
         title: "Send a test webhook",
+        openWorld: true,
+        confirm: "always",
         description: "Queue a canonical test webhook event.",
     }),
     op({
@@ -46,7 +55,8 @@ export const webhooksOperations = [
     op({
         id: "webhooks.deliveries.replay",
         title: "Replay a webhook delivery",
-        confirmRequired: true,
+        openWorld: true,
+        confirm: "always",
         description: "Replay one webhook delivery without changing the event id. Re-triggers the subscriber's downstream automation.",
     }),
     op({
@@ -64,13 +74,15 @@ export const webhooksOperations = [
     op({
         id: "webhooks.events.replay",
         title: "Replay a webhook event",
-        confirmRequired: true,
+        openWorld: true,
+        confirm: "always",
         description: "Replay one canonical webhook event. Re-triggers subscribers' downstream automations.",
     }),
     op({
         id: "webhooks.events.bulkReplay",
         title: "Replay a batch of webhook events",
-        confirmRequired: true,
+        openWorld: true,
+        confirm: "always",
         description: "Bulk replay webhook events by type and time range. Re-triggers downstream automations at scale.",
     }),
 ];

package/dist/operations/manifest.js

@@ -1,6 +1,9 @@
 // Views derived from the operation table. Nothing here holds state of its own;
 // each function reads `LUCA_OPERATIONS` and reshapes it for one caller: the
 // `luca://operations` resource, the docs generator, or the registry check.
+import * as Arr from "effect/Array";
+import * as Order from "effect/Order";
+import * as R from "effect/Record";
 import { operationAnnotations } from "../annotations.js";
 import { LUCA_OPERATIONS } from "./catalog.js";
 import { LUCA_OPERATION_GROUPS } from "./registry.js";
@@ -13,8 +16,8 @@ export function operationManifest() {
         path: operation.path,
         scopes: operation.scopes,
         idempotencyRequired: operation.idempotencyRequired,
-        confirmRequired: operation.confirmRequired,
-        paginates: operation.pageShape !== undefined,
+        confirmRequired: operation.confirm !== undefined,
+        paginates: operation.pageContract !== undefined,
         untrustedContent: operation.untrustedContent,
         requiredScope: operation.requiredScope,
         annotations: operationAnnotations(operation),
@@ -22,7 +25,7 @@ export function operationManifest() {
     }));
 }
 export function operationGroups() {
-    return Object.entries(LUCA_OPERATION_GROUPS).map(([id, metadata]) => {
+    return R.toEntries(LUCA_OPERATION_GROUPS).map(([id, metadata]) => {
         const operations = LUCA_OPERATIONS.filter((operation) => operation.group === id);
         return {
             // SAFETY: Object.entries widens the key to `string`; the cast recovers
@@ -31,9 +34,7 @@ export function operationGroups() {
             title: metadata.title,
             description: metadata.description,
             toolCount: operations.length,
-            scopes: [
-                ...new Set(operations.flatMap((operation) => operation.scopes)),
-            ].sort(),
+            scopes: Arr.sort(Arr.dedupe(operations.flatMap((operation) => operation.scopes)), Order.String),
             tools: operations.map((operation) => operation.toolName),
         };
     });

package/dist/operations/registry.js

@@ -1,10 +1,19 @@
-import * as z from "zod/v4";
-import { OPENAPI_INPUTS } from "../generated/openapi-inputs.js";
-import { OPENAPI_OUTPUTS } from "../generated/openapi-outputs.js";
+import * as Arr from "effect/Array";
+import * as HashSet from "effect/HashSet";
+import * as P from "effect/Predicate";
+import * as R from "effect/Record";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import * as Str from "effect/String";
+import { mutatesExisting } from "../annotations.js";
+import { confirmInput, NonEmptyString, WORKSPACE_INPUT_FIELDS, } from "../fields.js";
+import { OPENAPI_INPUT_FIELDS } from "../generated/openapi-inputs.js";
+import { OPENAPI_OUTPUTS, OPENAPI_REDACTED_FIELDS, } from "../generated/openapi-outputs.js";
 import { ROUTE_CATALOG } from "../generated/route-catalog.js";
-import { openApiToolInputFields, openApiToolOutputFields, } from "../openapi-zod.js";
-import { optionalField } from "../optional-field.js";
-import { pageShapeFor } from "../page-shape.js";
+import { openApiToolOutputFields, } from "../openapi-schema.js";
+import { fieldsWhen, optionalField } from "../optional-field.js";
+import { pageContractFor } from "../page-contract.js";
+import { effectiveCapability } from "../scopes.js";
 export const LUCA_OPERATION_GROUPS = {
     capabilities: {
         title: "Capabilities",
@@ -60,7 +69,11 @@ export const LUCA_OPERATION_GROUPS = {
     },
     safety: {
         title: "Account Safety",
-        description: "Per-channel account health, send pacing, and the human-approval window.",
+        description: "Per-channel account health and send pacing.",
+    },
+    channels: {
+        title: "Channels",
+        description: "Connected channel accounts, which channels can be connected, and what each provider supports. Read-only.",
     },
     insights: {
         title: "Insights",
@@ -91,18 +104,35 @@ export const LUCA_OPERATION_GROUPS = {
         description: "Business intelligence, funnel analytics, revenue attribution, and coach performance metrics.",
     },
 };
+/** Whether this call has to carry `confirm: true` to run. */
+export function needsConfirmation(gate, input) {
+    if (gate === undefined) {
+        return false;
+    }
+    return gate === "always" || gate.applies(input);
+}
+/**
+ * The tier an operation needs: what its effect asks for, raised to whatever its
+ * API scopes need, so the tier a tool states is the one an OAuth connection
+ * has to request.
+ */
 function requiredScopeFor(input) {
     let capability = "draft";
     if (input.method === "GET") {
         capability = "read";
     }
-    else if (input.confirmRequired) {
+    else if (input.confirm === "always") {
         // Real-world side effect (sends, enrollments, replays) = operating the
-        // live queue.
+        // live queue. A write gated for only some inputs keeps its route's tier:
+        // the gate guards the risky inputs, and the others stay open to a
+        // connection below queue_ops.
         capability = "queue_ops";
     }
     return {
-        capability,
+        capability: effectiveCapability({
+            scopes: input.scopes,
+            requiredScope: { capability },
+        }),
         dataSensitivity: input.untrustedContent ? "full_content" : "redacted",
     };
 }
@@ -113,7 +143,7 @@ function requiredScopeFor(input) {
  * untrusted-content boundary so a downstream agent treats it as data, never as
  * instructions (prompt-injection defense).
  */
-const UNTRUSTED_CONTENT_GROUPS = new Set([
+const UNTRUSTED_CONTENT_GROUPS = HashSet.fromIterable([
     "callEvents",
     "conversations",
     "leads",
@@ -127,46 +157,18 @@ const UNTRUSTED_CONTENT_GROUPS = new Set([
 /** Server-side bounded auto-pagination guard for list tools. */
 export const DEFAULT_MAX_PAGES = 10;
 const MAX_PAGES_LIMIT = 50;
-const OPENAPI_INPUTS_BY_ROUTE = new Map(Object.entries(OPENAPI_INPUTS));
-const OPENAPI_OUTPUTS_BY_ROUTE = new Map(Object.entries(OPENAPI_OUTPUTS));
-export const WORKSPACE_INPUT_FIELDS = {
-    workspaceId: z
-        .uuid()
-        .optional()
-        .describe("Optional Luca workspace id override."),
-    workspaceSlug: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("Optional Luca workspace slug override."),
-};
+/** The generated records, read by a `METHOD path` key built at runtime. */
+const OPENAPI_OUTPUTS_BY_ROUTE = OPENAPI_OUTPUTS;
+const OPENAPI_REDACTED_FIELDS_BY_ROUTE = OPENAPI_REDACTED_FIELDS;
 const idempotencyInput = {
-    idempotencyKey: z
-        .string()
-        .min(1)
-        .optional()
-        .describe("Stable key for safe retries. If omitted, the MCP server generates a unique key for this call."),
-};
-/**
- * The confirmation gate's input field, shared by the generated operation tools
- * and the hand-written task tools. One wording covers both because a client
- * sees one tool list: the effects named here are the union of what either kind
- * can do, not a guess at which one the reader is holding.
- */
-export const confirmInput = {
-    confirm: z
-        .boolean()
-        .optional()
-        .describe("This tool has a real-world side effect: it messages a real lead, starts outbound touches, or re-triggers downstream automations. Pass confirm: true to proceed; the call is rejected without it."),
+    idempotencyKey: Schema.optionalKey(NonEmptyString.annotate({
+        description: "Stable key for safe retries. If omitted, the MCP server generates a unique key for this call.",
+    })),
 };
 const paginationInput = {
-    maxPages: z
-        .number()
-        .int()
-        .min(1)
-        .max(MAX_PAGES_LIMIT)
-        .optional()
-        .describe(`Max pages the server auto-fetches and merges (default ${DEFAULT_MAX_PAGES}, hard cap ${MAX_PAGES_LIMIT}). If more remain, the result is marked truncated with a nextCursor to continue.`),
+    maxPages: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: MAX_PAGES_LIMIT })).annotate({
+        description: `Max pages the server auto-fetches and merges (default ${DEFAULT_MAX_PAGES}, hard cap ${MAX_PAGES_LIMIT}). If more remain, the result is marked truncated with a nextCursor to continue.`,
+    })),
 };
 /**
  * Fold the fields every operation tool shares, meaning query, body, idempotency
@@ -185,52 +187,36 @@ function commonInput(input) {
         },
     };
 }
+/** The `{name}` placeholders in a route path, in order. */
+function pathParamNames(path) {
+    return Arr.filterMap(Array.from(path.matchAll(/\{([^}]+)\}/g)), ([, key]) => key === undefined ? Result.failVoid : Result.succeed(key));
+}
 function pathParams(input, path) {
-    const params = {};
-    for (const [, key] of path.matchAll(/\{([^}]+)\}/g)) {
-        // The capture group requires at least one character, so a match always
-        // carries a non-empty key. This guard exists to satisfy the compiler's
-        // view of `RegExpMatchArray`, and no path string can reach it.
-        // Stryker disable next-line ConditionalExpression,BlockStatement: unreachable, the capture group cannot match empty
-        if (!key) {
-            continue;
-        }
-        const value = z.string().safeParse(input[key]);
-        if (value.success) {
-            params[key] = value.data;
-        }
-    }
-    return params;
+    return R.fromEntries(Arr.filterMap(pathParamNames(path), (key) => {
+        const value = input[key];
+        return P.isString(value)
+            ? Result.succeed([key, value])
+            : Result.failVoid;
+    }));
 }
 function inputSchemaFor(input) {
-    const fields = openApiToolInputFields({
-        spec: OPENAPI_INPUTS_BY_ROUTE.get(`${input.method} ${input.path}`),
-        workspaceInput: WORKSPACE_INPUT_FIELDS,
-        idempotencyInput,
-        idempotencyRequired: input.idempotencyRequired,
-    });
-    if (input.confirmRequired) {
-        Object.assign(fields, confirmInput);
-    }
-    if (input.paginates) {
-        Object.assign(fields, paginationInput);
-    }
-    return fields;
+    return {
+        ...WORKSPACE_INPUT_FIELDS,
+        ...fieldsWhen(input.idempotencyRequired, idempotencyInput),
+        ...OPENAPI_INPUT_FIELDS[`${input.method} ${input.path}`],
+        ...fieldsWhen(input.confirm !== undefined, confirmInput),
+        ...fieldsWhen(input.paginates, paginationInput),
+    };
 }
 /**
- * Build an operation's output schema and, if it declares `redactedFields`
- * (see the `op()` parameter doc), attach an
- * `x-luca-redacted-fields` marker to `result` so an MCP client can tell those
- * fields may arrive blanked for a `redacted`-tier key. `.meta()` is metadata
- * only. It never affects `.parse()` or runtime validation, and it is defined
- * on the classic `z.ZodType` interface, not the core `$ZodType` that
- * `ZodFields` values are typed as. The cast is safe because every value
- * here is built by `schemaToZod()` in `openapi-zod.ts`, which only ever
- * constructs classic zod instances.
+ * Build an operation's output schema and, when `redactedFields` is non-empty,
+ * attach an `x-luca-redacted-fields` marker to `result` so an MCP client can
+ * tell those fields may arrive blanked for a `redacted`-tier key. The marker is
+ * an annotation only and never affects validation.
  */
 export function outputSchemaFor(input) {
     const fields = openApiToolOutputFields({
-        body: OPENAPI_OUTPUTS_BY_ROUTE.get(`${input.method} ${input.path}`),
+        body: OPENAPI_OUTPUTS_BY_ROUTE[`${input.method} ${input.path}`],
         untrustedContent: input.untrustedContent,
     });
     // This guard also runs while `LUCA_OPERATIONS` is built at module
@@ -241,14 +227,13 @@ export function outputSchemaFor(input) {
     // registers as a survivor. The branch itself is real and covered: the absent,
     // empty, and populated cases all assert on the marker.
     // Stryker disable next-line LogicalOperator,BooleanLiteral: crashes at import, leaving no test to attribute the kill to
-    if (!input.redactedFields || input.redactedFields.length === 0) {
+    if (!input.redactedFields || Arr.isReadonlyArrayEmpty(input.redactedFields)) {
         return fields;
     }
+    const result = fields.result ?? Schema.Unknown;
     return {
         ...fields,
-        // openApiToolOutputFields always sets `result`; ZodRawShape's index
-        // signature cannot express that invariant.
-        result: z.any().pipe(fields.result).meta({
+        result: result.annotate({
             "x-luca-redacted-fields": input.redactedFields,
         }),
     };
@@ -267,6 +252,15 @@ function operationGroupForId(id) {
     const [group] = id.split(".");
     return group;
 }
+/**
+ * The MCP tool name for an operation id: `luca_` plus the id in snake_case,
+ * so `analytics.speedImpact` becomes `luca_analytics_speed_impact`. Task
+ * tools are named the same way, and one casing across the list is what
+ * clients and models see.
+ */
+function toolNameFor(id) {
+    return `luca_${id.split(".").map(Str.camelToSnake).join("_")}`;
+}
 /**
  * Declare one 1:1 operation tool. The route's id says which allowlisted route
  * it is; {@link ROUTE_CATALOG} answers with the method, path, scopes, and
@@ -276,36 +270,36 @@ function operationGroupForId(id) {
  * ({@link inputSchemaFor}), the required scope tier ({@link requiredScopeFor}),
  * the untrusted-content boundary, and a `buildRequest` that maps tool input to
  * an HTTP request. What stays here is what only the tool surface knows: the
- * title, the agent-facing description, the confirmation gate, and which fields
- * can come back blanked. Task tools (composed, intent-level) are declared
- * separately in `task-tools.ts`.
+ * title, the agent-facing description, and the confirmation gate. Which fields
+ * can come back blanked is read off the route's `sensitive()` markers in
+ * {@link OPENAPI_REDACTED_FIELDS}. Task tools (composed, intent-level) are
+ * declared separately in `task-tools.ts`.
  */
 export function op(input) {
     const route = ROUTE_CATALOG[input.id];
-    // SAFETY: `ROUTE_CATALOG` is generated from the allowlist and its methods are
-    // the ones the public API serves; the snapshot carries them as plain strings.
-    const method = route.method;
-    const { path, scopes, idempotencyRequired } = route;
-    const confirmRequired = input.confirmRequired ?? false;
-    const pageShape = pageShapeFor(method, path);
+    const { method, path, scopes, idempotencyRequired } = route;
+    const mutatesExistingRoute = input.mutatesExisting ?? mutatesExisting(method);
+    const pageContract = pageContractFor(method, path);
     const group = operationGroupForId(input.id);
-    const untrustedContent = input.untrustedContent ??
-        (method === "GET" && UNTRUSTED_CONTENT_GROUPS.has(group));
+    const untrustedContent = input.untrustedContent ?? HashSet.has(UNTRUSTED_CONTENT_GROUPS, group);
     const operation = {
         id: input.id,
         group,
-        toolName: `luca_${input.id.replaceAll(".", "_")}`,
+        toolName: toolNameFor(input.id),
         title: input.title,
         method,
         path,
         scopes,
+        mutatesExisting: mutatesExistingRoute,
         idempotencyRequired,
-        confirmRequired,
-        ...optionalField("pageShape", pageShape),
+        ...optionalField("confirm", input.confirm),
+        openWorld: input.openWorld ?? false,
+        ...optionalField("pageContract", pageContract),
         untrustedContent,
         requiredScope: requiredScopeFor({
             method,
-            confirmRequired,
+            scopes,
+            confirm: input.confirm,
             untrustedContent,
         }),
         description: input.description,
@@ -313,14 +307,14 @@ export function op(input) {
             method,
             path,
             idempotencyRequired,
-            confirmRequired,
-            paginates: pageShape !== undefined,
+            confirm: input.confirm,
+            paginates: pageContract !== undefined,
         }),
         outputSchema: outputSchemaFor({
             method,
             path,
             untrustedContent,
-            ...optionalField("redactedFields", input.redactedFields),
+            ...optionalField("redactedFields", OPENAPI_REDACTED_FIELDS_BY_ROUTE[`${method} ${path}`]),
         }),
         buildRequest: (toolInput) => ({
             pathParams: pathParams(toolInput, path),

package/dist/operations.js

@@ -2,10 +2,11 @@
 // job under `./operations/`: `registry.ts` holds the types and the `op()`
 // machinery, `catalog.ts` holds the operation table, and `manifest.ts` holds
 // the views derived from it. What a client is told about a tool lives in
-// `../annotations.ts`, one level up, because both kinds of tool ask for it.
+// `../annotations.ts` and `../tool.ts`, one level up, because both kinds of
+// tool ask for it.
 // This file names each export rather than re-exporting with `export *`,
 // because a star barrel pulls the whole dependency graph into every importer.
 // The lint rule that forbids it is measuring real load cost, not style.
-export { LUCA_OPERATIONS } from "./operations/catalog.js";
+export { LUCA_OPERATIONS, operationById } from "./operations/catalog.js";
 export { operationGroups, operationManifest } from "./operations/manifest.js";
-export { confirmInput, DEFAULT_MAX_PAGES, outputSchemaFor, WORKSPACE_INPUT_FIELDS, } from "./operations/registry.js";
+export { DEFAULT_MAX_PAGES, needsConfirmation, outputSchemaFor, } from "./operations/registry.js";

package/dist/optional-field.js

@@ -1,12 +1,24 @@
-import { Option } from "effect";
+import * as Option from "effect/Option";
+import * as R from "effect/Record";
 export function optionalField(key, value) {
-    return Option.fromNullable(value).pipe(Option.match({
+    return Option.fromNullishOr(value).pipe(Option.match({
         // Returning `undefined` here instead of `{}` is indistinguishable at
         // every call site: the result is only ever spread, and spreading either
         // value contributes no keys. The empty object is written out because it
         // matches the declared return type.
         // Stryker disable next-line ArrowFunction: `...undefined` and `...{}` both contribute nothing
         onNone: () => ({}),
-        onSome: (present) => Object.fromEntries([[key, present]]),
+        onSome: (present) => R.fromEntries([[key, present]]),
     }));
 }
+/**
+ * Spreads the fields `build` makes from a value, or nothing when the value is
+ * absent. {@link optionalField} covers the single-key case.
+ */
+export function optionalFields(value, build) {
+    return Option.fromNullishOr(value).pipe(Option.match({ onNone: () => ({}), onSome: build }));
+}
+/** Spreads `fields` when `include` holds, or nothing when it does not. */
+export function fieldsWhen(include, fields) {
+    return include ? fields : {};
+}