@promptctl/cc-candybar 1.42.1 → 1.43.0

package/src/config/loader/cycles.ts

@@ -1,148 +0,0 @@
-// [LAW:types-are-the-program] Dependency-cycle detection over the variable graph.
-// Edges come from three sources (template refs, cache.key refs, cache.depends_on);
-// a single DFS catches mixed cycles spanning edge types. This file changes when
-// what constitutes a runtime dependency edge changes.
-
-import {
-  hasCacheField,
-  type DslConfig,
-  type VariableDecl,
-} from "../dsl-types.js";
-import { findKeyLine } from "./diagnostics.js";
-import { type ValidateCtx } from "./validate-core.js";
-import { extractTemplateRefs } from "./refs.js";
-
-// Carries declaration metadata for each graph node so cycle errors report the
-// correct config path (variables.X vs segments.S.vars.X) and correct line.
-interface NodeInfo {
-  readonly declarationPath: string;
-  readonly linePathParts: readonly string[];
-}
-
-export function validateNoCycles(ctx: ValidateCtx, cfg: DslConfig): void {
-  const { graph, nodeInfo } = buildTemplateGraph(cfg);
-
-  const WHITE = 0;
-  const GRAY = 1;
-  const BLACK = 2;
-  const color = new Map<string, number>();
-  const stack: string[] = [];
-
-  for (const node of graph.keys()) color.set(node, WHITE);
-
-  for (const start of graph.keys()) {
-    if (color.get(start) !== WHITE) continue;
-    if (dfs(start)) return; // first cycle is enough — report and stop walking
-  }
-
-  function dfs(node: string): boolean {
-    color.set(node, GRAY);
-    stack.push(node);
-    for (const next of graph.get(node) ?? []) {
-      const c = color.get(next);
-      if (c === GRAY) {
-        const cycleStart = stack.indexOf(next);
-        const cycle = [...stack.slice(cycleStart), next];
-        const firstNode = cycle[0]!;
-        const info = nodeInfo.get(firstNode);
-        ctx.issues.push({
-          path: info?.declarationPath ?? `variables.${firstNode}`,
-          message: `Dependency cycle: ${cycle.join(" → ")}`,
-          line: findKeyLine(
-            ctx.source,
-            info?.linePathParts ?? ["variables", firstNode],
-          ),
-        });
-        return true;
-      }
-      if (c === WHITE && dfs(next)) return true;
-    }
-    color.set(node, BLACK);
-    stack.pop();
-    return false;
-  }
-}
-
-// [LAW:types-are-the-program] Build the full variable dependency graph: edges
-// are X → Y for any of three edge kinds:
-//   1. template-kind vars: template string references Y (eval dependency)
-//   2. any var with cache.key: key template references Y (cache-key dependency)
-//   3. any var with cache.depends_on: each listed name is Y (invalidation dep)
-// All three kinds can form infinite loops at runtime; a single DFS catches
-// mixed cycles that span multiple edge types.
-//
-// Segment vars use the namespaced form (segName.varName) as their sole graph
-// node — eliminates bare-name collisions when two segments both declare a var
-// named e.g. "local". Global vars keep their bare names.
-function buildTemplateGraph(cfg: DslConfig): {
-  graph: Map<string, Set<string>>;
-  nodeInfo: Map<string, NodeInfo>;
-} {
-  const allVarNames = new Set<string>(Object.keys(cfg.variables));
-  const nodeInfo = new Map<string, NodeInfo>();
-
-  for (const name of Object.keys(cfg.variables)) {
-    nodeInfo.set(name, {
-      declarationPath: `variables.${name}`,
-      linePathParts: ["variables", name],
-    });
-  }
-  for (const [segName, seg] of Object.entries(cfg.segments)) {
-    if (!seg.vars) continue;
-    for (const vName of Object.keys(seg.vars)) {
-      const canonical = `${segName}.${vName}`;
-      allVarNames.add(canonical);
-      nodeInfo.set(canonical, {
-        declarationPath: `segments.${segName}.vars.${vName}`,
-        linePathParts: ["segments", segName, "vars", vName],
-      });
-    }
-  }
-
-  const graph = new Map<string, Set<string>>();
-  for (const name of allVarNames) graph.set(name, new Set());
-
-  // [LAW:one-source-of-truth] Edges resolve refs exactly as the runtime scope
-  // proxy does: a ref is the literal store key (globals bare, segment locals
-  // namespaced as segName.varName) — never re-derived per segment. Bare
-  // own-segment refs are not aliased here because the runtime has no such
-  // aliasing; cross-ref rejects them at load with the namespaced suggestion.
-  const addTemplateEdges = (from: string, template: string): void => {
-    for (const ref of extractTemplateRefs(template)) {
-      if (allVarNames.has(ref)) {
-        graph.get(from)!.add(ref);
-        continue;
-      }
-      // Resolve "first identifier" — `.session.id` may indicate dependence on
-      // `session` if that's the declared var (matches scope.ts proxy walk).
-      const head = ref.split(".")[0]!;
-      if (head !== ref && allVarNames.has(head)) {
-        graph.get(from)!.add(head);
-      }
-    }
-  };
-
-  const addVarEdges = (name: string, v: VariableDecl): void => {
-    if (v.kind === "template") addTemplateEdges(name, v.template);
-    if (hasCacheField(v)) {
-      if (v.cache && "key" in v.cache) addTemplateEdges(name, v.cache.key);
-      if (v.cache && "depends_on" in v.cache) {
-        for (const dep of v.cache.depends_on) {
-          if (allVarNames.has(dep)) graph.get(name)!.add(dep);
-        }
-      }
-    }
-  };
-
-  for (const [name, v] of Object.entries(cfg.variables)) {
-    addVarEdges(name, v);
-  }
-  for (const [segName, seg] of Object.entries(cfg.segments)) {
-    if (!seg.vars) continue;
-    for (const [vName, vDecl] of Object.entries(seg.vars)) {
-      addVarEdges(`${segName}.${vName}`, vDecl);
-    }
-  }
-
-  return { graph, nodeInfo };
-}

