@promptctl/cc-candybar 1.30.0 → 1.32.0

package/src/config/loader/actions.ts

@@ -145,6 +145,8 @@ const ACTION_ARMS: Record<ActionKey, ArmParse<ActionDecl>> = {
   copy: templateArm("copy"),
   open: templateArm("open"),
   reset: resetArm,
+  undo: markerArm("undo"),
+  redo: markerArm("redo"),
 };
 
 // [LAW:one-source-of-truth] A copy/open action emits the closed single-key
@@ -170,6 +172,8 @@ function actionDeclJson(): JsonNode {
       templateArmJson("copy"),
       templateArmJson("open"),
       templateArmJson("reset"),
+      markerArmJson("undo"),
+      markerArmJson("redo"),
     ],
   };
 }
@@ -228,6 +232,47 @@ function resetArm(
   return key === null ? null : { reset: key };
 }
 
+// [LAW:one-type-per-behavior] `undo`/`redo` are copy/open/reset's shape one
+// step further reduced: a single required key whose only legal VALUE is the
+// literal `true` (mirrors intMarkerSpec — a marker, not data), because there
+// is no key to name: the history they step is one global stack over the
+// whole overrides layer, not a per-target write. `function`, not a const
+// arrow, so ACTION_ARMS above (built before this declaration in source
+// order) can reference it directly via hoisting.
+function markerArm(key: "undo" | "redo"): ArmParse<ActionDecl> {
+  return (ctx, path, raw) => {
+    for (const k of Object.keys(raw)) {
+      if (k !== key)
+        issue(
+          ctx,
+          `${path}.${k}`,
+          `Unknown key "${k}" on a ${key} action. Expected only: ${key}`,
+        );
+    }
+    if (raw[key] !== true) {
+      issue(
+        ctx,
+        `${path}.${key}`,
+        `${key} must be the literal true (it takes no key — it steps the ONE global history over the whole overrides layer), got ${describeValue(raw[key])}`,
+      );
+      return null;
+    }
+    return { [key]: true } as unknown as ActionDecl;
+  };
+}
+
+// [LAW:one-source-of-truth] Mirrors templateArmJson's shape one level
+// narrower: the value schema is `const: true`, not `type: string` — a
+// marker action carries no data, on the wire or in the schema.
+function markerArmJson(key: "undo" | "redo"): JsonNode {
+  return {
+    type: "object",
+    properties: { [key]: { const: true } },
+    required: [key],
+    additionalProperties: false,
+  };
+}
+
 // ─── The `set` value-source sub-union ────────────────────────────────────────
 
 // [LAW:single-enforcer] A set-state URL path segment must be a non-empty,
@@ -343,6 +388,20 @@ const INSERT_SEGMENT_FIELDS: FieldSpecMap<{
   anchor: layoutNameSpec("anchor"),
   relation: relationSpec(),
 };
+// [LAW:one-type-per-behavior] `insertSegmentFrom`'s payload mirrors
+// `insertSegment`'s verbatim except the segment name is a `from`-shaped
+// OptionDomain (fromSpec, the SAME field `set`/`persist … from` already
+// validate) instead of a literal layout name — the "to" vs "from" split every
+// other value source already draws, one arm over.
+const INSERT_SEGMENT_FROM_FIELDS: FieldSpecMap<{
+  insertSegmentFrom: OptionDomain;
+  anchor: string;
+  relation: "before" | "after";
+}> = {
+  insertSegmentFrom: fromSpec("persist"),
+  anchor: layoutNameSpec("anchor"),
+  relation: relationSpec(),
+};
 
 // [LAW:types-are-the-program] A bounded step is fully described by an integer
 // domain (min < max) and a non-zero integer increment (`by`; negative for a
@@ -395,12 +454,25 @@ interface ValueSourceArm {
   readonly parse: ArmParse<Partial<ActionDecl>>;
 }
 
