@promptctl/cc-candybar 1.42.1 → 1.43.0

package/src/config/loader/variables.ts

@@ -1,260 +0,0 @@
-// [LAW:types-are-the-program] The variable schema: a VariableDecl is discriminated
-// by `kind` (literal / input / env / file / shell / template / time / git / state),
-// declared as DATA (VARIABLE_SCHEMA) and interpreted by the tag-by-field-value
-// engine (taggedUnion). Each arm is a `fields` schema over its member's non-`kind`
-// fields, except `input`, whose `default` must match its `type` — a genuine
-// cross-field invariant carried as a closure. This file changes when a source
-// kind's shape changes; adding a kind is one new arm here plus its runtime impl.
-
-import {
-  GIT_FIELDS,
-  type GitField,
-  type EnvVarDecl,
-  type FileVarDecl,
-  type InputVarDecl,
-  type GitVarDecl,
-  type LiteralVarDecl,
-  type ShellVarDecl,
-  type StateVarDecl,
-  type TemplateVarDecl,
-  type TimeVarDecl,
-  type VariableDecl,
-} from "../dsl-types.js";
-import { findKeyLine } from "./diagnostics.js";
-import {
-  describeType,
-  fields,
-  isPlainObject,
-  objectJson,
-  optionalStringSpec,
-  optionalTypedDefault,
-  requireStringSpec,
-  optionalEnumSpec,
-  taggedUnion,
-  taggedUnionJson,
-  withConst,
-  type FieldSpec,
-  type FieldSpecMap,
-  type JsonNode,
-  type TaggedArm,
-  type TaggedUnionSchema,
-  type ValidateCtx,
-} from "./validate-core.js";
-import {
-  optionalCacheSpec,
-  requireCacheSpec,
-  ttlOnlyCacheSpec,
-} from "./cache.js";
-
-export function validateVariables(
-  ctx: ValidateCtx,
-  pathPrefix: string,
-  raw: unknown,
-): Record<string, VariableDecl> {
-  if (raw === undefined) return {};
-  if (!isPlainObject(raw)) {
-    ctx.issues.push({
-      path: pathPrefix,
-      message: `${pathPrefix} must be an object, got ${describeType(raw)}`,
-      line: findKeyLine(ctx.source, pathPrefix.split(".")),
-    });
-    return {};
-  }
-
-  const out: Record<string, VariableDecl> = {};
-  for (const [name, decl] of Object.entries(raw)) {
-    const parsed = taggedUnion(
-      ctx,
-      VARIABLE_SCHEMA,
-      `${pathPrefix}.${name}`,
-      decl,
-    );
-    if (parsed !== null) out[name] = parsed;
-  }
-  return out;
-}
-
-// [LAW:types-are-the-program] `value` is a required union literal with a bespoke
-// message whose line points at the variable (not `.value`) — a custom spec, since
-// the generic string/enum specs encode different line behavior.
-function literalValueSpec(): FieldSpec<string | number | boolean> {
-  return {
-    required: true,
-    json: { type: ["string", "number", "boolean"] },
-    parse: (ctx, path, _field, raw) => {
-      const value = raw.value;
-      if (
-        typeof value !== "string" &&
-        typeof value !== "number" &&
-        typeof value !== "boolean"
-      ) {
-        ctx.issues.push({
-          path: `${path}.value`,
-          message: `literal value must be string|number|boolean, got ${describeType(value)}`,
-          line: findKeyLine(ctx.source, path.split(".")),
-        });
-        return undefined;
-      }
-      return value;
-    },
-  };
-}
-
-// [LAW:types-are-the-program] `field` is a required member of the closed GitField
-// set with a bespoke one-of message — a custom spec for the same reason.
-function gitFieldSpec(): FieldSpec<GitField> {
-  return {
-    required: true,
-    json: { enum: [...GIT_FIELDS] },
-    parse: (ctx, path, _field, raw) => {
-      const field = raw.field;
-      if (
-        typeof field !== "string" ||
-        !GIT_FIELDS.includes(field as GitField)
-      ) {
-        ctx.issues.push({
-          path: `${path}.field`,
-          message: `git field must be one of: ${GIT_FIELDS.join(", ")}, got ${JSON.stringify(field)}`,
-          line: findKeyLine(ctx.source, [...path.split("."), "field"]),
-        });
-        return undefined;
-      }
-      return field as GitField;
-    },
-  };
-}
-
-// [LAW:types-are-the-program] `input`'s `default` carries the cross-field
-// invariant — it must match the declared `type` (an absent or invalid `type`
-// defaults the check to "string"). A field spec receives the WHOLE record, so it
-// reads its sibling `raw.type` to pick the expected type WITHOUT re-reporting a
-// bad type (the `type` field spec owns that error — reading raw here avoids the
-// duplicate issue). This is what lets `input` derive BOTH `parse` and `json` from
-// one field map via `arm()`, like every other arm — closing the last spot where
-// the two interpreters were authored independently [LAW:one-source-of-truth].
-function inputDefaultSpec(): FieldSpec<string | number | boolean> {
-  return {
-    required: false,
-    json: { type: ["string", "number", "boolean"] },
-    parse: (ctx, path, _field, raw) => {
-      const t = raw.type;
-      const expected =
-        t === "number" || t === "boolean" || t === "string" ? t : "string";
-      return optionalTypedDefault(ctx, path, raw, expected);
-    },
-  };
-}
-
-// [LAW:dataflow-not-control-flow] Each arm's field set is DATA over the member's
-// non-`kind` fields; the engine supplies the discriminator. `fields` runs every
-// spec (reporting all issues) and fails the arm when a required field is absent
-// or invalid — the conditional-spread + result-threading the old switch hand-rolled.
-const LITERAL_FIELDS: FieldSpecMap<Omit<LiteralVarDecl, "kind">> = {
-  value: literalValueSpec(),
-  default: optionalStringSpec(),
-};
-const INPUT_FIELDS: FieldSpecMap<Omit<InputVarDecl, "kind">> = {
-  path: requireStringSpec(),
-  type: optionalEnumSpec(["string", "number", "boolean"] as const),
-  default: inputDefaultSpec(),
-};
-const ENV_FIELDS: FieldSpecMap<Omit<EnvVarDecl, "kind">> = {
-  name: requireStringSpec(),
-  default: optionalStringSpec(),
-};
-const FILE_FIELDS: FieldSpecMap<Omit<FileVarDecl, "kind">> = {
-  path: requireStringSpec(),
-  readMode: optionalEnumSpec(["whole", "first-line"] as const),
-  regex: optionalStringSpec(),
-  cache: requireCacheSpec("file"),
-  default: optionalStringSpec(),
-};
-const SHELL_FIELDS: FieldSpecMap<Omit<ShellVarDecl, "kind">> = {
-  command: requireStringSpec(),
-  regex: optionalStringSpec(),
-  cache: requireCacheSpec("shell"),
-  default: optionalStringSpec(),
-};
-const TEMPLATE_FIELDS: FieldSpecMap<Omit<TemplateVarDecl, "kind">> = {
-  template: requireStringSpec(),
-  cache: optionalCacheSpec(),
-  default: optionalStringSpec(),
-};
-const TIME_FIELDS: FieldSpecMap<Omit<TimeVarDecl, "kind">> = {
-  layout: requireStringSpec(),
-  // [LAW:no-silent-failure] ttl-only: the runtime honors no other invalidation
-  // on a clock-driven var, so the loader rejects what it would otherwise have
-  // had to silently coerce.
-  cache: ttlOnlyCacheSpec(),
-  default: optionalStringSpec(),
-};
-const GIT_VAR_FIELDS: FieldSpecMap<Omit<GitVarDecl, "kind">> = {
-  field: gitFieldSpec(),
-  cache: requireCacheSpec("git"),
-  default: optionalStringSpec(),
-};
-const STATE_FIELDS: FieldSpecMap<Omit<StateVarDecl, "kind">> = {
-  key: requireStringSpec(),
-  default: optionalStringSpec(),
-};
-
-// [LAW:decomposition] A regular arm parses its non-`kind` fields via `fields` and
-// re-attaches the tag the engine already validated; null threading is preserved.
-function arm<
-  K extends VariableDecl["kind"],
-  M extends Omit<Extract<VariableDecl, { kind: K }>, "kind">,
->(
-  kind: K,
-  fieldMap: FieldSpecMap<M>,
-): TaggedArm<Extract<VariableDecl, { kind: K }>> {
-  return {
-    // [LAW:one-source-of-truth] The arm's emit facet: the member object schema
-    // with its `kind` discriminator baked in — `objectJson` over the SAME field
-    // map `fields` validates, plus `{ kind: { const } }`. taggedUnionJson collects
-    // these verbatim into the union's anyOf.
-    json: withConst(objectJson(fieldMap), "kind", kind),
-    parse: (ctx: ValidateCtx, path: string, raw: Record<string, unknown>) => {
-      const body = fields(ctx, fieldMap, path, raw);
-      // [LAW:types-are-the-program] `fieldMap: FieldSpecMap<M>` is checked against
-      // the member's non-`kind` fields at each call site, so {kind, ...body} IS the
-      // member; TS can't relate the reconstruction to the distributed Extract for a
-      // generic K, hence the cast — the call-site check carries the real guarantee.
-      return body === null
-        ? null
-        : ({ kind, ...body } as unknown as Extract<VariableDecl, { kind: K }>);
-    },
-  };
-}
-
-const VARIABLE_SCHEMA: TaggedUnionSchema<VariableDecl, "kind"> = {
-  tag: "kind",
-  noun: "source kind",
-  arms: {
-    literal: arm("literal", LITERAL_FIELDS),
-    // [LAW:one-source-of-truth] `input`'s `default`/`type` cross-field invariant
-    // lives in `inputDefaultSpec` (a field spec reading its sibling), so `input`
-    // is one field map like every other arm — `arm()` derives both `parse` and
-    // `json` from INPUT_FIELDS, no hand-authored schema to keep in sync.
-    input: arm("input", INPUT_FIELDS),
-    env: arm("env", ENV_FIELDS),
-    file: arm("file", FILE_FIELDS),
-    shell: arm("shell", SHELL_FIELDS),
-    template: arm("template", TEMPLATE_FIELDS),
-    time: arm("time", TIME_FIELDS),
-    git: arm("git", GIT_VAR_FIELDS),
-    state: arm("state", STATE_FIELDS),
-  },
-};
-
-// [LAW:one-source-of-truth] One VariableDecl's schema, derived from the SAME
-// VARIABLE_SCHEMA the validator interprets — the tag-by-kind anyOf.
-export function variableDeclJson(): JsonNode {
-  return taggedUnionJson(VARIABLE_SCHEMA);
-}
-
-// [LAW:one-source-of-truth] The `variables` block (and a segment's nested `vars`)
-// is a name → VariableDecl map; both surfaces emit this one shape, symmetric to
-// both calling `validateVariables`.
-export function variablesMapJson(): JsonNode {
-  return { type: "object", additionalProperties: variableDeclJson() };
-}