package/src/config/loader/diagnostics.ts

@@ -1,99 +0,0 @@
-// [LAW:single-enforcer] One home for config-error reporting: the public issue/
-// error types, the best-effort source-line lookup every validator calls, and the
-// human-readable formatter ConfigError renders. Changes here are display/source-
-// mapping changes; the schema validators never touch this file.
-
-// ─── Public types ────────────────────────────────────────────────────────────
-
-export interface ConfigIssue {
-  /** Dotted logical path inside the config (e.g., "variables.foo.cache"). */
-  readonly path: string;
-  /** Short, actionable description of the problem. */
-  readonly message: string;
-  /** Source line (1-based). For semantic errors, best-effort from the path. */
-  readonly line?: number;
-  /** Source column (1-based). Present only for parse errors. */
-  readonly col?: number;
-}
-
-export class ConfigError extends Error {
-  readonly file: string;
-  readonly issues: readonly ConfigIssue[];
-
-  constructor(file: string, issues: readonly ConfigIssue[]) {
-    super(formatIssues(file, issues));
-    this.name = "ConfigError";
-    this.file = file;
-    this.issues = issues;
-  }
-}
-
-// ─── Best-effort source-line lookup ──────────────────────────────────────────
-
-// Walk source forward, finding each path component as a JSON5 key in turn.
-// JSON5 keys are unquoted identifiers (`foo:`), double-quoted strings, or
-// single-quoted strings. Numeric path parts (e.g., layout indices) are
-// skipped — they point inside arrays where line lookup is less useful.
-//
-// This is "good enough" navigation, not a guarantee. Returns undefined if a
-// path part can't be located — the caller falls back to the logical path.
-export function findKeyLine(
-  source: string,
-  pathParts: readonly string[],
-): number | undefined {
-  let cursor = 0;
-  let foundCursor: number | undefined;
-  for (const part of pathParts) {
-    if (part === "" || /^\d+$/.test(part)) continue;
-    const found = findKeyOccurrence(source, cursor, part);
-    if (found === -1) {
-      return foundCursor !== undefined
-        ? lineFromOffset(source, foundCursor)
-        : undefined;
-    }
-    cursor = found;
-    foundCursor = found;
-  }
-  return foundCursor !== undefined
-    ? lineFromOffset(source, foundCursor)
-    : undefined;
-}
-
-function findKeyOccurrence(source: string, from: number, key: string): number {
-  // Match `<key>:` or `"<key>":` or `'<key>':` — any whitespace before the colon
-  // is allowed by JSON5. Escape regex specials in key.
-  const escaped = key.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
-  const re = new RegExp(`(?:["']${escaped}["']|\\b${escaped}\\b)\\s*:`, "g");
-  re.lastIndex = from;
-  const m = re.exec(source);
-  return m ? m.index : -1;
-}
-
-function lineFromOffset(source: string, offset: number): number {
-  let line = 1;
-  for (let i = 0; i < offset && i < source.length; i++) {
-    if (source.charCodeAt(i) === 0x0a) line++;
-  }
-  return line;
-}
-
-// ─── Error formatting ────────────────────────────────────────────────────────
-
-function formatIssues(file: string, issues: readonly ConfigIssue[]): string {
-  if (issues.length === 0) return `${file}: invalid config (no details)`;
-  const lines: string[] = [
-    `Invalid config in ${file} (${issues.length} issue${issues.length === 1 ? "" : "s"}):`,
-  ];
-  for (const issue of issues) {
-    const locParts: string[] = [];
-    if (issue.line !== undefined) {
-      locParts.push(
-        `line ${issue.line}${issue.col !== undefined ? `:${issue.col}` : ""}`,
-      );
-    }
-    if (issue.path) locParts.push(issue.path);
-    const loc = locParts.length > 0 ? `[${locParts.join(" • ")}] ` : "";
-    lines.push(`  ${loc}${issue.message}`);
-  }
-  return lines.join("\n");
-}