+// [LAW:no-mode-explosion] `detectKeys` narrows WHICH of an arm's fields the
+// present-count dispatch keys off, independent of `allowed`/`label` (still
+// the full field set — what the arm PERMITS and is NAMED by never changes).
+// Every arm before insertSegmentFrom had a field set disjoint from every
+// other arm's, so `Object.keys(fieldMap)` was a safe default for both jobs
+// at once. insertSegmentFrom breaks that: it shares `anchor`/`relation` with
+// insertSegment (same POSITION shape, different segment-name SOURCE), so
+// dispatching on the full set would make an ordinary `insertSegment` action
+// spuriously match both arms via those shared keys. Pass the true
+// discriminator (the field no sibling arm carries) here; omit it when the
+// field set already is disjoint from every sibling, as it is everywhere else.
 function valueSourceArm<P extends object>(
   discriminator: "set" | "persist",
   fieldMap: FieldSpecMap<P>,
-  ...checks: ReadonlyArray<Refinement<P>>
+  checks: ReadonlyArray<Refinement<P>> = [],
+  detectKeys?: readonly string[],
 ): ValueSourceArm {
-  const detect = Object.keys(fieldMap);
+  const fullKeys = Object.keys(fieldMap);
+  const detect = detectKeys ?? fullKeys;
   const inner: ArmParse<P> = (ctx, path, raw) =>
     fields(ctx, fieldMap, path, raw);
   const source = objectJson(fieldMap) as {
@@ -409,8 +481,8 @@ function valueSourceArm<P extends object>(
   };
   return {
     detect,
-    allowed: [discriminator, ...detect],
-    label: detect.join("/"),
+    allowed: [discriminator, ...fullKeys],
+    label: fullKeys.join("/"),
     json: {
       type: "object",
       properties: { [discriminator]: { type: "string" }, ...source.properties },
@@ -430,7 +502,7 @@ function valueSourceArm<P extends object>(
 const SET_ARMS: readonly ValueSourceArm[] = [
   valueSourceArm("set", TO_FIELDS_SET),
   valueSourceArm("set", FROM_FIELDS_SET),
-  valueSourceArm("set", BOUNDED_FIELDS, minLessThanMax, byNonZero),
+  valueSourceArm("set", BOUNDED_FIELDS, [minLessThanMax, byNonZero]),
   valueSourceArm("set", INT_FIELDS),
   valueSourceArm("set", CYCLE_FIELDS_SET),
 ];
@@ -442,10 +514,21 @@ const SET_ARMS: readonly ValueSourceArm[] = [
 const PERSIST_ARMS: readonly ValueSourceArm[] = [
   valueSourceArm("persist", TO_FIELDS_PERSIST),
   valueSourceArm("persist", FROM_FIELDS_PERSIST),
-  valueSourceArm("persist", BOUNDED_FIELDS, minLessThanMax, byNonZero),
+  valueSourceArm("persist", BOUNDED_FIELDS, [minLessThanMax, byNonZero]),
   valueSourceArm("persist", CYCLE_FIELDS_PERSIST),
   valueSourceArm("persist", REMOVE_SEGMENT_FIELDS),
-  valueSourceArm("persist", INSERT_SEGMENT_FIELDS),
+  // [LAW:no-mode-explosion] Both insertSegment arms narrow detectKeys to
+  // their own discriminating field — see valueSourceArm's own comment. They
+  // share "anchor"/"relation" (same position shape, different segment-name
+  // source), so dispatching on the full field set would make EITHER arm
+  // spuriously match an action declaring the other.
+  valueSourceArm("persist", INSERT_SEGMENT_FIELDS, [], ["insertSegment"]),
+  valueSourceArm(
+    "persist",
+    INSERT_SEGMENT_FROM_FIELDS,
+    [],
+    ["insertSegmentFrom"],
+  ),
 ];
 
 // [LAW:one-source-of-truth] The clause list, not the joined string, is the
@@ -466,6 +549,7 @@ function valueSourceClauses(discriminator: "set" | "persist"): string[] {
     clauses.push(
       `"removeSegment" (remove a named segment from the layout)`,
       `"insertSegment"/"anchor"/"relation" (insert a named segment before/after an existing one)`,
+      `"insertSegmentFrom"/"anchor"/"relation" (insert a segment PICKED from an option domain before/after an existing one)`,
     );
   }
   return clauses;
@@ -590,7 +674,7 @@ function fromSpec(discriminator: "set" | "persist"): FieldSpec<OptionDomain> {
       const at = `${path}.${field}`;
       if (typeof from === "string") {
         if (from === "") {
-          issue(ctx, at, `from must be a non-empty domain name`);
+          issue(ctx, at, `${field} must be a non-empty domain name`);
           return undefined;
         }
         return from;
@@ -601,7 +685,7 @@ function fromSpec(discriminator: "set" | "persist"): FieldSpec<OptionDomain> {
           issue(
             ctx,
             at,
-            `from must name a domain (a non-empty string) or declare an inline domain (a non-empty array of values)`,
+            `${field} must name a domain (a non-empty string) or declare an inline domain (a non-empty array of values)`,
           );
           return undefined;
         }
@@ -609,7 +693,7 @@ function fromSpec(discriminator: "set" | "persist"): FieldSpec<OptionDomain> {
           issue(
             ctx,
             at,
-            `from array members must be non-empty — an empty value cannot be delivered on the ${wire} wire`,
+            `${field} array members must be non-empty — an empty value cannot be delivered on the ${wire} wire`,
           );
           return undefined;
         }
@@ -618,7 +702,7 @@ function fromSpec(discriminator: "set" | "persist"): FieldSpec<OptionDomain> {
           issue(
             ctx,
             at,
-            `from array member(s) ${slashed.map((m) => `"${m}"`).join(", ")} contain "/" — ${discriminator} values must be slash-free`,
+            `${field} array member(s) ${slashed.map((m) => `"${m}"`).join(", ")} contain "/" — ${discriminator} values must be slash-free`,
           );
           return undefined;
         }
@@ -626,7 +710,7 @@ function fromSpec(discriminator: "set" | "persist"): FieldSpec<OptionDomain> {
           issue(
             ctx,
             at,
-            `from array members must be unique — a duplicated value would render the same picker option twice`,
+            `${field} array members must be unique — a duplicated value would render the same picker option twice`,
           );
           return undefined;
         }
@@ -635,7 +719,7 @@ function fromSpec(discriminator: "set" | "persist"): FieldSpec<OptionDomain> {
       issue(
         ctx,
         at,
-        `from must be a domain name (a string) or an inline domain (an array of strings), got ${describeValue(from)}`,
+        `${field} must be a domain name (a string) or an inline domain (an array of strings), got ${describeValue(from)}`,
       );
       return undefined;
     },

package/src/config/loader/cross-ref.ts

@@ -15,8 +15,10 @@ import {
 } from "../dsl-types.js";
 import {
   actionBindsPersist,
+  actionBindsRedo,
   actionBindsReset,
   actionBindsSet,
+  actionBindsUndo,
   type ActionDecl,
 } from "../action.js";
 import {
@@ -394,10 +396,14 @@ function checkPresetRootOpsTarget(
   if (discriminator === "reset") return;
   const hasRemove = "removeSegment" in a;
   const hasInsert = "insertSegment" in a;
-  if (!hasRemove && !hasInsert) {
+  // [LAW:one-source-of-truth] brandon-layout-edit-2gc.3's domain-sourced
+  // sibling — the segment name is picked at render, so only `anchor` (still
+  // literal at author time) needs the declared-segment check below.
+  const hasInsertFrom = "insertSegmentFrom" in a;
+  if (!hasRemove && !hasInsert && !hasInsertFrom) {
     ctx.issues.push({
       path: at,
-      message: `actions.${name}: "${key}" is a "presets.<name>.rootOps" target and can only be paired with "removeSegment" or "insertSegment" (not "to"/"from"/"cycle"/bounded — those have no meaning as a tree op)`,
+      message: `actions.${name}: "${key}" is a "presets.<name>.rootOps" target and can only be paired with "removeSegment", "insertSegment", or "insertSegmentFrom" (not "to"/"from"/"cycle"/bounded — those have no meaning as a tree op)`,
       line,
     });
     return;
@@ -427,6 +433,13 @@ function checkPresetRootOpsTarget(
       });
     }
   }
+  if (hasInsertFrom && "insertSegmentFrom" in a && missing(a.anchor)) {
+    ctx.issues.push({
+      path: at,
+      message: `actions.${name}: anchor "${a.anchor}" is not a declared segment (have: ${Object.keys(cfg.segments).join(", ")})`,
+      line,
+    });
+  }
 }
 
 function hasStateKind(cfg: DslConfig): boolean {
@@ -442,15 +455,22 @@ function hasStateKind(cfg: DslConfig): boolean {
   return false;
 }
 
-// [LAW:dataflow-not-control-flow] A config emits a set-state, set-config, OR
-// reset-config click — and so needs session.id — when any declared action is
-// a `set` (literal/option/bounded/cycle), a `persist` (its config-overrides
-// twin), or a `reset` (persist's gated undo) — all three carry session.id on
-// the wire for click-error surfacing. copy/open actions write nothing, so
-// they embed no session.id.
+// [LAW:dataflow-not-control-flow] A config emits a set-state, set-config,
+// reset-config, undo, OR redo click — and so needs session.id — when any
+// declared action is a `set` (literal/option/bounded/cycle), a `persist`
+// (its config-overrides twin), a `reset` (persist's gated undo), or an
+// `undo`/`redo` (the overrides layer's global history step) — all five
+// carry session.id on the wire for click-error surfacing (an empty history
+// stack is a loud, session-scoped miss, not a silent no-op). copy/open
+// actions write nothing, so they embed no session.id.
 function hasActionSetAction(cfg: DslConfig): boolean {
   return Object.values(cfg.actions).some(
-    (a) => actionBindsSet(a) || actionBindsPersist(a) || actionBindsReset(a),
+    (a) =>
+      actionBindsSet(a) ||
+      actionBindsPersist(a) ||
+      actionBindsReset(a) ||
+      actionBindsUndo(a) ||
+      actionBindsRedo(a),
   );
 }
 

package/src/config/loader/edit-mode.ts

@@ -0,0 +1,111 @@
+// [LAW:one-source-of-truth] brandon-layout-edit-2gc.3's TOGGLE half of edit
+// mode — the disclosure primitive's third body-kind, one register down from
+// group sugar and `{{ menu }}`: where those two synthesize a whole trigger +
+// body, edit mode synthesizes only the on/off state + toggle ACTION here
+// (`edit.mode` / `edit.toggle`), so a hand-authored `{{ action "edit.toggle"
+// "✎" }}` cross-ref-checks and compiles exactly like any other action — no
+// bespoke "this action always exists" carve-out anywhere downstream. The
+// per-segment +/- CHROME is a separate, LATER pass
+// (src/config/edit-chrome.ts) that runs on the fully merged, preset-resolved,
+// rootOps-replayed config (inside validateConfig, not here) because it needs
+// data — which segments are in which preset's CURRENT tree — that does not
+// exist yet at this per-file parse stage. Splitting the two halves across two
+// synthesis points is not incidental: the toggle is authorable/cross-ref-able
+// content (like a group's name or a menu's apply action), the chrome is
+// derived data (like a group's lowered body), and each belongs at the stage
+// that has what it needs.
+//
+// [LAW:carrying-cost] DEMAND-DRIVEN, not unconditional — this is the one place
+// this pass diverges from group/menu synthesis's OWN precedent of "reserve
+// unconditionally, synthesize on demand" and leans fully into the "on demand"
+// half: a config that references `{{ action "edit.toggle" … }}` nowhere gets
+// NEITHER the toggle var/action NOR (edit-chrome.ts checks for the SAME
+// action's presence) any per-segment chrome. This matters concretely, not just
+// as a purity concern — `edit.mode` is a `state` variable and `edit.toggle` is
+// a `set` action, and cross-ref.ts requires a global `session.id` variable the
+// instant ANY state var or set action exists anywhere in a config. Synthesizing
+// either unconditionally would force session.id onto every purely-static,
+// non-interactive bar in the corpus — exactly the regression an early version
+// of this pass caused. The reserved namespace stays reserved unconditionally
+// (mirroring reservedNamespaceCollisions' own contract); only the SYNTHESIS is
+// conditional.
+
+import { createEngine } from "@promptctl/go-template-js";
+import type { Mutable, ValidateCtx } from "./validate-core.js";
+import type { RawDslConfig, VariableDecl } from "../dsl-types.js";
+import type { ActionDecl } from "../action.js";
+import {
+  DISCLOSURE_CLOSED,
+  disclosureCycleAction,
+  disclosureStateVar,
+} from "../disclosure.js";
+import { reservedNamespaceCollisions } from "./reserved-namespace.js";
+
+// [LAW:one-source-of-truth] The reserved namespace every edit-mode artifact —
+// this toggle AND edit-chrome.ts's per-position +/- actions/segments — lives
+// under, mirroring `groups.`/`menus.`. Exported so edit-chrome.ts's LATER
+// synthesis (and its `isChromeExempt` exclusion of edit-mode's own chrome
+// from being treated as ordinary, removable/addable content) reads the same
+// string, never a second copy.
+export const EDIT_NS = "edit.";
+
+// [LAW:single-enforcer] The SessionState key edit mode's on/off state lives
+// at, and the toggle action's identity member. Both edit-chrome.ts (every
+// synthesized affordance's `when` gate) and a hand-authored trigger segment
+// read/write these same two names — one declaration, no drift.
+export const EDIT_MODE_KEY = "edit.mode";
+export const EDIT_TOGGLE_ACTION = "edit.toggle";
+export const EDIT_MODE_OPEN = "open";
+
+// [LAW:one-source-of-truth] The predicate every synthesized +/- chrome
+// segment gates on — spelled once here so edit-chrome.ts never hand-rolls
+// the template string a second time.
+export const EDIT_MODE_GATE = `{{ eq .${EDIT_MODE_KEY} "${EDIT_MODE_OPEN}" }}`;
+
+// [LAW:single-enforcer] The ONE detector for "does this file want edit mode":
+// a literal `{{ action "edit.toggle" … }}` call somewhere a segment's
+// template/bg/fg can reach — the SAME AST-based approach
+// menu-synth.ts's segmentReferencesMenu uses (robust against whitespace,
+// pipelines, and lookalike text a source-string scan would false-positive
+// or false-negative on), one function name over. A bare engine purely for
+// introspection: it never evaluates, so a malformed template simply yields
+// no match here (registerDslConfig re-parses and reports the real error;
+// [LAW:no-silent-failure] this pass just isn't the one that reports it).
+function referencesEditToggle(template: string): boolean {
+  const engine = createEngine<string>({ fromString: (s) => s });
+  try {
+    return engine
+      .parse(template)
+      .referencedCalls()
+      .some((c) => c.name === "action" && c.args[0] === EDIT_TOGGLE_ACTION);
+  } catch {
+    return false;
+  }
+}
+
+function fileWantsEditMode(out: Readonly<RawDslConfig>): boolean {
+  for (const seg of Object.values(out.segments ?? {})) {
+    for (const field of [seg.template, seg.bg, seg.fg] as const) {
+      if (typeof field === "string" && referencesEditToggle(field)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+export function synthesizeEditModeToggle(
+  ctx: ValidateCtx,
+  out: Mutable<RawDslConfig>,
+): void {
+  reservedNamespaceCollisions(ctx, out, EDIT_NS, "edit mode");
+  if (!fileWantsEditMode(out)) return;
+  const variables: Record<string, VariableDecl> = {
+    [EDIT_MODE_KEY]: disclosureStateVar(EDIT_MODE_KEY, DISCLOSURE_CLOSED),
+  };
+  const actions: Record<string, ActionDecl> = {
+    [EDIT_TOGGLE_ACTION]: disclosureCycleAction(EDIT_MODE_KEY, EDIT_MODE_OPEN),
+  };
+  out.variables = { ...(out.variables ?? {}), ...variables };
+  out.actions = { ...(out.actions ?? {}), ...actions };
+}