@promptctl/cc-candybar 1.26.0 → 1.27.0

package/src/config/loader/actions.ts

@@ -1,26 +1,28 @@
 // [LAW:types-are-the-program] The action-table schema. An ActionDecl is
-// discriminated by exactly-one-of set/copy/open; a `set` adds exactly-one value
-// SOURCE (to/from/min-max-by/int). The proof here is what lets every downstream
-// consumer (renderAction, deriveActionValidators) match on the present key with
-// no fallthrough. Whether a `{{ action "name" }}` reference resolves is a
-// cross-ref concern. This file changes when the action vocabulary changes.
+// discriminated by exactly-one-of set/persist/copy/open/reset; a `set` or
+// `persist` adds exactly-one value SOURCE (to/from/min-max-by/int — `persist`
+// excludes `int`). The proof here is what lets every downstream consumer
+// (renderAction, deriveActionValidators, deriveConfigActionValidators) match
+// on the present key with no fallthrough. Whether a `{{ action "name" }}`
+// reference resolves is a cross-ref concern. This file changes when the
+// action vocabulary changes.
 //
 // [LAW:no-mode-explosion] Unlike cache (single-key value-arms → oneOfPresent) and
 // variables (tag-by-field-value → taggedUnion), an action's arms are multi-key
-// RECORDS: a `set` carries `set` plus a value-source group (`to` | `from` |
-// `min`/`max`/`by` | `int`). A single key never selects an arm, so the shared
-// present-key engine doesn't fit — bending it to would mean per-arm sibling
-// allow-lists and bespoke unknown-key messages bolted on as modes. Instead the
-// leaf machinery is shared (`fields` + `refine` + field specs carry every arm's
-// shape and cross-field invariant as DATA) and this file owns only the thin total
-// present-key dispatch — the irreducible union eliminator.
+// RECORDS: a `set`/`persist` carries the discriminator plus a value-source group
+// (`to` | `from` | `min`/`max`/`by` | `int`). A single key never selects an arm, so
+// the shared present-key engine doesn't fit — bending it to would mean per-arm
+// sibling allow-lists and bespoke unknown-key messages bolted on as modes. Instead
+// the leaf machinery is shared (`fields` + `refine` + field specs carry every arm's
+// shape and cross-field invariant as DATA, parameterized by discriminator name so
+// `set` and `persist` share one field-map definition) and this file owns only the
+// thin total present-key dispatch — the irreducible union eliminator.
 
 import {
   ACTION_KEYS,
-  OPTION_SOURCES,
   type ActionDecl,
   type ActionKey,
-  type OptionSource,
+  type OptionDomain,
 } from "../action.js";
 import { findKeyLine } from "./diagnostics.js";
 import {
@@ -116,18 +118,38 @@ function validateActionDecl(
 }
 
 // [LAW:dataflow-not-control-flow] The top-level arm table as DATA: copy/open share
-// one template-arm shape (their key names the only difference); set delegates to
-// its value-source sub-union. The present key indexes this map — the eliminator
-// never branches on the key name.
+// one template-arm shape (their key names the only difference); set/persist
+// delegate to their value-source sub-union (the SAME field shapes, a different
+// discriminator key — see valueSourceAction); reset is copy/open's plain-string
+// sibling. The present key indexes this map — the eliminator never branches on
+// the key name.
 const ACTION_ARMS: Record<ActionKey, ArmParse<ActionDecl>> = {
-  set: validateSetAction,
+  set: (ctx, path, raw) =>
+    valueSourceAction(
+      ctx,
+      path,
+      raw,
+      "set",
+      SET_ARMS,
+      "the SessionState key to write",
+    ),
+  persist: (ctx, path, raw) =>
+    valueSourceAction(
+      ctx,
+      path,
+      raw,
+      "persist",
+      PERSIST_ARMS,
+      "the config globals field to write",
+    ),
   copy: templateArm("copy"),
   open: templateArm("open"),
+  reset: resetArm,
 };
 
 // [LAW:one-source-of-truth] A copy/open action emits the closed single-key
 // object its arm validates — symmetric to `templateArm(key)`'s parse.
-function templateArmJson(key: "copy" | "open"): JsonNode {
+function templateArmJson(key: "copy" | "open" | "reset"): JsonNode {
   return {
     type: "object",
     properties: { [key]: { type: "string" } },
@@ -136,16 +158,18 @@ function templateArmJson(key: "copy" | "open"): JsonNode {
   };
 }
 
-// [LAW:one-source-of-truth] One ActionDecl's schema: the set sub-union (each
-// arm's `json`, derived from SET_ARMS) joined with copy/open — the SAME members
-// `validateActionDecl` dispatches over. The `actions` block is a name → ActionDecl
-// map, symmetric to `validateActions`.
+// [LAW:one-source-of-truth] One ActionDecl's schema: the set/persist sub-unions
+// (each arm's `json`, derived from SET_ARMS/PERSIST_ARMS) joined with
+// copy/open/reset — the SAME members `validateActionDecl` dispatches over. The
+// `actions` block is a name → ActionDecl map, symmetric to `validateActions`.
 function actionDeclJson(): JsonNode {
   return {
     anyOf: [
       ...SET_ARMS.map((arm) => arm.json),
+      ...PERSIST_ARMS.map((arm) => arm.json),
       templateArmJson("copy"),
       templateArmJson("open"),
+      templateArmJson("reset"),
     ],
   };
 }
@@ -173,6 +197,37 @@ function templateArm(key: "copy" | "open"): ArmParse<ActionDecl> {
   };
 }
 
+// [LAW:one-type-per-behavior] `reset` is copy/open's shape (a single required
+// string, no other keys) but the string is a KEY (a config globals field name),
+// not a template — no Go-template parsing happens for it, so it reuses the
+// slash-free/non-empty shape `set`/`persist` keys share rather than
+// requireString's bare-presence check. A `function` declaration (not a const
+// arrow) so it is hoisted — ACTION_ARMS above references it directly, not
+// through a deferred closure.
+function resetArm(
+  ctx: ValidateCtx,
+  path: string,
+  raw: Record<string, unknown>,
+): ActionDecl | null {
+  for (const k of Object.keys(raw)) {
+    if (k !== "reset")
+      issue(
+        ctx,
+        `${path}.${k}`,
+        `Unknown key "${k}" on a reset action. Expected only: reset`,
+      );
+  }
+  const key = slashFreeString(
+    ctx,
+    path,
+    "reset",
+    raw,
+    `reset key must be non-empty (the config globals field to clear)`,
+    (v) => `reset key "${v}" contains "/" — keys must be slash-free`,
+  );
+  return key === null ? null : { reset: key };
+}
+
 // ─── The `set` value-source sub-union ────────────────────────────────────────
 
 // [LAW:single-enforcer] A set-state URL path segment must be a non-empty,
@@ -205,41 +260,69 @@ function slashFreeString(
   return v;
 }
 
-// [LAW:dataflow-not-control-flow] The `set` key is validated once for every value
-// source (it is shared across all set arms), before the source is detected — so a
-// bad key and an ambiguous source both surface in one pass, matching the
-// hand-rolled order. It is therefore NOT a field of any arm's `fields` map; the
-// arm parses only the value-source payload, and the dispatcher re-attaches `set`.
-function validateSetKey(
+// [LAW:dataflow-not-control-flow] The discriminator key ("set" or "persist")
+// is validated once for every value source (it is shared across all arms of
+// that discriminator), before the source is detected — so a bad key and an
+// ambiguous source both surface in one pass. It is therefore NOT a field of
+// any arm's `fields` map; the arm parses only the value-source payload, and
+// the dispatcher re-attaches the discriminator.
+function validateValueSourceKey(
   ctx: ValidateCtx,
   path: string,
   raw: Record<string, unknown>,
+  discriminator: "set" | "persist",
+  keyNoun: string,
 ): string | null {
   return slashFreeString(
     ctx,
     path,
-    "set",
+    discriminator,
     raw,
-    `set key must be non-empty (the SessionState key to write)`,
-    (v) => `set key "${v}" contains "/" — state keys must be slash-free`,
+    `${discriminator} key must be non-empty (${keyNoun})`,
+    (v) => `${discriminator} key "${v}" contains "/" — keys must be slash-free`,
   );
 }
 
+// [LAW:one-source-of-truth] The wire verb name a discriminator's writes
+// travel over — `set-state` for `set` (SessionState), `set-config` for
+// `persist` (the config-overrides layer). Threaded into the shared field
+// specs below so their "cannot be delivered on the X wire" messages name
+// the wire the value actually crosses, and the field/value noun ("set
+// value" / "persist value") names the actual action kind, not always `set`.
+function wireName(discriminator: "set" | "persist"): string {
+  return discriminator === "set" ? "set-state" : "set-config";
+}
+
 // [LAW:types-are-the-program] Each value source's payload as a field map — the
-// non-`set` keys that source carries. `fields` runs every spec (reporting all
-// issues) and fails the arm when a required field is absent or invalid; `refine`
-// adds the cross-field invariants `fields` cannot express. The reconstructed
-// payload IS the member minus `set`, which the dispatcher re-attaches.
-const TO_FIELDS: FieldSpecMap<{ to: string }> = { to: setLiteralSpec() };
-const FROM_FIELDS: FieldSpecMap<{ from: OptionSource }> = { from: fromSpec() };
+// non-discriminator keys that source carries. `fields` runs every spec
+// (reporting all issues) and fails the arm when a required field is absent or
+// invalid; `refine` adds the cross-field invariants `fields` cannot express.
+// The reconstructed payload IS the member minus the discriminator, which the
+// dispatcher re-attaches. Built once per discriminator (`set`/`persist` share
+// field SHAPE but not error WORDING — see setLiteralSpec/fromSpec/cycleSpec).
+const TO_FIELDS_SET: FieldSpecMap<{ to: string }> = {
+  to: setLiteralSpec("set"),
+};
+const TO_FIELDS_PERSIST: FieldSpecMap<{ to: string }> = {
+  to: setLiteralSpec("persist"),
+};
+const FROM_FIELDS_SET: FieldSpecMap<{ from: OptionDomain }> = {
+  from: fromSpec("set"),
+};
+const FROM_FIELDS_PERSIST: FieldSpecMap<{ from: OptionDomain }> = {
+  from: fromSpec("persist"),
+};
 const BOUNDED_FIELDS: FieldSpecMap<{ min: number; max: number; by: number }> = {
   min: requireIntSpec(),
   max: requireIntSpec(),
   by: requireIntSpec(),
 };
 const INT_FIELDS: FieldSpecMap<{ int: true }> = { int: intMarkerSpec() };
-const CYCLE_FIELDS: FieldSpecMap<{ cycle: readonly string[] }> = {
-  cycle: cycleSpec(),
+const CYCLE_FIELDS_SET: FieldSpecMap<{ cycle: readonly string[] }> = {
+  cycle: cycleSpec("set"),
+};
+const CYCLE_FIELDS_PERSIST: FieldSpecMap<{ cycle: readonly string[] }> = {
+  cycle: cycleSpec("persist"),
 };
 
 // [LAW:types-are-the-program] A bounded step is fully described by an integer
@@ -270,29 +353,34 @@ const byNonZero: Refinement<BoundedPayload> = {
   }),
 };
 
-// [LAW:types-are-the-program] A set arm is its payload field map plus its
-// refinements; `detect` (the non-`set` keys whose presence selects it), `allowed`
-// (those keys plus `set`, the unknown-key allow-list), and `label` (the source
-// name in the exactly-one message — the detect keys joined by "/") all DERIVE from
-// the field map, so the field set is the single source for what the arm parses,
-// permits, and is named by.
-interface SetArm {
+// [LAW:types-are-the-program] A value-source arm is its payload field map plus
+// its refinements; `detect` (the non-discriminator keys whose presence
+// selects it), `allowed` (those keys plus the discriminator, the unknown-key
+// allow-list), and `label` (the source name in the exactly-one message — the
+// detect keys joined by "/") all DERIVE from the field map, so the field set
+// is the single source for what the arm parses, permits, and is named by.
+// Parameterized by `discriminator` ("set" | "persist") so `set` and `persist`
+// share the identical to/from/min-max-by/cycle shapes without duplicating
+// their field maps — only the discriminator's NAME differs in the emitted
+// object shape and the reconstructed member.
+interface ValueSourceArm {
   readonly detect: readonly string[];
   readonly allowed: readonly string[];
   readonly label: string;
-  // [LAW:one-source-of-truth] The arm's emit facet: the closed object schema for
-  // a `set` of this source — the shared `set` key plus the source's own fields,
-  // derived from the SAME field map `fields` validates. Cross-field refinements
-  // (min<max, by≠0) are unexpressible in JSON Schema, so only the structural
-  // shape is emitted — the shape/meaning split every refinement keeps.
+  // [LAW:one-source-of-truth] The arm's emit facet: the closed object schema
+  // for this discriminator's value source — the discriminator key plus the
+  // source's own fields, derived from the SAME field map `fields` validates.
+  // Cross-field refinements (min<max, by≠0) are unexpressible in JSON Schema,
+  // so only the structural shape is emitted.
   readonly json: JsonNode;
   readonly parse: ArmParse<Partial<ActionDecl>>;
 }
 
-function setArm<P extends object>(
+function valueSourceArm<P extends object>(
+  discriminator: "set" | "persist",
   fieldMap: FieldSpecMap<P>,
   ...checks: ReadonlyArray<Refinement<P>>
-): SetArm {
+): ValueSourceArm {
   const detect = Object.keys(fieldMap);
   const inner: ArmParse<P> = (ctx, path, raw) =>
     fields(ctx, fieldMap, path, raw);
@@ -302,12 +390,12 @@ function setArm<P extends object>(
   };
   return {
     detect,
-    allowed: ["set", ...detect],
+    allowed: [discriminator, ...detect],
     label: detect.join("/"),
     json: {
       type: "object",
-      properties: { set: { type: "string" }, ...source.properties },
-      required: ["set", ...(source.required ?? [])],
+      properties: { [discriminator]: { type: "string" }, ...source.properties },
+      required: [discriminator, ...(source.required ?? [])],
       additionalProperties: false,
     },
     parse: (checks.length
@@ -316,40 +404,60 @@ function setArm<P extends object>(
   };
 }
 
-// [LAW:dataflow-not-control-flow] The value-source arms in the order their labels
-// appear in the exactly-one message. A `set` declares exactly one of these; the
-// dispatcher counts presence over `detect` and reconstructs `{ set, ...payload }`.
-const SET_ARMS: readonly SetArm[] = [
-  setArm(TO_FIELDS),
-  setArm(FROM_FIELDS),
-  setArm(BOUNDED_FIELDS, minLessThanMax, byNonZero),
-  setArm(INT_FIELDS),
-  setArm(CYCLE_FIELDS),
+// [LAW:dataflow-not-control-flow] The value-source arms in the order their
+// labels appear in the exactly-one message. A `set` declares exactly one of
+// these; the dispatcher counts presence over `detect` and reconstructs
+// `{ set, ...payload }`.
+const SET_ARMS: readonly ValueSourceArm[] = [
+  valueSourceArm("set", TO_FIELDS_SET),
+  valueSourceArm("set", FROM_FIELDS_SET),
+  valueSourceArm("set", BOUNDED_FIELDS, minLessThanMax, byNonZero),
+  valueSourceArm("set", INT_FIELDS),
+  valueSourceArm("set", CYCLE_FIELDS_SET),
+];
+
+// [LAW:one-type-per-behavior] `persist` mirrors `set` minus the `int` arm — a
+// page cursor is a UI-only paging concept with no meaning as a persisted
+// config default (see action.ts's ActionDecl comment).
+const PERSIST_ARMS: readonly ValueSourceArm[] = [
+  valueSourceArm("persist", TO_FIELDS_PERSIST),
+  valueSourceArm("persist", FROM_FIELDS_PERSIST),
+  valueSourceArm("persist", BOUNDED_FIELDS, minLessThanMax, byNonZero),
+  valueSourceArm("persist", CYCLE_FIELDS_PERSIST),
 ];
 
-const VALUE_SOURCE_MESSAGE = `a set action declares exactly one value source: "to" (a literal value), "from" (an option domain: ${OPTION_SOURCES.join(
-  "/",
-)}), "min"/"max"/"by" (a bounded step), "int" (an unbounded integer cursor), or "cycle" (an enumerated domain stepped in order)`;
+const VALUE_SOURCE_MESSAGE = (discriminator: "set" | "persist") =>
+  `a ${discriminator} action declares exactly one value source: "to" (a literal value), "from" (an option domain — a registered domain name like "themes"/"styles"/"looks", or an inline array of literal values), "min"/"max"/"by" (a bounded step)${discriminator === "set" ? `, "int" (an unbounded integer cursor)` : ""}, or "cycle" (an enumerated domain stepped in order)`;
 
-// [LAW:dataflow-not-control-flow] The set sub-union eliminator: validate the
-// shared `set` key, count which value sources are present, require exactly one,
-// reject keys outside that arm's allow-list, parse the payload, reconstruct the
-// member. The variability (which arms, each arm's fields/refinements/allow-list)
-// is the SET_ARMS data; the only branches are the presence-count and the
-// null-threading both the key and the payload share.
-function validateSetAction(
+// [LAW:dataflow-not-control-flow] The set/persist sub-union eliminator:
+// validate the shared discriminator key, count which value sources are
+// present, require exactly one, reject keys outside that arm's allow-list,
+// parse the payload, reconstruct the member. The variability (which arms,
+// each arm's fields/refinements/allow-list) is the `arms` data; the only
+// branches are the presence-count and the null-threading both the key and
+// the payload share.
+function valueSourceAction(
   ctx: ValidateCtx,
   path: string,
   raw: Record<string, unknown>,
+  discriminator: "set" | "persist",
+  arms: readonly ValueSourceArm[],
+  keyNoun: string,
 ): ActionDecl | null {
-  const stateKey = validateSetKey(ctx, path, raw);
+  const stateKey = validateValueSourceKey(
+    ctx,
+    path,
+    raw,
+    discriminator,
+    keyNoun,
+  );
 
-  const present = SET_ARMS.filter((arm) => arm.detect.some((k) => k in raw));
+  const present = arms.filter((arm) => arm.detect.some((k) => k in raw));
   if (present.length !== 1) {
     issue(
       ctx,
       path,
-      `${VALUE_SOURCE_MESSAGE}${
+      `${VALUE_SOURCE_MESSAGE(discriminator)}${
         present.length > 1
           ? ` — found: ${present.map((a) => a.label).join(", ")}`
           : ""
@@ -364,21 +472,24 @@ function validateSetAction(
       issue(
         ctx,
         `${path}.${k}`,
-        `Unknown key "${k}" on this set action. Expected one of: ${arm.allowed.join(", ")}`,
+        `Unknown key "${k}" on this ${discriminator} action. Expected one of: ${arm.allowed.join(", ")}`,
       );
   }
 
   const payload = arm.parse(ctx, path, raw);
   return stateKey === null || payload === null
     ? null
-    : ({ set: stateKey, ...payload } as unknown as ActionDecl);
+    : ({ [discriminator]: stateKey, ...payload } as unknown as ActionDecl);
 }
 
-// [LAW:no-silent-fallbacks] A literal `to` and the `set` key share the
-// non-empty/slash-free shape — the set-state wire rejects empty values and splits
-// on "/", so either is undeliverable. The empty/slash messages are this arm's,
-// the shape is the shared enforcer's.
-function setLiteralSpec(): FieldSpec<string> {
+// [LAW:no-silent-fallbacks] A literal `to` and the discriminator key share
+// the non-empty/slash-free shape — the wire rejects empty values and splits
+// on "/", so either is undeliverable. The empty/slash messages are this
+// arm's, the shape is the shared enforcer's. Built once per discriminator
+// (see TO_FIELDS_SET/TO_FIELDS_PERSIST) so a `persist` action's message names
+// "persist value" and the set-config wire, never `set`'s wording.
+function setLiteralSpec(discriminator: "set" | "persist"): FieldSpec<string> {
+  const wire = wireName(discriminator);
   return {
     required: true,
     json: { type: "string" },
@@ -388,45 +499,108 @@ function setLiteralSpec(): FieldSpec<string> {
         path,
         field,
         raw,
-        `set value must be non-empty — an empty value cannot be delivered on the set-state wire`,
-        (v) => `set value "${v}" contains "/" — set values must be slash-free`,
+        `${discriminator} value must be non-empty — an empty value cannot be delivered on the ${wire} wire`,
+        (v) =>
+          `${discriminator} value "${v}" contains "/" — ${discriminator} values must be slash-free`,
       ) ?? undefined,
   };
 }
 
-// [LAW:types-are-the-program] `from` is a required member of the closed
-// OPTION_SOURCES domain — the option set a picker ranges. A non-member is a hard
-// error with the bespoke one-of message, never a silent fallback.
-function fromSpec(): FieldSpec<OptionSource> {
+// [LAW:types-are-the-program] `from` is either a NAME (a non-empty string,
+// resolved against the option-domain registry) or an INLINE literal domain (a
+// non-empty array of deliverable wire values — the same non-empty/
+// slash-free wire shape `to` and `cycle` members enforce, plus the same
+// uniqueness `cycleSpec` requires: a duplicate has no successor-ambiguity
+// concern here, but it would render the same picker cell twice for no
+// benefit). This arm proves only the SHAPE; whether a named domain actually
+// resolves needs the merged config's per-config domains (e.g. "looks"), so
+// that check is a cross-reference concern (validateCrossReferences) —
+// symmetric to how a layout node's segment ref or a `{{ action }}` ref
+// resolves post-merge. Built once per discriminator, same reason as
+// setLiteralSpec.
+function fromSpec(discriminator: "set" | "persist"): FieldSpec<OptionDomain> {
+  const wire = wireName(discriminator);
   return {
     required: true,
-    json: { enum: [...OPTION_SOURCES] },
+    json: {
+      anyOf: [
+        { type: "string", minLength: 1 },
+        {
+          type: "array",
+          items: { type: "string", minLength: 1 },
+          minItems: 1,
+          uniqueItems: true,
+        },
+      ],
+    },
     parse: (ctx, path, field, raw) => {
       const from = raw[field];
-      if (
-        typeof from !== "string" ||
-        !(OPTION_SOURCES as readonly string[]).includes(from)
-      ) {
-        issue(
-          ctx,
-          `${path}.${field}`,
-          `from must be one of: ${OPTION_SOURCES.join(", ")}, got ${describeValue(from)}`,
-        );
-        return undefined;
+      const at = `${path}.${field}`;
+      if (typeof from === "string") {
+        if (from === "") {
+          issue(ctx, at, `from must be a non-empty domain name`);
+          return undefined;
+        }
+        return from;
+      }
+      if (Array.isArray(from) && from.every((m) => typeof m === "string")) {
+        const members = from as string[];
+        if (members.length === 0) {
+          issue(
+            ctx,
+            at,
+            `from must name a domain (a non-empty string) or declare an inline domain (a non-empty array of values)`,
+          );
+          return undefined;
+        }
+        if (members.some((m) => m === "")) {
+          issue(
+            ctx,
+            at,
+            `from array members must be non-empty — an empty value cannot be delivered on the ${wire} wire`,
+          );
+          return undefined;
+        }
+        const slashed = members.filter((m) => m.includes("/"));
+        if (slashed.length > 0) {
+          issue(
+            ctx,
+            at,
+            `from array member(s) ${slashed.map((m) => `"${m}"`).join(", ")} contain "/" — ${discriminator} values must be slash-free`,
+          );
+          return undefined;
+        }
+        if (new Set(members).size !== members.length) {
+          issue(
+            ctx,
+            at,
+            `from array members must be unique — a duplicated value would render the same picker option twice`,
+          );
+          return undefined;
+        }
+        return members;
       }
-      return from as OptionSource;
+      issue(
+        ctx,
+        at,
+        `from must be a domain name (a string) or an inline domain (an array of strings), got ${describeValue(from)}`,
+      );
+      return undefined;
     },
   };
 }
 
 // [LAW:types-are-the-program] `cycle` is the enumerated domain a click steps
 // through: at least two members (one member has no successor to step to — that
-// is a literal `to`), each a deliverable set-state value (non-empty, slash-free
+// is a literal `to`), each a deliverable wire value (non-empty, slash-free
 // — the same wire shape `to` enforces), no duplicates (the successor of a
 // duplicated member is ambiguous). Members double as the derived allow-list
 // gate, so a member this spec admits is a value the wire delivers, by
-// construction.
-function cycleSpec(): FieldSpec<readonly string[]> {
+// construction. Built once per discriminator, same reason as setLiteralSpec.
+function cycleSpec(
+  discriminator: "set" | "persist",
+): FieldSpec<readonly string[]> {
+  const wire = wireName(discriminator);
   return {
     required: true,
     json: {
@@ -461,7 +635,7 @@ function cycleSpec(): FieldSpec<readonly string[]> {
         issue(
           ctx,
           at,
-          `cycle members must be non-empty — an empty value cannot be delivered on the set-state wire`,
+          `cycle members must be non-empty — an empty value cannot be delivered on the ${wire} wire`,
         );
         return undefined;
       }
@@ -469,7 +643,7 @@ function cycleSpec(): FieldSpec<readonly string[]> {
         issue(
           ctx,
           at,
-          `cycle member(s) ${slashed.map((m) => `"${m}"`).join(", ")} contain "/" — set values must be slash-free`,
+          `cycle member(s) ${slashed.map((m) => `"${m}"`).join(", ")} contain "/" — ${discriminator} values must be slash-free`,
         );
         return undefined;
       }