package/src/config/loader/discovery.ts

@@ -1,182 +0,0 @@
-// [LAW:single-enforcer] Config-file discovery: where the DSL config can live, in
-// what precedence, and how `~` expands. One candidate-path enumerator feeds the
-// resolver, the watchers, and the collision detector so none can disagree about
-// which files are candidates. This file changes when the resolution rules change.
-
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-// [LAW:one-source-of-truth] The set of accepted extensions lives here once.
-// Both .json5 and .json are accepted: JSON ⊂ JSON5, so the same parser
-// (JSON5.parse) handles both — only the filename lookup varies. Ordering is
-// load-bearing: .json5 wins over .json at the same location (documented
-// format > compatibility tail).
-const CONFIG_EXTENSIONS = ["json5", "json"] as const;
-
-// [LAW:single-enforcer] One implementation of `~`-prefix expansion, called at
-// each trust boundary that takes a user-supplied path. The CLI `--config`
-// value is expanded in `parseRenderArgs` (server.ts) before it ever reaches
-// here; `CC_CANDYBAR_CONFIG` is expanded below where the env var is read.
-// One function, one rule, two callers.
-//
-// [LAW:enumeration-gap] Only the shell-standard home-expansion forms trigger
-// replacement: bare `~`, `~/...`, or `~\...` on Windows. A string like
-// `~alice/cfg` (POSIX named-home lookup) is NOT expanded — we have no way
-// to resolve another user's home and a literal substitution would corrupt
-// the path (`<homedir>alice/cfg`).
-export function expandHome(p: string): string {
-  return p === "~" || p.startsWith("~/") || p.startsWith("~\\")
-    ? os.homedir() + p.slice(1)
-    : p;
-}
-
-/**
- * The full ordered list of candidate paths the DSL config could live at,
- * for a given (projectDir, cwd). Returned regardless of which exist — the
- * cache uses this to watch every candidate location so the creation of any
- * file in the resolution chain triggers hot-reload.
- *
- * `configFile` is the highest-precedence entry — the path resolved from the
- * client's `--config` flag (already `~`-expanded at the trust boundary in
- * server.ts). When present, it is the sole candidate and the rest of the
- * precedence chain is bypassed.
- *
- * [LAW:single-enforcer] One enumerator; `resolveDslConfigPath` finds the
- * first that exists, watchers listen on all of them, no second list.
- *
- * [LAW:dataflow-not-control-flow] Location is the dominant precedence axis;
- * extension breaks ties within a location. Encoded as a nested flat-map: each
- * location yields one path per extension in order. No branches on extension.
- */
-export function dslConfigCandidatePaths(
-  projectDir?: string,
-  cwd?: string,
-  configFile?: string,
-): readonly string[] {
-  // CLI --config wins over everything — highest precedence. Pre-expanded at
-  // the trust boundary; trust the type here.
-  if (configFile) {
-    return [configFile];
-  }
-
-  const envPath = process.env.CC_CANDYBAR_CONFIG;
-  if (envPath) {
-    // [LAW:single-enforcer] env-var is a separate trust boundary; expand here
-    // where the env is read, with the shared `expandHome` helper. [LAW:
-    // dataflow-not-control-flow] When the env var sets the path, it's the
-    // *only* candidate — the precedence chain collapses to one entry.
-    return [expandHome(envPath)];
-  }
-
-  const effectiveCwd = cwd ?? process.cwd();
-  const xdgConfigHome =
-    process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
-
-  return [
-    ...(projectDir
-      ? CONFIG_EXTENSIONS.map((ext) =>
-          path.join(projectDir, `.cc-candybar.${ext}`),
-        )
-      : []),
-    ...CONFIG_EXTENSIONS.map((ext) =>
-      path.join(effectiveCwd, `.cc-candybar.${ext}`),
-    ),
-    ...CONFIG_EXTENSIONS.map((ext) =>
-      path.join(xdgConfigHome, "cc-candybar", `config.${ext}`),
-    ),
-  ];
-}
-
-/**
- * Resolution order for the user's DSL config file:
- *   1. `configFile` (the CLI `--config <path>` value, already `~`-expanded)
- *   2. $CC_CANDYBAR_CONFIG env var (literal path, `~`-expanded here)
- *   3. `<projectDir>/.cc-candybar.json5`
- *   4. `<projectDir>/.cc-candybar.json`
- *   5. `<cwd>/.cc-candybar.json5`
- *   6. `<cwd>/.cc-candybar.json`
- *   7. `$XDG_CONFIG_HOME/cc-candybar/config.json5`
- *      (defaulting to `~/.config/cc-candybar/config.json5`)
- *   8. `$XDG_CONFIG_HOME/cc-candybar/config.json`
- *
- * Returns the first path that exists, or null if none do.
- *
- * [LAW:dataflow-not-control-flow] The locations array is data; the search is
- * `locations.find(fs.existsSync)`. Adding a layer is a new array entry, not a
- * new branch. Extension support is a property of the candidate list, not the
- * search.
- *
- * [LAW:single-enforcer] Built on top of `dslConfigCandidatePaths` — the
- * precedence list lives in one place.
- */
-export function resolveDslConfigPath(
-  projectDir?: string,
-  cwd?: string,
-  configFile?: string,
-): string | null {
-  return (
-    dslConfigCandidatePaths(projectDir, cwd, configFile).find(fs.existsSync) ??
-    null
-  );
-}
-
-/**
- * Detect same-location extension collisions: any location where BOTH
- * `<base>.json5` and `<base>.json` exist simultaneously. The resolver picks
- * .json5 (documented format wins), but the user almost certainly didn't
- * intend to keep two; the duplicate is dead weight that will drift.
- *
- * Returns a human-readable warning naming the conflicting files, or null if
- * no collisions exist. The render path surfaces this through the daemon's
- * diagnostics channel so the user sees it on every render until they remove
- * the duplicate.
- *
- * [LAW:single-enforcer] Consumes `dslConfigCandidatePaths` — same enumerator
- * as the resolver and watcher; collision detection cannot disagree with
- * resolution about which files are candidates.
- *
- * [LAW:dataflow-not-control-flow] Walk candidates, group by parent directory
- * + base name (without extension), find groups with size > 1 whose members
- * all exist. No special-case branches per extension.
- */
-export function detectConfigCollisions(
-  projectDir?: string,
-  cwd?: string,
-): string | null {
-  const candidates = dslConfigCandidatePaths(projectDir, cwd);
-  // [LAW:dataflow-not-control-flow] Dedupe candidates by full path first.
-  // When projectDir === cwd (a very common case — the daemon often resolves
-  // both from the same hook payload), the enumerator yields the same path
-  // at both precedence levels. That is a structural duplicate of *position
-  // in the precedence list*, not a same-location duplicate of *files on
-  // disk*. The latter is what collision detection is for; the former is
-  // noise that would fire a false positive.
-  const seen = new Set<string>();
-  const uniqueExisting: string[] = [];
-  for (const candidate of candidates) {
-    if (seen.has(candidate)) continue;
-    seen.add(candidate);
-    if (!fs.existsSync(candidate)) continue;
-    uniqueExisting.push(candidate);
-  }
-  // Group by (dir + base-without-extension). A group with > 1 existing
-  // member is a collision at that logical location.
-  const groups = new Map<string, string[]>();
-  for (const candidate of uniqueExisting) {
-    const dir = path.dirname(candidate);
-    const base = path.basename(candidate).replace(/\.(json5|json)$/, "");
-    const key = path.join(dir, base);
-    if (!groups.has(key)) groups.set(key, []);
-    groups.get(key)!.push(candidate);
-  }
-  const collisions = [...groups.values()].filter((g) => g.length > 1);
-  if (collisions.length === 0) return null;
-  // Stable, parseable message. The first file in each group is the .json5
-  // (the one that wins); the rest are the shadowed siblings.
-  const lines = collisions.map((g) => {
-    const [winner, ...shadowed] = g;
-    return `${winner} shadows ${shadowed.join(", ")}`;
-  });
-  return `config-extension collision: ${lines.join("; ")} — remove the duplicate`;
-}

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