package/src/config/menu-keys.ts

@@ -1,139 +0,0 @@
-// [LAW:one-source-of-truth] THE derivation of a menu's disclosure identity — the
-// single place both the loader (which SYNTHESIZES the state var + cycle action)
-// and the renderer (which READS openness + emits the toggle) agree on "which key
-// holds which open menu". A `{{ menu }}` helper is context-free about its NAME
-// (it cannot see the segment it sits in), so the loader and the render walk both
-// derive identity from the same two facts — the host segment name and the menu's
-// own apply-action name — and MUST produce identical strings or a click would
-// write a key the render never reads. Keeping the rule in one module makes that
-// agreement structural rather than a coincidence of two copies.
-//
-// [LAW:decomposition] A menu's identity is `(stateKey, member)`:
-//   • member  = the menu's apply-action name — unique per menu within a segment,
-//               so two menus in ONE segment are distinct.
-//   • stateKey = the SessionState key whose value names the open member. By
-//               DEFAULT each menu owns a UNIQUE key (`menus.<seg>.<apply>`), so
-//               it toggles only itself — menus are INDEPENDENT. Passing an
-//               explicit shared key makes sibling menus share one key
-//               (`menus.<key>`); one key holds one open member, so they become
-//               mutually exclusive (an accordion) — exactly group sugar's shared-
-//               key mechanism, selected by a VALUE not a mode
-//               [LAW:dataflow-not-control-flow]. There is no implicit "the row is
-//               the key" position magic: identity depends only on names a reader
-//               can see in the template, never on tree position.
-
-import { ident } from "./ident.js";
-
-// [LAW:one-source-of-truth] The reserved namespace every synthesized menu
-// artifact (state var + cycle action) lives under, mirroring group sugar's
-// `groups.`. A user-authored name under this prefix is a load error so synthesis
-// can never silently collide.
-export const MENU_NS = "menus.";
-
-// [LAW:one-source-of-truth] The closed sentinel and the ▸/▾ glyphs are the shared
-// disclosure primitive, not menu-specific — they live in src/config/disclosure.ts
-// (DISCLOSURE_CLOSED / DISCLOSURE_GLYPH_*) so group sugar and {{ menu }} cannot
-// drift. This module keeps only the menu's own IDENTITY derivation (member = apply
-// name; key = optional shared key), which group sugar derives differently.
-
-// [LAW:single-enforcer] A menu's member name IS its apply-action name. Both the
-// loader and the helper call this so neither restates the rule.
-export function menuMember(applyName: string): string {
-  return applyName;
-}
-
-// [LAW:single-enforcer] THE state key for a menu. Independent (no shared key):
-// unique per (segment, apply) so the menu toggles only itself. Shared key: the
-// key all siblings passing the same string agree on, so one open member wins
-// (accordion). The shared form ignores the segment name on purpose — that is how
-// menus in DIFFERENT segments become mutually exclusive.
-export function menuStateKey(
-  segName: string,
-  applyName: string,
-  sharedKey: string | undefined,
-): string {
-  return sharedKey !== undefined
-    ? MENU_NS + ident(sharedKey)
-    : MENU_NS + ident(segName) + "." + ident(applyName);
-}
-
-// The synthesized cycle action a menu's disclosure toggle realizes: writing its
-// state key between MENU_CLOSED and its member. Named per (stateKey, member) so
-// menus sharing a key contribute distinct cycles on it — the existing same-key
-// validator merge unions their members into one gate.
-export function menuActionName(stateKey: string, member: string): string {
-  return stateKey + "." + member;
-}
-
-// [LAW:single-enforcer] THE page-cursor key a menu's picker body paginates by —
-// synthesized by the loader (state var + int action, both named by this key)
-// and derived again by the renderer, so neither side hand-declares or restates
-// it. One cursor PER DISCLOSURE STATE KEY, not per menu: a shared (accordion)
-// key holds at most one open member, so its one open body is the only body the
-// cursor can belong to — sharing is exact by construction, not an
-// approximation — and the disclosure toggle's page-0 reset re-seeds it on
-// every open. [LAW:one-source-of-truth] The synthesized state VARIABLE is
-// named by this same string (the disclosure-var convention), so the renderer
-// reads the live page via this one name.
-export function menuPageKey(stateKey: string): string {
-  return stateKey + ".page";
-}
-
-// [LAW:types-are-the-program] The `{{ menu }}` rare-knob options, spelled as ONE
-// trailing `(dict …)` argument. Defaults are the canonical path: paged=true (a
-// drop menu wants bounded height; a short domain paginates to one page and shows
-// no arrows anyway), closeOnPick=false (stay-open so options can be tried in a
-// row), key omitted (an independent menu).
-export interface MenuOptions {
-  readonly closeOnPick: boolean;
-  readonly paged: boolean;
-  readonly key: string | undefined;
-}
-
-// [LAW:one-source-of-truth] THE reader of a menu's options dict — the loader
-// folds it over `staticDictEntries` (gating identity at load) and the renderer
-// folds it over the evaluated dict object (realizing the body), so the option
-// vocabulary, value types, and defaults live exactly once. An unknown name or a
-// mistyped value throws with text naming the legal shape — the blind authoring
-// agent's teaching channel [LAW:no-silent-failure]; the loader attaches segment
-// context, the renderer surfaces it via composeWithDiagnostics.
-export function parseMenuOptions(
-  entries: Readonly<Record<string, unknown>>,
-): MenuOptions {
-  for (const name of Object.keys(entries)) {
-    if (name !== "closeOnPick" && name !== "paged" && name !== "key") {
-      throw new Error(
-        `unknown {{ menu }} option "${name}" — the options dict takes "closeOnPick" (bool, default false), "paged" (bool, default true), "key" (string, accordion grouping)`,
-      );
-    }
-  }
-  const bool = (name: "closeOnPick" | "paged", def: boolean): boolean => {
-    const v = entries[name];
-    if (v === undefined) return def;
-    if (typeof v !== "boolean") {
-      throw new Error(
-        `{{ menu }} option "${name}" must be a boolean, got ${JSON.stringify(v)} (e.g. (dict "${name}" ${String(!def)}))`,
-      );
-    }
-    return v;
-  };
-  const key = entries["key"];
-  if (key !== undefined && typeof key !== "string") {
-    throw new Error(
-      `{{ menu }} option "key" must be a string naming the accordion group, got ${JSON.stringify(key)}`,
-    );
-  }
-  // [LAW:types-are-the-program] An empty shared key would collapse the state key
-  // to the bare reserved `menus.` namespace (and a `menus..member` action name) —
-  // a key, when present, must name a group.
-  if (key === "") {
-    throw new Error(
-      `{{ menu }} has an empty accordion key — a shared key must be a non-empty name (or omit "key" for an independent menu)`,
-    );
-  }
-  return {
-    closeOnPick: bool("closeOnPick", false),
-    paged: bool("paged", true),
-    key,
-  };
-}

