@promptctl/cc-candybar 1.29.0 → 1.31.0

package/src/render/action.ts

@@ -27,16 +27,20 @@ import { toString as varToString } from "../var-system/types.js";
 import { buildScope } from "../template-engine/scope.js";
 import type { ActionDecl } from "../config/action.js";
 import { resolveOptionDomain } from "../config/option-domain.js";
+import { encodeLayoutOp, type LayoutOp } from "../config/layout-ops.js";
 import type { StripStyle } from "../themes/policy.js";
 import {
   effectsUrl,
+  VERB_APPLY_LAYOUT_OP,
   VERB_COPY,
   VERB_OPEN_VSCODE,
+  VERB_REDO,
   VERB_RESET_CONFIG,
   VERB_SET_CONFIG,
   VERB_SET_STATE,
   VERB_STEP_CONFIG,
   VERB_STEP_STATE,
+  VERB_UNDO,
   type Effect,
 } from "../click/wire.js";
 
@@ -135,7 +139,18 @@ export type CompiledActionDecl =
   // one config-overrides key. Carries only the key — there is no value to
   // realize, so it shares copy/open's "no gate" shape at compile time (the
   // GATE is the key-membership check the reset-config verb handler applies).
-  | { readonly kind: "reset"; readonly key: string };
+  | { readonly kind: "reset"; readonly key: string }
+  // [LAW:one-source-of-truth] brandon-layout-edit-2gc.1's structural-edit
+  // arms. Fully literal at compile time (the op IS the declaration — no
+  // template-bound option, unlike persist-option), so `op` is precomputed
+  // here rather than reconstructed from raw fields at every realize() call.
+  | { readonly kind: "layout-op"; readonly key: string; readonly op: LayoutOp }
+  // [LAW:one-source-of-truth] brandon-layout-edit-2gc.2's global history
+  // step over the overrides layer — `reset`'s fine-grained sibling. No key:
+  // there is nothing to carry, since the history stack (not this action) is
+  // what decides which entry moves.
+  | { readonly kind: "undo" }
+  | { readonly kind: "redo" };
 
 export type CompiledActions = ReadonlyMap<string, CompiledActionDecl>;
 
@@ -294,6 +309,25 @@ function compileAction(
         members: action.cycle,
       };
     }
+    if ("removeSegment" in action) {
+      return {
+        kind: "layout-op",
+        key: action.persist,
+        op: { op: "remove", target: action.removeSegment },
+      };
+    }
+    if ("insertSegment" in action) {
+      return {
+        kind: "layout-op",
+        key: action.persist,
+        op: {
+          op: "insert",
+          segment: action.insertSegment,
+          anchor: action.anchor,
+          relation: action.relation,
+        },
+      };
+    }
     return {
       kind: "persist-bounded",
       key: action.persist,
@@ -312,7 +346,10 @@ function compileAction(
       target: parseActionTemplate(parse, action.open, name),
     };
   }
-  return { kind: "reset", key: action.reset };
+  if ("reset" in action) {
+    return { kind: "reset", key: action.reset };
+  }
+  return "undo" in action ? { kind: "undo" } : { kind: "redo" };
 }
 
 function parseActionTemplate(
@@ -522,6 +559,34 @@ function realize(
         effect: { verb: VERB_RESET_CONFIG, args: [sessionId, c.key] },
         active: false,
       };
+    // [LAW:one-source-of-truth] No key to carry — the click just says "step
+    // the history", and which entry moves is entirely server-side state
+    // (never wire input, so there is nothing here to gate). Never "active":
+    // a history step is a one-shot trigger, not a current-selection toggle.
+    case "undo":
+      return {
+        effect: { verb: VERB_UNDO, args: [sessionId] },
+        active: false,
+      };
+    case "redo":
+      return {
+        effect: { verb: VERB_REDO, args: [sessionId] },
+        active: false,
+      };
+    // [LAW:one-source-of-truth] The op is fixed at compile time (see
+    // compileAction) — the click just delivers it. `apply-layout-op`'s
+    // handler does read-current-append-write (see verbs/index.ts), unlike
+    // persist-literal's plain overwrite, so it is its own verb rather than
+    // VERB_SET_CONFIG. Never "active": a structural edit is a one-shot
+    // trigger, not a current-selection toggle.
+    case "layout-op":
+      return {
+        effect: {
+          verb: VERB_APPLY_LAYOUT_OP,
+          args: [sessionId, c.key, encodeLayoutOp(c.op)],
+        },
+        active: false,
+      };
   }
 }