@@ -1,137 +0,0 @@
-// [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.
-//
-// WHAT candybar-settings-ui-aok.1 CHANGED, and what it did not: the gate above
-// is intact and still the only way edit mode is reached — but it now has a
-// PERMANENT DEMANDER. synthesizeSettingsMenu mints a `settings.edit` segment
-// referencing `edit.toggle` into every config it can host, so in practice the
-// demand is satisfied for essentially every config a user writes, and reading
-// this section as "most bars carry no edit mode" is no longer true. The
-// separation the gate protects still holds exactly where it always mattered:
-// the menu declines to synthesize for a config with no `session.id`
-// (canHostSessionState in settings-menu.ts), which is precisely the static,
-// non-interactive bar this comment was written to keep clean. Production blast
-// radius was nil either way — the bundled default's `toolbar` segment already
-// referenced `edit.toggle`, so every config merging it already demanded edit
-// mode before the menu existed.
-
-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,
-  disclosureGate,
-  disclosureStateVar,
-  type DisclosureRef,
-} 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] Edit mode AS a disclosure, which is what it has
-// always been: a binary toggle over one SessionState key. Naming it as a ref
-// lets anything nested inside edit mode (a `(?)` and its body) derive its own
-// gate by conjunction with this one, instead of concatenating gate strings.
-export const EDIT_MODE_REF: DisclosureRef = {
-  variable: EDIT_MODE_KEY,
-  member: EDIT_MODE_OPEN,
-};
-
-// [LAW:one-source-of-truth] The predicate every synthesized +/- chrome
-// segment gates on — derived from the ref above through the same function
-// every other disclosure's gate comes from, so edit-mode chrome and a group
-// body are gated by one rule rather than by two spellings that agree today.
-export const EDIT_MODE_GATE = disclosureGate(EDIT_MODE_REF);
-
-// [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 };
-}