package/src/config/option-domain.ts

@@ -1,164 +0,0 @@
-// [LAW:one-type-per-behavior] An option domain is a NAME → members lookup,
-// regardless of where the members come from. Before this module, "themes" /
-// "styles" / "looks" were three special-cased branches wearing a closed
-// TypeScript union (OptionSource) — a hardcoded list of legal domain NAMES
-// with extra steps. There is exactly one domain concept: a `from` value is
-// either an INLINE literal domain (an authored array — zero registration,
-// zero engine edit) or the NAME of a domain resolved through this registry.
-// Adding a new registry-backed domain is one `registerOptionDomain` call
-// (data), never a new union member every consumer must re-match on.
-//
-// [LAW:no-shared-mutable-globals] `_GLOBAL_OPTION_DOMAINS` is shared mutable
-// state with exactly one owner (this module) and one explicit API
-// (registerOptionDomain / resolveOptionDomain / knownOptionDomainNames). It
-// holds only domains whose members are legitimately PROCESS-lifetime static
-// (themes, styles — module-init snapshots, same reasoning as
-// template-engine/funcs.ts's THEMES_LIST/STYLES_LIST caches). A domain whose
-// members vary PER CONFIG (the merged `looks:` block — two daemon render-cache
-// entries can hold different looks blocks for different configs
-// simultaneously) can never live here; it is threaded explicitly as
-// `perConfigDomains`, the same way `lookNames` already is.
-//
-// [LAW:one-source-of-truth] This is the ONE place a domain name resolves to
-// its members. render/action.ts (rendering options) and
-// daemon/verbs/state-validators.ts (deriving the click gate) both call
-// through here instead of each hand-rolling the themes/styles/looks branch —
-// the rendered options and the derived gate cannot diverge because there is
-// no second resolver.
-
-import {
-  CHARSETS,
-  COLOR_COMPATIBILITIES,
-  listResolvablePaletteNames,
-  STRIP_STYLES,
-} from "../themes/policy.js";
-import { presetNames } from "./presets.js";
-
-// [LAW:types-are-the-program] The authoring shape of a `set … from` value: a
-// bare string names a domain (resolved through the registry or a per-config
-// override); a non-empty array of strings IS the domain, inline, needing no
-// name and no registration. Mirrors the `cycle` field's array shape — an
-// author already knows this pattern.
-export type OptionDomain = string | readonly string[];
-
-export type OptionDomainResolver = () => readonly string[];
-
-interface DomainEntry {
-  readonly permanent: boolean;
-  readonly resolve: OptionDomainResolver;
-}
-
-const _GLOBAL_OPTION_DOMAINS = new Map<string, DomainEntry>();
-
-function registerBuiltinDomain(
-  name: string,
-  resolve: OptionDomainResolver,
-): void {
-  _GLOBAL_OPTION_DOMAINS.set(name, { permanent: true, resolve });
-}
-
-// [LAW:one-source-of-truth] "themes"/"styles" become ORDINARY registrations —
-// the same registerOptionDomain any future caller uses — reading the same
-// canonical lists the set-state validator and the `themes()`/`styles()`
-// template bindings already consult (listResolvablePaletteNames/
-// STRIP_STYLES). No special-cased branch remains anywhere downstream.
-registerBuiltinDomain("themes", () => listResolvablePaletteNames());
-registerBuiltinDomain("styles", () => STRIP_STYLES);
-// [LAW:one-source-of-truth] Same shape as themes/styles: the exact consts
-// the loader's own field validation and the render layer's glyph/color-depth
-// dispatch already derive from (themes/policy.ts CHARSETS/COLOR_COMPATIBILITIES)
-// — a menu drawing from these can never enumerate a value the render layer
-// would reject.
-registerBuiltinDomain("charsets", () => CHARSETS);
-registerBuiltinDomain("colorCompatibilities", () => COLOR_COMPATIBILITIES);
-
-// [LAW:no-silent-fallbacks] A built-in domain can never be re-claimed — a
-// config or feature registering a custom domain named "themes" gets a loud
-// load-time error, never a silent shadow of the real theme list. Registering
-// returns a disposer (same shape as registerStateValidator) so a caller with
-// a bounded lifetime (a test, a future per-feature domain) can clean up.
-export function registerOptionDomain(
-  name: string,
-  resolve: OptionDomainResolver,
-): () => void {
-  const existing = _GLOBAL_OPTION_DOMAINS.get(name);
-  if (existing) {
-    throw new Error(
-      `registerOptionDomain: option domain "${name}" is already registered` +
-        (existing.permanent
-          ? " (a built-in domain — built-ins cannot be reclaimed)"
-          : ""),
-    );
-  }
-  _GLOBAL_OPTION_DOMAINS.set(name, { permanent: false, resolve });
-  let active = true;
-  return () => {
-    if (!active) return;
-    active = false;
-    const entry = _GLOBAL_OPTION_DOMAINS.get(name);
-    if (entry && !entry.permanent) _GLOBAL_OPTION_DOMAINS.delete(name);
-  };
-}
-
-// [LAW:one-source-of-truth] THE single construction of a config's per-config
-// domain overrides — the domains whose members are declared IN the config
-// rather than in the registry above: "looks" (the merged `looks:` block) and
-// "presets" (the merged `presets:` block). cross-ref.ts (checking a `from` name
-// resolves), state-validators.ts (deriving the click gate), and dsl/render.ts
-// (compiling render-time options) each need this map; before this function they
-// each rebuilt it independently, three sites that could silently drift if a
-// future per-config domain were added to only some of them.
-//
-// [LAW:locality-or-seam] The parameter is the CONFIG, structurally typed to the
-// blocks read here — not one positional record per domain. Presets were the
-// second per-config domain, and adding them under the old `(looks)` signature
-// would have rippled a new argument through all three call sites; under this
-// one, a third domain is a single line HERE and nothing else moves. Structural
-// (rather than importing DslConfig) so this leaf module still never imports
-// dsl-types.ts — that would cycle through dsl-types.ts -> action.ts ->
-// option-domain.ts (type-only, but still a cycle this module stays clear of,
-// per [LAW:one-way-deps]).
-export function perConfigDomainsFor(config: {
-  readonly looks: Readonly<Record<string, unknown>>;
-  readonly presets: Readonly<Record<string, unknown>>;
-}): ReadonlyMap<string, readonly string[]> {
-  return new Map([
-    ["looks", Object.keys(config.looks)],
-    // [LAW:one-source-of-truth] Not `Object.keys` — the floor is selectable
-    // whether or not a config declares it, and presetNames is where that is
-    // stated (once, for the gate and the render alike).
-    ["presets", presetNames(config.presets)],
-  ]);
-}
-
-// [LAW:one-source-of-truth] The full set of names `from` may legally name for
-// THIS config: every globally-registered domain plus this config's per-config
-// overrides (currently just "looks"). Used both to resolve a name and to spell
-// out the legal set in an unknown-domain error.
-export function knownOptionDomainNames(
-  perConfigDomains: ReadonlyMap<string, readonly string[]>,
-): readonly string[] {
-  return [
-    ...new Set([..._GLOBAL_OPTION_DOMAINS.keys(), ...perConfigDomains.keys()]),
-  ];
-}
-
-// [LAW:dataflow-not-control-flow] One total resolution: an inline array IS
-// its own domain (no lookup); a string is a NAME resolved first against this
-// config's per-config overrides, then the global registry. A name matching
-// neither is a genuine error — the loader's cross-ref pass already proved
-// every `from` name resolves before this runs, so a miss here is a
-// caller/wiring bug, not a config-authoring mistake.
-export function resolveOptionDomain(
-  from: OptionDomain,
-  perConfigDomains: ReadonlyMap<string, readonly string[]>,
-): readonly string[] {
-  if (typeof from !== "string") return from;
-  const local = perConfigDomains.get(from);
-  if (local) return local;
-  const entry = _GLOBAL_OPTION_DOMAINS.get(from);
-  if (entry) return entry.resolve();
-  throw new Error(
-    `unknown option domain "${from}" (have: ${knownOptionDomainNames(perConfigDomains).join(", ")})`,
-  );
-}