package/src/config/loader/emit-schema.ts

@@ -1,68 +0,0 @@
-// [LAW:one-source-of-truth] The JSON Schema emitter — the SECOND interpreter over
-// the declarative loader schemas. `validateConfig` composes the per-module
-// `validate*` functions to validate at runtime; `emitConfigSchema` composes the
-// per-module `*Json` functions to derive the editor-facing JSON Schema. Both read
-// the SAME module-private schema declarations (GLOBALS_SCHEMA, VARIABLE_SCHEMA,
-// SEGMENT_SCHEMA, CACHE_SCHEMA, SET_ARMS, the A-grammar layout grammar), so the
-// published schema and the runtime validator can never describe a different grammar.
-//
-// What a JSON Schema still cannot express (by construction): cross-field
-// refinements (min<max, by≠0, input default matches type), palette-name
-// membership, duration FORMAT, and cross-references between segments/variables/
-// cycles. Those stay SEMANTIC checks the loader carries — schema = shape, lint =
-// meaning, the same complementary boundary `config-schema.test.ts` pins.
-
-import { editGlobalsJson, globalsJson } from "./globals.js";
-import { variablesMapJson } from "./variables.js";
-import { segmentsJson } from "./segments.js";
-import { actionsJson } from "./actions.js";
-import { looksJson } from "./looks.js";
-import { presetsJson } from "./presets.js";
-import {
-  layoutNodeJson,
-  LAYOUT_NODE_DEF_NAME,
-  LAYOUT_NODE_REF,
-} from "./layout.js";
-import type { JsonNode } from "./validate-core.js";
-
-// [LAW:one-source-of-truth] The stable published identity. The committed artifact
-// is self-identifying at this URL so an editor loading it via `$schema` resolves.
-export const SCHEMA_ID =
-  "https://raw.githubusercontent.com/promptctl/cc-candybar/main/schema/cc-candybar.schema.json";
-
-// [LAW:dataflow-not-control-flow] The RawDslConfig schema: every top-level key is
-// optional (a user file declares only what differs from the bundled default), so
-// the object carries no `required`. Each property is one module's emitted shape —
-// the same composition `validateConfig` performs over the validators. `root`
-// references the LayoutNode definition that closes the node recursion via `$ref`.
-export function emitConfigSchema(): JsonNode {
-  return {
-    $schema: "http://json-schema.org/draft-07/schema#",
-    $id: SCHEMA_ID,
-    title: "cc-candybar config (.cc-candybar.json5)",
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      globals: globalsJson(),
-      variables: variablesMapJson(),
-      segments: segmentsJson(),
-      root: { $ref: LAYOUT_NODE_REF },
-      actions: actionsJson(),
-      looks: looksJson(),
-      presets: presetsJson(),
-      editGlobals: editGlobalsJson(),
-      helpers: { type: "object", additionalProperties: { type: "string" } },
-    },
-    definitions: {
-      [LAYOUT_NODE_DEF_NAME]: layoutNodeJson(),
-    },
-  };
-}
-
-// [LAW:single-enforcer] One serialization, shared by `gen:schema` (writes the
-// committed artifact) and `check:schema` (byte-diffs against it) so the two can
-// never disagree on how the schema is produced. Trailing newline + 2-space indent
-// match the committed file's format.
-export function serializeConfigSchema(): string {
-  return JSON.stringify(emitConfigSchema(), null, 2) + "\n";
-}