@nodaro/prompts 1.7.3 → 1.8.0

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { ConnectedReference, GenericNode, GenericEdge, HintNodeLike, HintGraphContext, EntityStyle, SupportedFontName, CharacterDef, IdentityMeta, SceneData, CharacterMentionTokenInfo, LocationMentionTokenInfo, UsageMode, StyleDirectives, I18nCatalogId, SurroundDirection } from '@nodaro/shared';
+import { ConnectedReference, GenericNode, GenericEdge, HintNodeLike, HintGraphContext, EntityStyle, SupportedFontName, CharacterDef, IdentityMeta, SceneData, CharacterMentionTokenInfo, LocationMentionTokenInfo, UsageMode, ProjectedCatalog, ProjectedCatalogDimension, ProjectedCatalogOption, LocaleId, LocaleCatalogMap, StyleDirectives, I18nCatalogId, SurroundDirection } from '@nodaro/shared';
 export { HintEdgeLike, HintGraphContext, HintNodeLike } from '@nodaro/shared';
 import { z } from 'zod';
 
@@ -18,7 +18,14 @@ import { z } from 'zod';
  */
 
 type IdentityLockMode = "off" | "soft" | "strict";
-/** Default applied when a Character node was created before the field existed. */
+/**
+ * The identity-lock default for characters — the value used wherever a Character
+ * node or entity has no explicit `identityLock`/`identity_lock`: the UI display
+ * fallback (canvas node, config panel, Character Studio), the runtime coercion in
+ * `toIdentityLockMode`, and the backend create defaults (characters route, MCP
+ * create_character, asset generation). Mirror this value in the
+ * `characters.identity_lock` SQL column default (migration 353).
+ */
 declare const DEFAULT_IDENTITY_LOCK: IdentityLockMode;
 /**
  * Natural-language clause for each mode. Returns an empty string for "off"
@@ -35,9 +42,9 @@ declare function toIdentityLockMode(value: unknown): IdentityLockMode;
  *   - off    → { enabled: false }                     (no lock line)
  *   - soft   → { enabled: true, text: <soft clause> }  (mild "preserve likeness")
  *   - strict → { enabled: true, text: <strict clause> }(strong "match exactly")
- * `undefined` coerces to the runtime default (`"soft"`) via `toIdentityLockMode`,
- * so existing nodes (which never set the field) emit the mild line in hybrid. The
- * per-mention `~lock`/`~nolock` sentinel still overrides via `withForcedIdentityLock`.
+ * `undefined` coerces to the runtime default (`DEFAULT_IDENTITY_LOCK`, now `"off"`)
+ * via `toIdentityLockMode`, so a node that never set the field emits NO lock line
+ * in hybrid. The per-mention `~lock`/`~nolock` sentinel still overrides via `withForcedIdentityLock`.
  */
 declare function characterLockToRefLock(mode: IdentityLockMode | undefined): {
     enabled: boolean;
@@ -290,10 +297,143 @@ declare function referenceRulesBlock(opts?: {
     sceneFrame?: boolean;
 }): string;
 
+/**
+ * Compact professional TERMS for picker-catalog entries.
+ *
+ * Every picker catalog entry carries a long `promptHint` — a full mechanism
+ * description injected downstream by `getParameterPromptHint`. A `term` is the
+ * SHORT form of the same entry: the two-to-four word phrase a professional
+ * would actually write in a prompt ("whip pan left", "hard cut", "medium
+ * close-up") when the consumer wants a compact instruction instead of a
+ * paragraph.
+ *
+ * The split of responsibilities is:
+ *   - `label`       → what USERS see in the picker.
+ *   - `promptHint`  → what MODELS read in verbose ("full") hint mode.
+ *   - `term`        → what MODELS read in compact hint mode.
+ *
+ * ---------------------------------------------------------------------------
+ * THE CONVENTION EVERY CATALOG FOLLOWS
+ * ---------------------------------------------------------------------------
+ * 1. The catalog's entry interface gains an OPTIONAL `term?: string`. It is
+ *    authored only where the label does not already read as the professional
+ *    term (see `isSuspiciousDerivedTerm` for the failure shapes); everywhere
+ *    else the lowercased label IS the term and no data is added.
+ * 2. Alongside each `get<Name>PromptHint(id)` getter, the catalog exports a
+ *    sibling `get<Name>Term(id)` implemented as
+ *      `export function get<Name>Term(id: string | undefined | null): string {
+ *         return resolveTerm(get<Name>(id))
+ *       }`
+ *    — same arity, same lookup, same empty-string-on-miss behavior, so the two
+ *    getters can never disagree about which entry they are describing.
+ * 3. An authored `term` is:
+ *      - lowercase,
+ *      - at most `TERM_MAX_CHARS` characters,
+ *      - at most 8 words,
+ *      - with NO trailing period,
+ *      - phrased the way a professional cinematographer / photographer /
+ *        sound designer / stylist would write it in a prompt.
+ *    Entries with no standard trade term (exotic morph/portal transitions and
+ *    the like) get a short descriptive phrase instead — never a sentence, and
+ *    never the long `promptHint`.
+ * 4. An entry whose `promptHint` is `""` — the no-op "auto" / "none" entries —
+ *    injects NOTHING, so its resolved term is `""` too. `resolveTerm` enforces
+ *    that; do not author a `term` on such an entry expecting it to be used.
+ *
+ * A guard test (`__tests__/catalog-terms.test.ts`) walks every registered
+ * catalog and fails for entries whose label cannot be safely lowercased into a
+ * term and that have no explicit `term` authored — so the convention above is
+ * enforced, not merely documented.
+ */
+/** Hard cap on an authored/derived term. Longer than this is a hint, not a term. */
+declare const TERM_MAX_CHARS = 60;
+/**
+ * How verbose a picker node's injected fragment is.
+ *
+ *  - `"full"`    — the long `promptHint` (the historical, and still default,
+ *                  behavior; output is byte-identical to before hint modes
+ *                  existed).
+ *  - `"compact"` — the short professional `term` instead.
+ *
+ * ONLY the base catalog fragment swaps. The user's `preText` / `postText`
+ * free text, the transition / camera-motion / character-fx timing and
+ * start-state/end-state clauses, multi-pick joining, and multi-dimension
+ * composition all apply exactly the same in both modes.
+ *
+ * "The same" means the same MEANING, not always the same string. Where a
+ * wrapper is grammatically fused to the long hint it cannot simply be reused:
+ * the character-fx composer names its target by rewriting the words "the
+ * subject" inside a full hint, and a bare term has no such words, so compact
+ * mode names the target with an explicit `"{target}: {effect}"` prefix. When a
+ * catalog's grammar IS its meaning — Material's `"made of ..."`, Held Prop's
+ * `"holding a ..."` — that grammar is authored into the term itself rather
+ * than left for a consumer to re-add, because a projected `term` is injected
+ * standalone by thin clients that have no composer at all.
+ *
+ * A picker node selects the mode via an optional `hintMode` field on its node
+ * data; absent (or any unrecognized value) means `"full"`.
+ */
+type PickerHintMode = "full" | "compact";
+/**
+ * The minimal shape of a catalog entry that can resolve a term: an id, the
+ * user-facing label, the long hint (whose emptiness marks a no-op entry), and
+ * the optional authored short term.
+ */
+interface TermCarrier {
+    readonly id: string;
+    readonly label: string;
+    readonly promptHint: string;
+    readonly term?: string;
+}
+/**
+ * Mechanical label → term derivation: lowercase, drop parenthetical segments,
+ * collapse whitespace, trim.
+ *
+ * Deliberately NOT clever: it does not split on "/" or strip category nouns.
+ * A label like "None / Hard Cut" or "Fog / Mist" has to SURFACE as suspicious
+ * (see `isSuspiciousDerivedTerm`) so a human authors the right term — guessing
+ * here would quietly inject the wrong wording into every prompt.
+ */
+declare function deriveTerm(label: string): string;
+interface SuspiciousTermOptions {
+    /**
+     * Treat a single-word derived term as suspicious. Set for catalogs whose
+     * labels are bare MODIFIERS that only read as a professional term with
+     * their category noun attached — lighting "Short" → "short lighting",
+     * color-look "Warm" → "warm grade".
+     */
+    readonly bareWordSuspicious?: boolean;
+}
+/**
+ * Is the mechanically-derived term unsafe to inject as-is?
+ *
+ * True when the label is a UI compound or carries an annotation ("None / Hard
+ * Cut", "Ultra-wide (14mm)", "Key: Rembrandt"), when nothing survives the
+ * derivation, or — under `bareWordSuspicious` — when the result is a lone word
+ * that needs its category noun to mean anything to a model.
+ */
+declare function isSuspiciousDerivedTerm(label: string, opts?: SuspiciousTermOptions): boolean;
+/**
+ * The single resolution point every consumer reads: an explicit `term` when
+ * the catalog authored one, the derived label otherwise, and `""` for a no-op
+ * entry (missing entry, or an "auto"/"none" entry whose `promptHint` is empty
+ * and which therefore injects nothing).
+ */
+declare function resolveTerm(entry: TermCarrier | undefined | null): string;
+
 /**
  * Dispatch by parameter-node type to its prompt-hint string. For camera-motion,
  * pass `ctx` to include the composed start/end clauses; otherwise only the
  * bare motion description is returned.
+ *
+ * VERBOSITY — a picker node may set `data.hintMode` to `"compact"` to inject
+ * its short professional `term` ("whip pan left", "hard cut") instead of the
+ * long `promptHint`. Absent, or any unrecognized value, means `"full"`, whose
+ * output is byte-identical to what this function returned before hint modes
+ * existed. ONLY the base catalog fragment swaps: `preText`/`postText`, the
+ * transition / camera-motion / character-fx timing and start-state/end-state
+ * clauses, multi-pick joining and multi-dimension composition are emitted the
+ * same way in both modes.
  */
 declare function getParameterPromptHint(node: HintNodeLike | undefined, ctx?: HintGraphContext): string;
 
@@ -1523,6 +1663,7 @@ declare function resolveVeoI2vInputs(args: VeoI2vInputsArgs): VeoI2vInputsResult
  * the prompt-hint injection on both the frontend DAG executor and the
  * backend orchestrator.
  */
+
 type PersonDimension = "type" | "age" | "ethnicity" | "regional-aesthetic" | "frame" | "body-mass" | "bust" | "waist" | "hips" | "silhouette" | "face-shape" | "jawline" | "cheekbones" | "facial-fullness" | "eye-shape" | "eyelid-type" | "canthal-tilt" | "eye-spacing" | "eye-set-brow" | "nose" | "nose-tip" | "lip-fullness" | "lip-shape" | "lip-state" | "hair-color" | "hair-base" | "eyebrows" | "skin-tone" | "skin-texture" | "eye-color" | "eye-state" | "facial-hair" | "distinctive-features";
 interface Person {
     readonly id: string;
@@ -1539,6 +1680,17 @@ interface Person {
      *  instead of the redundant "East Asian (any)". Node cards + tooltips
      *  keep the full `label` / `description`. */
     readonly shortLabel?: string;
+    /**
+     * Optional authored COMPACT term — the short professional phrase a consumer
+     * injects instead of the full `promptHint` ("brown hair", "aquiline nose",
+     * "of nordic scandinavian descent"). Authored only where the lowercased
+     * label is not already what a professional writes: Person fragments are
+     * comma-joined into one compound description, so a bare dimension modifier
+     * ("Brown", "Strong", "Full") has to carry its category noun to mean
+     * anything. See `term.ts`; resolve via `resolveTerm` / `getPersonTerm`,
+     * never by reading this field directly.
+     */
+    readonly term?: string;
 }
 declare const PEOPLE: ReadonlyArray<Person>;
 declare const PERSON_DIMENSION_ORDER: ReadonlyArray<PersonDimension>;
@@ -1678,6 +1830,14 @@ interface PersonValue {
 declare function getPerson(id: string | undefined | null): Person | undefined;
 declare function getPersonLabel(id: string | undefined | null, fallback?: string): string;
 declare function getPersonPromptHint(id: string | undefined | null): string;
+/**
+ * The COMPACT counterpart of `getPersonPromptHint`: the short professional
+ * term ("brown hair", "aquiline nose", "of nordic scandinavian descent") a
+ * consumer injects instead of the full mechanism description. Same lookup,
+ * same empty-string-on-miss behavior, so the two can never disagree about
+ * which entry they are describing.
+ */
+declare function getPersonTerm(id: string | undefined | null): string;
 declare const PERSON_IDS: ReadonlyArray<string>;
 /**
  * Age hint with optional custom-numeric override. When the user picks the
@@ -1689,7 +1849,14 @@ declare const PERSON_IDS: ReadonlyArray<string>;
  * Custom number is clamped to a sane range and rejected if non-finite.
  */
 declare function buildAgeHint(ageId: string | undefined | null, customAge: number | undefined | null): string;
-declare function buildPersonHints(data: Record<string, unknown> & PersonValue): string[];
+declare function buildPersonHints(data: Record<string, unknown> & PersonValue, mode?: PickerHintMode): string[];
+/**
+ * The COMPACT counterpart of `buildPersonHints`: the same per-dimension walk
+ * in the same canonical order, emitting each selection's short professional
+ * term ("in their 30s", "of east asian descent", "long wavy hair", "brown
+ * hair", "fair skin", "green eyes") instead of its full mechanism description.
+ */
+declare function buildPersonTerms(data: Record<string, unknown> & PersonValue): string[];
 /**
  * Relocate legacy single-field Person values onto the post-split fields so the
  * picker UI shows them in their new home:
@@ -1743,6 +1910,7 @@ declare function migratePersonValue<T extends Record<string, unknown>>(data: T):
  * exact same phrasing here so each option's `promptHint` is non-empty AND
  * matches what actually gets injected downstream.
  */
+
 interface PickerOption {
     readonly id: string;
     readonly label: string;
@@ -1750,6 +1918,15 @@ interface PickerOption {
     /** The group id (matches `categoryOrder` / `categoryLabels`). */
     readonly category?: string;
     readonly promptHint: string;
+    /**
+     * The short professional term this id injects in COMPACT hint mode ("whip
+     * pan left" where `promptHint` is the full mechanism sentence). Always
+     * present and already RESOLVED via `resolveTerm` — an authored `term` when
+     * the catalog entry carries one, the derived label otherwise, and `""` for
+     * a no-op ("auto"/"none") entry that injects nothing. Consumers render
+     * `label` and inject `term`; they never derive it themselves.
+     */
+    readonly term: string;
     /** Only present if the source catalog entry already carries a data icon/emoji/thumbnail field. */
     readonly icon?: string;
 }
@@ -1787,7 +1964,23 @@ interface PickerCatalog {
     /** multi-dim: one self-describing entry per dimension field, in `fields` order. */
     readonly dimensions?: readonly PickerDimension[];
 }
+/**
+ * The frozen upstream base — the pure-data catalogs as authored, never mutated
+ * in place. Deployment curation is additive-by-registration (catalog packs);
+ * `getRegisteredPickerCatalogs()` is the pack-composed view every enumerating
+ * consumer reads.
+ */
 declare const PICKER_CATALOGS: readonly PickerCatalog[];
+/**
+ * The pack-composed picker catalogs — the single funnel every enumerating
+ * consumer (funnel getters, /v1/catalogs, MCP, completeness tests) reads.
+ * Memoized on the pack registry version so late registration is reflected.
+ *
+ * DEFERRED PLUG-IN POINT (do not build in Phase 0): a future `CatalogPolicy`
+ * filter (deny-by-tag / override, per read kind) applies HERE, after pack
+ * composition, e.g. `applyCatalogPolicy(composed, runtimePolicy())`.
+ */
+declare function getRegisteredPickerCatalogs(): readonly PickerCatalog[];
 /** Resolve a catalog by `nodeType` first, then by `catalogId`. */
 declare function getPickerCatalog(nodeTypeOrCatalogId: string): PickerCatalog | undefined;
 declare function listPickerCatalogs(): readonly PickerCatalog[];
@@ -1814,36 +2007,132 @@ interface ProjectPickerCatalogOptions {
     /** multi-dim: keep only this dimension field. */
     readonly field?: string;
 }
-/** An option after projection — description/promptHint present only when detail="full". */
-interface ProjectedPickerOption {
+type ProjectedPickerOption = ProjectedCatalogOption;
+type ProjectedPickerDimension = ProjectedCatalogDimension;
+type ProjectedPickerCatalog = ProjectedCatalog;
+/** Project a catalog to the wire shape: compact by default, optional category/field filter. */
+declare function projectPickerCatalog(c: PickerCatalog, opts?: ProjectPickerCatalogOptions): ProjectedPickerCatalog;
+/**
+ * Project every REGISTERED (pack-composed) catalog to the tag-free
+ * `/v1/catalogs` wire shape. This is what the `GET /v1/catalogs` route and its
+ * SDK resource serve, so a deployment's vendored packs are reflected verbatim.
+ */
+declare function projectAllCatalogs(opts?: {
+    detail?: PickerCatalogDetail;
+}): ProjectedCatalog[];
+
+/**
+ * Every option that leaves this module carries a RESOLVED `term`, exactly like
+ * the base registry's own options do.
+ *
+ * `PickerOption.term` is required at the type level, but a pack arrives from a
+ * separately-compiled bundle that may have been built against a `@nodaro/prompts`
+ * where the field did not exist yet — so at runtime a pack option can simply
+ * not have one. Resolving at COMPOSITION (rather than at each read) is what
+ * keeps the `/v1/catalogs` projection, the compact-hint read path and the
+ * `replace`-mode packs agreeing; a pack-added value would otherwise inject its
+ * full hint in full mode and NOTHING in compact.
+ */
+/** Pack-author input shapes: identical to the registry's own types except that
+ *  `term` is OPTIONAL — a vendored pack may predate the field, and a new
+ *  required field on a published input type would be a breaking change. The
+ *  composition root resolves it (`withTerm`), so everything that LEAVES this
+ *  module still satisfies `PickerOption` with a resolved `term`. */
+type PickerOptionInput = Omit<PickerOption, "term"> & {
+    readonly term?: string;
+};
+type PickerDimensionInput = Omit<PickerDimension, "options"> & {
+    readonly options: readonly PickerOptionInput[];
+};
+type PickerCatalogInput = Omit<PickerCatalog, "options" | "dimensions"> & {
+    readonly options?: readonly PickerOptionInput[];
+    readonly dimensions?: readonly PickerDimensionInput[];
+};
+type CatalogPackMode = "replace" | "extend" | "deny";
+/**
+ * A vendored curation pack applied at the picker-catalog composition root.
+ * `replace` swaps a full vendored copy; `extend` appends options (single-dim)
+ * or merges dimensions by field (multi-dim); `deny` removes entry ids from the
+ * copy. Packs target EXISTING catalog ids only — a new catalog id is out of
+ * Phase-0 scope (it drags the 5-registry parameter-picker checklist).
+ *
+ * DEFERRED (do not build here): a `CatalogPolicy` (tags / deny-by-tag /
+ * override) plugs in downstream of this compose, at `getRegisteredPickerCatalogs`.
+ */
+interface CatalogPack {
     readonly id: string;
-    readonly label: string;
-    readonly description?: string;
-    readonly category?: string;
-    readonly promptHint?: string;
-    readonly icon?: string;
+    readonly catalogId: string;
+    readonly mode: CatalogPackMode;
+    readonly catalog?: PickerCatalogInput;
+    readonly options?: readonly PickerOptionInput[];
+    readonly dimensions?: readonly PickerDimensionInput[];
+    readonly denyIds?: readonly string[];
+    /** Localized strings for this pack's added option ids, keyed by locale → id. */
+    readonly sidecars?: Partial<Record<LocaleId, LocaleCatalogMap>>;
+    /** Locales deliberately not translated for this pack (reported, never failed). */
+    readonly exemptSidecarLocales?: readonly LocaleId[];
 }
-interface ProjectedPickerDimension {
-    readonly field: string;
-    readonly label: string;
-    readonly options: readonly ProjectedPickerOption[];
+declare function registerCatalogPack(pack: CatalogPack): void;
+declare function getRegisteredCatalogPacks(): readonly CatalogPack[];
+declare function resetCatalogPacks(): void;
+declare function catalogPacksVersion(): number;
+declare function composePickerCatalogs(base: readonly PickerCatalog[], activePacks: readonly CatalogPack[]): readonly PickerCatalog[];
+
+/**
+ * Sidecar-localization coverage for a curation pack's added option ids. For
+ * every pack-added id, each non-English locale must either have a sidecar entry
+ * or be declared exempt (`pack.exemptSidecarLocales`). Exemptions are REPORTED,
+ * never treated as failures — a deployment may knowingly ship a pack with only
+ * a subset of the 11 locales translated.
+ */
+interface SidecarCoverageReport {
+    readonly total: number;
+    readonly missing: ReadonlyArray<{
+        catalogId: string;
+        locale: LocaleId;
+        id: string;
+    }>;
+    readonly exempted: ReadonlyArray<{
+        catalogId: string;
+        locale: LocaleId;
+    }>;
 }
-interface ProjectedPickerCatalog {
-    readonly nodeType: string;
-    readonly label: string;
-    readonly catalogId: string;
-    readonly kind: "single" | "multi";
-    readonly valueField?: string;
-    readonly defaultValue?: string;
-    readonly categoryOrder?: readonly string[];
-    readonly categoryLabels?: Readonly<Record<string, string>>;
-    readonly options?: readonly ProjectedPickerOption[];
-    readonly fields?: readonly string[];
-    readonly dimensions?: readonly ProjectedPickerDimension[];
-    readonly detail: PickerCatalogDetail;
+declare function computePackSidecarCoverage(pack: CatalogPack): SidecarCoverageReport;
+
+/**
+ * A person-pack entry. Pack dimensions are new keys OUTSIDE the closed
+ * `PersonDimension` union, so `dimension` is widened to `string`.
+ */
+type RegisteredPersonEntry = Omit<Person, "dimension"> & {
+    dimension: string;
+};
+interface PersonPack {
+    readonly id: string;
+    readonly entries: readonly RegisteredPersonEntry[];
+    readonly dimensions?: readonly {
+        dimension: string;
+        field: string;
+        label: string;
+    }[];
+    readonly sidecars?: Parameters<typeof registerCatalogPack>[0]["sidecars"];
+    readonly exemptSidecarLocales?: Parameters<typeof registerCatalogPack>[0]["exemptSidecarLocales"];
 }
-/** Project a catalog to the wire shape: compact by default, optional category/field filter. */
-declare function projectPickerCatalog(c: PickerCatalog, opts?: ProjectPickerCatalogOptions): ProjectedPickerCatalog;
+declare function registerPersonPack(pack: PersonPack): void;
+declare function resetPersonPacks(): void;
+declare function personPacksVersion(): number;
+/**
+ * The registered/composed person taxonomy: base `PEOPLE` folded with every
+ * `catalogId:"person"` CatalogPack in registration order (the SAME registry
+ * `composePickerCatalogs` folds for `/v1/catalogs` + MCP). `extend` appends the
+ * pack's full Person entries, `deny` removes `denyIds`, `replace` swaps to a
+ * reconstruction of the vendored catalog. This is the single funnel the
+ * picker-ui grids read, so a deploy's deny/replace curation hides base entries
+ * in the picker exactly as it hides them in the catalogs projection.
+ */
+declare function getRegisteredPeople(): readonly RegisteredPersonEntry[];
+declare function getRegisteredPersonDimensionOrder(): readonly string[];
+declare function getRegisteredPersonFieldByDimension(): Readonly<Record<string, string>>;
+declare function getRegisteredPersonDimensionLabels(): Readonly<Record<string, string>>;
 
 /** A catalog entry as the analyzer consumes it. Flat catalogs lack
  *  dimension/category; discriminated catalogs carry exactly one. */
@@ -2377,6 +2666,7 @@ declare function pickerFanoutTargets(producerId: string, edges: ReadonlyArray<{
  * zero API calls. Shared between picker UI and prompt-hint injection on
  * frontend DAG executor + backend orchestrator.
  */
+
 type ActionFxCategory = "disaster" | "fire-blasts" | "electric" | "combat" | "sci-fi" | "magic";
 interface ActionFx {
     readonly id: string;
@@ -2384,6 +2674,8 @@ interface ActionFx {
     readonly category: ActionFxCategory;
     readonly description: string;
     readonly promptHint: string;
+    /** Optional authored compact term (see `term.ts` for the convention). */
+    readonly term?: string;
 }
 declare const ACTION_FX_CATEGORY_ORDER: ReadonlyArray<ActionFxCategory>;
 declare const ACTION_FX_CATEGORY_LABELS: Readonly<Record<ActionFxCategory, string>>;
@@ -2392,6 +2684,16 @@ declare const ACTION_FX_IDS: ReadonlyArray<string>;
 declare function getActionFx(id: string | undefined | null): ActionFx | undefined;
 declare function getActionFxLabel(id: string | undefined | null, fallback?: string): string;
 declare function getActionFxPromptHint(id: string | undefined | null): string;
+/**
+ * Compact professional TERM for an id — the short phrase a VFX supervisor
+ * would write in a prompt ("haboob dust storm", "metal-on-metal friction
+ * sparks"), as opposed to the paragraph-length `promptHint`.
+ *
+ * Same lookup and same empty-string-on-miss behavior as
+ * `getActionFxPromptHint`, so the two can never disagree about which entry
+ * they describe.
+ */
+declare function getActionFxTerm(id: string | undefined | null): string;
 /**
  * Multi-pick: 1–2 ids → composite FX clause.
  *
@@ -2401,7 +2703,12 @@ declare function getActionFxPromptHint(id: string | undefined | null): string;
  * cap, but the cap here keeps the contract robust against stale workflow
  * data. Duplicate ids are deduplicated before the cap is applied.
  */
-declare function buildActionFxHints(value: unknown): string[];
+declare function buildActionFxHints(value: unknown, mode?: PickerHintMode): string[];
+/**
+ * Compact-mode mirror of `buildActionFxHints`: the same 1–2 ids, resolved to
+ * their short professional terms instead of their paragraph-length hints.
+ */
+declare function buildActionFxTerms(value: unknown): string[];
 
 /**
  * Canonical catalog of Aesthetic / Microtrend choices.
@@ -2423,6 +2730,7 @@ declare function buildActionFxHints(value: unknown): string[];
  * and the prompt-hint injection on both the frontend DAG executor and the
  * backend orchestrator.
  */
+
 type AestheticCategory = "mainstream" | "niche" | "era" | "mood";
 interface Aesthetic {
     readonly id: string;
@@ -2430,17 +2738,32 @@ interface Aesthetic {
     readonly category: AestheticCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term (see `term.ts`). Authored only where the
+     * lowercased label is not the phrase a stylist would write in a prompt —
+     * UI compounds ("Techwear / Gorpcore") and the fashion-era labels whose
+     * bare nouns name an art movement rather than the look.
+     */
+    readonly term?: string;
 }
 declare const AESTHETICS: ReadonlyArray<Aesthetic>;
 declare function getAesthetic(id: string | undefined | null): Aesthetic | undefined;
 declare function getAestheticLabel(id: string | undefined | null, fallback?: string): string;
 declare function getAestheticPromptHint(id: string | undefined | null): string;
+/** Compact-mode sibling of `getAestheticPromptHint` (see `term.ts`). */
+declare function getAestheticTerm(id: string | undefined | null): string;
 /**
  * Multi-pick variant: 1-2 aesthetic ids → blended hint. Single → entry's
  * own promptHint. Two → "styled in a {A} + {B} aesthetic blend" with
  * canonical entry labels (Y2K, dark academia, etc. stay as written).
  */
-declare function buildAestheticHints(value: unknown): string;
+declare function buildAestheticHints(value: unknown, mode?: PickerHintMode): string;
+/**
+ * Compact-mode sibling of `buildAestheticHints`: same 1-2 id shape, same
+ * blend structure, but composed from the entries' short terms instead of
+ * their paragraph-length hints.
+ */
+declare function buildAestheticTerms(value: unknown): string;
 declare const AESTHETIC_IDS: ReadonlyArray<string>;
 declare const AESTHETIC_CATEGORY_LABELS: Readonly<Record<AestheticCategory, string>>;
 declare const AESTHETIC_CATEGORY_ORDER: ReadonlyArray<AestheticCategory>;
@@ -2457,23 +2780,44 @@ declare const AESTHETIC_CATEGORY_ORDER: ReadonlyArray<AestheticCategory>;
  * Shared between the picker UI and the prompt-hint injection on both the
  * frontend DAG executor and the backend orchestrator.
  */
+
 interface Atmosphere {
     readonly id: string;
     readonly label: string;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term for this atmosphere ("dense fog", "sparks and
+     * embers") — authored only where the lowercased label is not what a DP or
+     * VFX supervisor would write in a prompt. See `term.ts`.
+     */
+    readonly term?: string;
 }
 declare const ATMOSPHERES: ReadonlyArray<Atmosphere>;
 declare function getAtmosphere(id: string | undefined | null): Atmosphere | undefined;
 declare function getAtmosphereLabel(id: string | undefined | null, fallback?: string): string;
 declare function getAtmospherePromptHint(id: string | undefined | null): string;
+/**
+ * Compact counterpart of `getAtmospherePromptHint`: the short professional
+ * term this atmosphere injects in compact hint mode ("dense fog" where the
+ * hint is the full sentence). Empty string for an unknown id and for any
+ * entry that injects no hint at all.
+ */
+declare function getAtmosphereTerm(id: string | undefined | null): string;
 /**
  * Multi-pick: 1-2 atmosphere ids → composite atmospheric clause. Single →
  * entry's own promptHint. Two → emit independently and join — atmospheres
  * are particle-effect descriptions that compose naturally
  * ("fog drifting in soft cool clouds, with golden god-rays cutting through").
  */
-declare function buildAtmosphereHints(value: unknown): string[];
+declare function buildAtmosphereHints(value: unknown, mode?: PickerHintMode): string[];
+/**
+ * Compact counterpart of `buildAtmosphereHints`: the same 1-2 id multi-pick,
+ * emitted as short professional terms instead of full mechanism sentences
+ * ("dense fog", "god rays"). Same collection order, same skip-the-no-ops
+ * behavior.
+ */
+declare function buildAtmosphereTerms(value: unknown): string[];
 declare const ATMOSPHERE_IDS: ReadonlyArray<string>;
 
 /**
@@ -2506,11 +2850,20 @@ interface Backdrop {
     readonly category: BackdropCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term injected in compact hint mode — authored only
+     * where the lowercased label would not read as the backdrop a photographer
+     * means (bare colors that describe the SUBJECT instead of the wall, UI
+     * shorthand like "Muslin" or "Paper Roll Seamless"). See `term.ts`.
+     */
+    readonly term?: string;
 }
 declare const BACKDROPS: ReadonlyArray<Backdrop>;
 declare function getBackdrop(id: string | undefined | null): Backdrop | undefined;
 declare function getBackdropLabel(id: string | undefined | null, fallback?: string): string;
 declare function getBackdropPromptHint(id: string | undefined | null): string;
+/** Compact professional term for a backdrop id — the short form of the hint. */
+declare function getBackdropTerm(id: string | undefined | null): string;
 declare const BACKDROP_IDS: ReadonlyArray<string>;
 declare const BACKDROP_CATEGORY_LABELS: Readonly<Record<BackdropCategory, string>>;
 declare const BACKDROP_CATEGORY_ORDER: ReadonlyArray<BackdropCategory>;
@@ -2530,11 +2883,28 @@ interface CameraFormat {
     readonly label: string;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term (see `term.ts`). Authored only where the
+     * lowercased label is not what a cinematographer would write in a prompt:
+     * a UI compound ("Webcam / FaceTime", "Tintype / Wet Plate", "B&W Film"),
+     * a parenthetical whose annotation carries the meaning ("Drone (Aerial)",
+     * "Toy Camera (Holga)", "Security Cam (CCTV)"), a bare name that reads as
+     * a subject rather than a capture medium once lowercased ("red komodo" is
+     * a lizard, "iphone" is a phone in frame), or a correct-but-underspecified
+     * name whose `promptHint` carries the distinguishing detail ("Camcorder" →
+     * "90s consumer camcorder", "Voigtlander" → "voigtlander rangefinder",
+     * "Super 8" → "super 8mm film"). Remaining labels are already the trade
+     * term ("35mm film", "vhs", "polaroid", "daguerreotype") and carry no
+     * `term`.
+     */
+    readonly term?: string;
 }
 declare const CAMERA_FORMATS: ReadonlyArray<CameraFormat>;
 declare function getCameraFormat(id: string | undefined | null): CameraFormat | undefined;
 declare function getCameraFormatLabel(id: string | undefined | null, fallback?: string): string;
 declare function getCameraFormatPromptHint(id: string | undefined | null): string;
+/** Compact-mode sibling of `getCameraFormatPromptHint` — same lookup, short form. */
+declare function getCameraFormatTerm(id: string | undefined | null): string;
 declare const CAMERA_FORMAT_IDS: ReadonlyArray<string>;
 
 /**
@@ -2545,6 +2915,7 @@ declare const CAMERA_FORMAT_IDS: ReadonlyArray<string>;
  * cue that gets appended to the user prompt when the node has camera
  * motion enabled.
  */
+
 type CameraMotionCategory = "default" | "pan" | "tilt" | "zoom" | "dolly" | "truck" | "pedestal" | "roll" | "orbit" | "crane" | "tracking" | "special";
 interface CameraMotion {
     readonly id: string;
@@ -2552,6 +2923,12 @@ interface CameraMotion {
     readonly category: CameraMotionCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term for this move ("whip pan left", "push-pull
+     * swing") — authored only where the lowercased label is not what a
+     * cinematographer would write in a prompt. See `term.ts`.
+     */
+    readonly term?: string;
 }
 declare const CAMERA_MOTIONS: ReadonlyArray<CameraMotion>;
 declare const CAMERA_MOTION_CATEGORY_ORDER: ReadonlyArray<CameraMotionCategory>;
@@ -2561,6 +2938,15 @@ declare function getCameraMotion(id: string | undefined | null): CameraMotion |
 declare function getCameraMotionLabel(id: string | undefined | null, fallback?: string): string;
 /** Descriptive prompt hint for the given motion id. Empty string when motion is "auto" or unknown. */
 declare function getCameraMotionPromptHint(id: string | undefined | null): string;
+/**
+ * Compact counterpart of `getCameraMotionPromptHint`: the short professional
+ * term a cinematographer would write for this move ("whip pan left",
+ * "push-pull swing") where the hint is the full mechanism sentence. Same
+ * lookup and same empty-string-on-miss behavior, so the two getters can never
+ * disagree about which motion they describe; "auto" (which injects nothing)
+ * resolves to "" here too.
+ */
+declare function getCameraMotionTerm(id: string | undefined | null): string;
 declare const CAMERA_MOTION_IDS: ReadonlyArray<string>;
 /**
  * Compose a structural prompt-hint sentence from a camera-motion id plus
@@ -2576,8 +2962,24 @@ declare const CAMERA_MOTION_IDS: ReadonlyArray<string>;
  * Hints within each side are joined with " and " for grammatical flow.
  * If multiple nodes are connected (e.g. Framing + Lighting + Tone), all
  * three contribute their hint to the clause.
+ *
+ * @param mode `"compact"` delegates to `composeCameraMotionTermFromConnections`
+ *   — the same start/end structure built from the motion's short professional
+ *   `term`. The caller is expected to have resolved the connected nodes to
+ *   THEIR terms too, so the whole fragment stays at one level of detail.
+ */
+declare function composeCameraMotionHintFromConnections(motionId: string | undefined, startHints: ReadonlyArray<string>, endHints: ReadonlyArray<string>, mode?: PickerHintMode): string;
+/**
+ * Compact-mode mirror of `composeCameraMotionHintFromConnections`: the same
+ * start/end structure, built from the motion's short `term` and the connected
+ * parameter nodes' terms instead of their full promptHints
+ * ("dolly in, beginning with wide shot, ending with medium close-up").
+ *
+ * Same shape in every respect — empty base (an "auto" or unknown motion) still
+ * yields "", each side is joined with " and ", and the clauses are appended in
+ * start-then-end order.
  */
-declare function composeCameraMotionHintFromConnections(motionId: string | undefined, startHints: ReadonlyArray<string>, endHints: ReadonlyArray<string>): string;
+declare function composeCameraMotionTermFromConnections(motionId: string | undefined, startTerms: ReadonlyArray<string>, endTerms: ReadonlyArray<string>): string;
 
 /**
  * Canonical catalog of character-driven effects for AI-video generation.
@@ -2598,6 +3000,7 @@ declare function composeCameraMotionHintFromConnections(motionId: string | undef
  *
  * null input is treated like undefined (falsy short-circuit → returns "")
  */
+
 type CharacterFxCategory = "transformation" | "power" | "body-mod" | "face-expression" | "aura-ambient";
 interface CharacterFx {
     readonly id: string;
@@ -2605,6 +3008,8 @@ interface CharacterFx {
     readonly category: CharacterFxCategory;
     readonly description: string;
     readonly promptHint: string;
+    /** Optional authored compact term (see `term.ts` for the convention). */
+    readonly term?: string;
 }
 type CharacterFxPosition = "auto" | "start" | "middle" | "end" | "full";
 type CharacterFxDuration = "auto" | "instant" | "short" | "medium" | "long";
@@ -2620,6 +3025,14 @@ declare const CHARACTER_FX_CATEGORY_LABELS: Readonly<Record<CharacterFxCategory,
 declare function getCharacterFx(id: string | undefined | null): CharacterFx | undefined;
 declare function getCharacterFxLabel(id: string | undefined | null, fallback?: string): string;
 declare function getCharacterFxPromptHint(id: string | undefined | null): string;
+/**
+ * Compact counterpart of `getCharacterFxPromptHint`: the short professional
+ * term this effect injects in compact hint mode ("werewolf transformation"
+ * where the hint is the full shot description). Same lookup and same
+ * empty-string-on-miss behavior — including the no-op "auto"/"none" entries,
+ * which inject nothing at either detail level.
+ */
+declare function getCharacterFxTerm(id: string | undefined | null): string;
 declare const CHARACTER_FX_IDS: ReadonlyArray<string>;
 /**
  * Compose a character-fx prompt-hint sentence from an effect id (or array
@@ -2629,9 +3042,21 @@ declare const CHARACTER_FX_IDS: ReadonlyArray<string>;
  *
  * Substitution: each base hint has every `"the subject"` occurrence
  * rewritten to the target name BEFORE the join. Empty targetHints leaves
- * "the subject" intact in the prompt.
- */
-declare function composeCharacterFxHintFromConnections(effectId: string | ReadonlyArray<string> | undefined, targetHints: ReadonlyArray<string>, timing?: CharacterFxTiming): string;
+ * "the subject" intact in the prompt. In compact hint mode the base is a bare
+ * `term` with no "the subject" to rewrite, so the target is named by an
+ * explicit `"{target}: {effects}"` prefix instead — the character is named in
+ * both modes.
+ *
+ * @param mode `"compact"` builds the base from each effect's short
+ *   professional `term` instead of its full shot description. The ", and "
+ *   multi-pick join and the position/duration/intensity clauses are emitted
+ *   identically in both modes. The TARGET is not: no `term` contains the
+ *   words "the subject" (a term names the effect, not a sentence about a
+ *   subject), so compact mode names the target with an explicit
+ *   `"{target}: {effects}"` prefix instead of substituting into the base.
+ *   Either way the wired character is always named.
+ */
+declare function composeCharacterFxHintFromConnections(effectId: string | ReadonlyArray<string> | undefined, targetHints: ReadonlyArray<string>, timing?: CharacterFxTiming, mode?: PickerHintMode): string;
 
 /**
  * Canonical catalog of color/look choices.
@@ -2652,6 +3077,16 @@ interface ColorLook {
     readonly category: ColorLookCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional form injected in COMPACT hint mode ("warm color
+     * grade" where `promptHint` is the full sentence). Authored only where the
+     * lowercased label is not already what a colorist would write — e.g. bare
+     * grade adjectives ("Warm", "Sepia"), UI compounds ("Teal & Orange",
+     * "Agfa / ORWO"), annotated stock names ("Kodak Tri-X 400 (B&W)") and
+     * stacked modifiers with no head noun ("MTV 90s VHS"). See `term.ts`;
+     * resolve via `resolveTerm`.
+     */
+    readonly term?: string;
 }
 declare const COLOR_LOOKS: ReadonlyArray<ColorLook>;
 declare const COLOR_LOOK_CATEGORY_ORDER: ReadonlyArray<ColorLookCategory>;
@@ -2659,6 +3094,8 @@ declare const COLOR_LOOK_CATEGORY_LABELS: Record<ColorLookCategory, string>;
 declare function getColorLook(id: string | undefined | null): ColorLook | undefined;
 declare function getColorLookLabel(id: string | undefined | null, fallback?: string): string;
 declare function getColorLookPromptHint(id: string | undefined | null): string;
+/** Compact sibling of `getColorLookPromptHint` — the short colorist term. */
+declare function getColorLookTerm(id: string | undefined | null): string;
 declare const COLOR_LOOK_IDS: ReadonlyArray<string>;
 
 /**
@@ -2682,11 +3119,20 @@ interface CompositionEffect {
     readonly label: string;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Optional authored compact term (see `term.ts`). Authored only where the
+     * lowercased label is not the phrase a retoucher / VFX artist would write in
+     * a prompt — "Doubled Mirror" reads as a doubled mirror, not as a mirrored
+     * duplicate of the subject. Everywhere else the label IS the term.
+     */
+    readonly term?: string;
 }
 declare const COMPOSITION_EFFECTS: ReadonlyArray<CompositionEffect>;
 declare function getCompositionEffect(id: string | undefined | null): CompositionEffect | undefined;
 declare function getCompositionEffectLabel(id: string | undefined | null, fallback?: string): string;
 declare function getCompositionEffectPromptHint(id: string | undefined | null): string;
+/** The compact professional term for a composition effect (see `term.ts`). */
+declare function getCompositionEffectTerm(id: string | undefined | null): string;
 declare const COMPOSITION_EFFECT_IDS: ReadonlyArray<string>;
 
 /**
@@ -2714,11 +3160,23 @@ interface Era {
     readonly category: EraCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact period name for prompt injection, authored only where the
+     * lowercased label is not what a period stylist would write: UI compounds
+     * ("1950s Diner / Pin-up"), annotated labels ("Fin-de-siècle (1895-1905)"),
+     * and decade names whose word order reads as a menu entry rather than an era
+     * ("Atomic Age 50s", "Pre-War Roaring"). Proper era names — medieval,
+     * renaissance, victorian, dieselpunk — need nothing; the label already IS
+     * the term.
+     */
+    readonly term?: string;
 }
 declare const ERAS: ReadonlyArray<Era>;
 declare function getEra(id: string | undefined | null): Era | undefined;
 declare function getEraLabel(id: string | undefined | null, fallback?: string): string;
 declare function getEraPromptHint(id: string | undefined | null): string;
+/** Compact counterpart of `getEraPromptHint` — the short period name. */
+declare function getEraTerm(id: string | undefined | null): string;
 declare const ERA_IDS: ReadonlyArray<string>;
 declare const ERA_CATEGORY_LABELS: Readonly<Record<EraCategory, string>>;
 declare const ERA_CATEGORY_ORDER: ReadonlyArray<EraCategory>;
@@ -2743,6 +3201,7 @@ declare const ERA_CATEGORY_ORDER: ReadonlyArray<EraCategory>;
  * node, and the prompt-hint injection on both the frontend DAG executor and
  * the backend orchestrator.
  */
+
 type ExposureCategory = "aperture" | "shutter-speed" | "iso";
 interface ExposureSettings {
     readonly id: string;
@@ -2750,6 +3209,25 @@ interface ExposureSettings {
     readonly category: ExposureCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Optional authored compact term (see `term.ts`). Authored on nearly every
+     * dial value, because the mechanical derivation mangles all three
+     * categories — the f-stop slash reads as a UI compound ("f/1.2"), the
+     * shutter fraction loses its unit and its annotation ("1/1000 (action
+     * freeze)" → "1/1000"), and the ISO annotation is stripped ("ISO 3200
+     * (heavy grain)" → "iso 3200").
+     *
+     * Each term is the terse trade phrase a photographer writes — the dial
+     * value plus its category noun ("f/2.8 aperture", "1/500s shutter speed",
+     * "iso 1600 film speed") — and NOT the visual consequence: that is what
+     * `promptHint` is for, and a comma-bearing term would split into unrelated
+     * items once compact terms are joined into a comma-delimited list.
+     *
+     * ISO 400 / ISO 800 need nothing: their labels already read as the term.
+     * The three annotated ISO labels carry the category noun only because the
+     * guard requires an authored term to differ from the derivation.
+     */
+    readonly term?: string;
 }
 declare const EXPOSURE_SETTINGS: ReadonlyArray<ExposureSettings>;
 declare const EXPOSURE_CATEGORY_ORDER: ReadonlyArray<ExposureCategory>;
@@ -2757,6 +3235,16 @@ declare const EXPOSURE_CATEGORY_LABELS: Record<ExposureCategory, string>;
 declare function getExposure(id: string | undefined | null): ExposureSettings | undefined;
 declare function getExposureLabel(id: string | undefined | null, fallback?: string): string;
 declare function getExposurePromptHint(id: string | undefined | null): string;
+/**
+ * Compact professional TERM for an exposure id — the short phrase a
+ * photographer would write in a prompt ("f/1.4 aperture"), as opposed to the
+ * sentence-long `promptHint`.
+ *
+ * Same lookup and same empty-string-on-miss behavior as
+ * `getExposurePromptHint`, so the two can never disagree about which entry
+ * they describe.
+ */
+declare function getExposureTerm(id: string | undefined | null): string;
 declare const EXPOSURE_IDS: ReadonlyArray<string>;
 /**
  * Maps each ExposureCategory to the consumer data field name that holds the
@@ -2782,6 +3270,16 @@ declare function buildExposureHints(data: Record<string, unknown> & {
     aperture?: unknown;
     shutterSpeed?: unknown;
     isoValue?: unknown;
+}, mode?: PickerHintMode): string[];
+/**
+ * Compact-mode mirror of `buildExposureHints`: the same per-category fields in
+ * the same canonical order (aperture, shutter-speed, iso), resolved to their
+ * short professional terms instead of their sentence-long hints.
+ */
+declare function buildExposureTerms(data: Record<string, unknown> & {
+    aperture?: unknown;
+    shutterSpeed?: unknown;
+    isoValue?: unknown;
 }): string[];
 
 /**
@@ -2794,6 +3292,7 @@ declare function buildExposureHints(data: Record<string, unknown> & {
  * Shared between the picker UI and the prompt-hint injection on both the
  * frontend DAG executor and the backend orchestrator.
  */
+
 type FramingCategory = "shot-size" | "angle" | "coverage" | "composition" | "vantage";
 interface Framing {
     readonly id: string;
@@ -2801,6 +3300,18 @@ interface Framing {
     readonly category: FramingCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Optional authored compact term (see `term.ts`). Authored only where the
+     * lowercased label is not the phrase a cinematographer would write in a
+     * prompt — a UI compound ("Golden Spiral / Fibonacci"), an annotation
+     * ("ECU: Eye"), a reversed pair ("Headroom Tight" → "tight headroom"), a
+     * bare word that needs its shot noun ("Insert" → "insert shot"), or a trade
+     * phrase whose bare form reads as something else entirely once the trade
+     * context is stripped ("Choker" the neckwear, "Dirty Single" the grime,
+     * "Single" the continuous take). Everywhere else the label IS the term and
+     * nothing is authored.
+     */
+    readonly term?: string;
 }
 declare const FRAMINGS: ReadonlyArray<Framing>;
 declare const FRAMING_CATEGORY_ORDER: ReadonlyArray<FramingCategory>;
@@ -2808,6 +3319,13 @@ declare const FRAMING_CATEGORY_LABELS: Record<FramingCategory, string>;
 declare function getFraming(id: string | undefined | null): Framing | undefined;
 declare function getFramingLabel(id: string | undefined | null, fallback?: string): string;
 declare function getFramingPromptHint(id: string | undefined | null): string;
+/**
+ * The compact professional term for a framing id (see `term.ts`): the short
+ * phrase this framing injects in compact hint mode ("tight headroom" where the
+ * hint is the full clause). Empty string for an unknown id and for any entry
+ * that injects no hint at all.
+ */
+declare function getFramingTerm(id: string | undefined | null): string;
 declare const FRAMING_IDS: ReadonlyArray<string>;
 declare function isVantageFraming(id: string | undefined | null): boolean;
 /**
@@ -2856,6 +3374,19 @@ declare function buildFramingHints(data: Record<string, unknown> & {
     coverage?: unknown;
     composition?: unknown;
     vantage?: unknown;
+}, skipVantage?: boolean, mode?: PickerHintMode): string[];
+/**
+ * Compact counterpart of `buildFramingHints`: the same per-category walk in the
+ * same canonical order and with the same `skipVantage` gate, emitted as short
+ * professional terms instead of full mechanism clauses ("medium close-up",
+ * "tight headroom"). Entries that inject no hint contribute no term either.
+ */
+declare function buildFramingTerms(data: Record<string, unknown> & {
+    shotSize?: unknown;
+    angle?: unknown;
+    coverage?: unknown;
+    composition?: unknown;
+    vantage?: unknown;
 }, skipVantage?: boolean): string[];
 
 /**
@@ -2881,6 +3412,7 @@ declare function buildFramingHints(data: Record<string, unknown> & {
  * node, and the prompt-hint injection on both the frontend DAG executor
  * and the backend orchestrator.
  */
+
 type HeldPropCategory = "device" | "drink" | "smoking" | "reading-writing" | "bag-accessory" | "floral-nature" | "instrument" | "companion" | "occupational";
 interface HeldProp {
     readonly id: string;
@@ -2888,18 +3420,57 @@ interface HeldProp {
     readonly category: HeldPropCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term for hint-compact mode (see `term.ts`). Authored
+     * on EVERY entry, and always with the held-in-hand VERB the catalog exists
+     * to encode ("holding a lit cigarette", "cradling a cat", "carrying a
+     * hard-shell briefcase"): the bare prop noun would say only that the object
+     * is somewhere in the scene, which is exactly the Object-node meaning this
+     * catalog is distinct from. Beyond the verb, each term also carries the
+     * qualifier the label drops where the bare noun would inject the wrong prop
+     * — homonym traps ("Lighter", "Joint", "Compass", "Marker", "Apple"), a
+     * trade meaning that collides with a sibling ("Cocktail Glass" is the
+     * conical glass in the trade; this entry is a rocks glass), and the state
+     * that decides what actually RENDERS ("Umbrella" -> open black umbrella,
+     * "Book" -> open hardback book).
+     */
+    readonly term?: string;
 }
 declare const HELD_PROPS: ReadonlyArray<HeldProp>;
 declare function getHeldProp(id: string | undefined | null): HeldProp | undefined;
 declare function getHeldPropLabel(id: string | undefined | null, fallback?: string): string;
 declare function getHeldPropPromptHint(id: string | undefined | null): string;
+/**
+ * Compact professional TERM for an id — the short prop phrase a stylist would
+ * write in a prompt ("holding a lit chrome lighter", "cradling a cat"), as
+ * opposed to the pose-carrying paragraph in `promptHint`.
+ *
+ * KEEPS the catalog's held-in-hand verb ("holding a…", "cradling a…",
+ * "carrying a…"). No consumer re-adds it — the orchestrator and the frontend
+ * resolver append the fragment verbatim, and a thin client injects the
+ * projected `term` standalone — so dropping the verb would turn "the subject
+ * is holding X" into "X is somewhere in the scene".
+ *
+ * Same lookup and same empty-string-on-miss behavior as
+ * `getHeldPropPromptHint`, so the two can never disagree about which entry
+ * they describe.
+ */
+declare function getHeldPropTerm(id: string | undefined | null): string;
 /**
  * Multi-pick: 1-2 prop ids → composite held-prop clause. Single → entry's
  * own promptHint (which already starts with "holding..." / "carrying..."
  * grammar). Two → emit independently, joined by buildPersonHints-style
  * comma-join. Common combos: book + coffee, cigarette + drink, phone + bag.
  */
-declare function buildHeldPropHints(value: unknown): string[];
+declare function buildHeldPropHints(value: unknown, mode?: PickerHintMode): string[];
+/**
+ * Compact-mode mirror of `buildHeldPropHints`: the same ids in the same order,
+ * resolved to their short professional terms — verb included — instead of
+ * their pose-carrying paragraph hints. The caller joins the array exactly as
+ * it joins the full hints, so each term carrying its own verb is what keeps a
+ * two-prop pick reading correctly.
+ */
+declare function buildHeldPropTerms(value: unknown): string[];
 declare const HELD_PROP_IDS: ReadonlyArray<string>;
 declare const HELD_PROP_CATEGORY_LABELS: Readonly<Record<HeldPropCategory, string>>;
 declare const HELD_PROP_CATEGORY_ORDER: ReadonlyArray<HeldPropCategory>;
@@ -2916,6 +3487,7 @@ declare const HELD_PROP_CATEGORY_ORDER: ReadonlyArray<HeldPropCategory>;
  * (https://splice.com/sounds/instruments) — Drums / Percussion / Keys /
  * Synth / Guitar / Bass / Brass / Woodwinds / Strings / World.
  */
+
 type InstrumentCategory = "drums" | "percussion" | "keys" | "synth" | "guitar" | "bass" | "brass" | "woodwinds" | "strings" | "world" | "middle-eastern";
 declare const INSTRUMENT_CATEGORY_ORDER: ReadonlyArray<InstrumentCategory>;
 declare const INSTRUMENT_CATEGORY_LABELS: Readonly<Record<InstrumentCategory, string>>;
@@ -2924,7 +3496,18 @@ interface InstrumentationEntry {
     readonly label: string;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Optional authored compact term (see `term.ts` for the convention).
+     * Authored only where the lowercased label is NOT what a producer would
+     * write in a prompt — bare modifiers whose trade term carries a category
+     * noun ("Stab" → "synth stab", "Polished" → "polished production"), bare
+     * genre words in the singing-style slot ("Pop" → "pop singing"), and
+     * annotated labels ("Trap (Melodic)" → "melodic trap singing"). Everywhere
+     * else the lowercased label IS the term and nothing is authored.
+     */
+    readonly term?: string;
 }
+/** Inherits the optional `term` from `InstrumentationEntry`. */
 interface CategorizedInstrument extends InstrumentationEntry {
     readonly category: InstrumentCategory;
 }
@@ -2940,6 +3523,17 @@ declare function getInstrument(id: string | undefined): CategorizedInstrument |
 declare function getProductionStyle(id: string | undefined): InstrumentationEntry | undefined;
 declare function getVocalPresence(id: string | undefined): InstrumentationEntry | undefined;
 declare function getSingingStyle(id: string | undefined): InstrumentationEntry | undefined;
+/**
+ * The COMPACT counterparts of the `promptHint` lookups: the short professional
+ * term a consumer injects instead of the entry's full fragment ("synth stab",
+ * "pristine studio production", "melodic trap singing"). Same lookup as the
+ * getters above, same empty-string-on-miss behavior, so hint mode and term
+ * mode can never disagree about WHICH entry they are describing.
+ */
+declare function getInstrumentTerm(id: string | undefined | null): string;
+declare function getProductionStyleTerm(id: string | undefined | null): string;
+declare function getVocalPresenceTerm(id: string | undefined | null): string;
+declare function getSingingStyleTerm(id: string | undefined | null): string;
 declare function buildInstrumentationHints(data: {
     readonly preText?: string;
     readonly postText?: string;
@@ -2947,6 +3541,21 @@ declare function buildInstrumentationHints(data: {
     readonly production?: string;
     readonly vocalPresence?: string | ReadonlyArray<string>;
     readonly singingStyle?: string | ReadonlyArray<string>;
+}, mode?: PickerHintMode): string;
+/**
+ * Compact-mode mirror of `buildInstrumentationHints`: the same preText /
+ * [production] [instruments] / "with <vocals>" / "in <style> style" / postText
+ * structure, in the same canonical field order, built from each entry's short
+ * `term` instead of its full `promptHint`. preText / postText are user free
+ * text rather than catalog copy, so they pass through untouched in both modes.
+ */
+declare function buildInstrumentationTerms(data: {
+    readonly preText?: string;
+    readonly postText?: string;
+    readonly instruments?: ReadonlyArray<string>;
+    readonly production?: string;
+    readonly vocalPresence?: string | ReadonlyArray<string>;
+    readonly singingStyle?: string | ReadonlyArray<string>;
 }): string;
 declare function isInstrumentalVocal(value: unknown): boolean;
 declare const INSTRUMENTATION_DEFAULT_DATA: {
@@ -2974,11 +3583,22 @@ interface Lens {
     readonly label: string;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Optional authored compact term (see `term.ts`). Authored where the
+     * lowercased label is not what a cinematographer would write in a prompt —
+     * the focal length lives in a parenthetical the derivation drops
+     * ("Wide (24mm)" → "wide"), or the bare optic name needs its category noun
+     * ("Macro" → "macro lens", "Shallow DOF" → "shallow depth of field").
+     * Everywhere else the label IS the term.
+     */
+    readonly term?: string;
 }
 declare const LENSES: ReadonlyArray<Lens>;
 declare function getLens(id: string | undefined | null): Lens | undefined;
 declare function getLensLabel(id: string | undefined | null, fallback?: string): string;
 declare function getLensPromptHint(id: string | undefined | null): string;
+/** The compact professional term for a lens (see `term.ts`). */
+declare function getLensTerm(id: string | undefined | null): string;
 declare const LENS_IDS: ReadonlyArray<string>;
 
 /**
@@ -2992,6 +3612,7 @@ declare const LENS_IDS: ReadonlyArray<string>;
  * Shared between the picker UI and the prompt-hint injection on both the
  * frontend DAG executor and the backend orchestrator.
  */
+
 type LightingCategory = "time-of-day" | "style" | "direction" | "lighting-ratio" | "color-temperature";
 interface Lighting {
     readonly id: string;
@@ -2999,6 +3620,15 @@ interface Lighting {
     readonly category: LightingCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term injected in compact hint mode (see `term.ts`).
+     *
+     * Lighting labels are bare MODIFIERS — "Short", "Broad", "Loop", "Split",
+     * "Hard" mean nothing on their own and collide head-on with common English
+     * words, so nearly every entry here authors the trade phrasing that carries
+     * its category noun ("short lighting", "1:4 lighting ratio").
+     */
+    readonly term?: string;
 }
 declare const LIGHTINGS: ReadonlyArray<Lighting>;
 declare const LIGHTING_CATEGORY_ORDER: ReadonlyArray<LightingCategory>;
@@ -3006,6 +3636,13 @@ declare const LIGHTING_CATEGORY_LABELS: Record<LightingCategory, string>;
 declare function getLighting(id: string | undefined | null): Lighting | undefined;
 declare function getLightingLabel(id: string | undefined | null, fallback?: string): string;
 declare function getLightingPromptHint(id: string | undefined | null): string;
+/**
+ * The COMPACT counterpart of `getLightingPromptHint`: the short professional
+ * term ("rembrandt lighting", "1:4 lighting ratio", "rim backlight") a
+ * consumer injects instead of the full mechanism description. Same lookup,
+ * same empty-string-on-miss behavior.
+ */
+declare function getLightingTerm(id: string | undefined | null): string;
 declare const LIGHTING_IDS: ReadonlyArray<string>;
 /**
  * Maps each LightingCategory to the consumer data field name that holds the
@@ -3049,6 +3686,22 @@ declare function buildLightingHints(data: Record<string, unknown> & {
     lightingDirection?: unknown;
     lightingRatio?: unknown;
     colorTemperature?: unknown;
+}, mode?: PickerHintMode): string[];
+/**
+ * The COMPACT counterpart of `buildLightingHints`: the same per-category walk
+ * in the same canonical order, emitting each selection's short professional
+ * term ("dusk lighting", "rembrandt lighting", "1:4 lighting ratio") instead
+ * of its full mechanism description.
+ *
+ * @param data the consumer data record (must include optional timeOfDay /
+ *   lightingStyle / lightingDirection fields)
+ */
+declare function buildLightingTerms(data: Record<string, unknown> & {
+    timeOfDay?: unknown;
+    lightingStyle?: unknown;
+    lightingDirection?: unknown;
+    lightingRatio?: unknown;
+    colorTemperature?: unknown;
 }): string[];
 
 /**
@@ -3079,13 +3732,25 @@ interface LoopSubject {
     /** Drop-in prompt text for Generate Image. Wired into the prompt input
      *  via FieldMappings, same as Setting / Motion / Mood Parameter nodes. */
     readonly promptHint: string;
+    /** Compact professional term for hint-compact mode (see `term.ts`). Authored
+     *  only where the lowercased label is not what a professional would write —
+     *  the "Tunnel — Exciting" style UI compounds and the generic subject
+     *  labels ("Galaxy", "Underwater Light") that need their trade wording. */
+    readonly term?: string;
 }
 declare const LOOP_SUBJECT_CATEGORY_ORDER: ReadonlyArray<LoopSubjectCategory>;
 declare const LOOP_SUBJECT_CATEGORY_LABELS: Readonly<Record<LoopSubjectCategory, string>>;
 declare const LOOP_SUBJECTS: ReadonlyArray<LoopSubject>;
-declare function getLoopSubject(id: string): LoopSubject | undefined;
+declare function getLoopSubject(id: string | undefined | null): LoopSubject | undefined;
 declare function getLoopSubjectLabel(id: string): string;
 declare function getLoopSubjectPromptHint(id: string): string;
+/**
+ * Compact professional term for the subject — the short phrase a VJ or
+ * cinematographer would write when the consumer wants a term instead of the
+ * full scene paragraph. Mirrors `getLoopSubjectPromptHint`'s lookup so the two
+ * can never describe different entries.
+ */
+declare function getLoopSubjectTerm(id: string | undefined | null): string;
 
 /**
  * Canonical catalog of material presets ("Material").
@@ -3097,7 +3762,10 @@ declare function getLoopSubjectPromptHint(id: string): string;
  *
  * Grammar: every entry's `promptHint` begins with `"made of ..."` — this reads
  * correctly regardless of target ("a dress made of silk", "a human made of
- * glass", "a pillow made of leather", "a train made of plastic").
+ * glass", "a pillow made of leather", "a train made of plastic"). The compact
+ * `term` keeps that same head ("made of polished gold"): without it the
+ * fragment stops saying what the subject IS and merely names a material
+ * present in the scene, which is a different image.
  *
  * For clothing-specific phrasing ("wearing silk"), see the `fabric` dimension
  * on the Styling node. There is intentional overlap in vocabulary (leather,
@@ -3108,6 +3776,7 @@ declare function getLoopSubjectPromptHint(id: string): string;
  * the prompt-hint injection on both the frontend DAG executor and the
  * backend orchestrator.
  */
+
 type MaterialCategory = "fabric" | "metal" | "stone" | "wood" | "glass-ceramic" | "natural" | "exotic";
 interface Material {
     readonly id: string;
@@ -3115,17 +3784,48 @@ interface Material {
     readonly category: MaterialCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term (see `term.ts`). Authored on EVERY material, and
+     * always in the catalog's `"made of ..."` grammar — that grammar is what
+     * makes the fragment mean "the subject IS this material" rather than "this
+     * material is somewhere in the scene", so it belongs to the term as much as
+     * to the hint. It also carries the qualifier the label drops where the bare
+     * noun would mislead: "gold"/"silver" alone read as COLORS, "mesh" as 3D
+     * geometry, "Subsurface Glow" is a UI label for subsurface scattering.
+     */
+    readonly term?: string;
 }
 declare const MATERIALS: ReadonlyArray<Material>;
 declare function getMaterial(id: string | undefined | null): Material | undefined;
 declare function getMaterialLabel(id: string | undefined | null, fallback?: string): string;
 declare function getMaterialPromptHint(id: string | undefined | null): string;
+/**
+ * Compact counterpart of `getMaterialPromptHint`: the short professional term
+ * this material injects in compact hint mode ("made of brushed stainless
+ * steel" where the hint is the full "made of ..." paragraph). The `"made of"`
+ * grammar is part of the TERM, not a wrapper the consumer adds — it is what
+ * distinguishes "the subject is made of glass" from "there is glass in the
+ * scene", and a thin client injecting `term` standalone (see
+ * `ProjectedCatalogOption`) has nothing else to reconstruct it from. Empty
+ * string for an unknown id.
+ */
+declare function getMaterialTerm(id: string | undefined | null): string;
 /**
  * Multi-pick: 1-2 material ids → composite material clause. Single → entry's
  * own promptHint. Two → "made of {A} and {B}" using lowercased entry labels.
  * Covers leather+brass handbag, wood+steel chair, glass+chrome lamp, etc.
+ *
+ * @param mode `"compact"` emits the bare material term(s) instead (delegates
+ *   to `buildMaterialTerms`).
  */
-declare function buildMaterialHints(value: unknown): string;
+declare function buildMaterialHints(value: unknown, mode?: PickerHintMode): string;
+/**
+ * Compact counterpart of `buildMaterialHints`: one material's term, or two
+ * joined with " and " ("made of polished gold and made of walnut"). Each term
+ * carries its own "made of" grammar, so the join needs no wrapper and a
+ * pack-added entry whose term is only the derived label still reads correctly.
+ */
+declare function buildMaterialTerms(value: unknown): string;
 declare const MATERIAL_IDS: ReadonlyArray<string>;
 declare const MATERIAL_CATEGORY_LABELS: Readonly<Record<MaterialCategory, string>>;
 declare const MATERIAL_CATEGORY_ORDER: ReadonlyArray<MaterialCategory>;
@@ -3154,6 +3854,7 @@ declare const MATERIAL_CATEGORY_ORDER: ReadonlyArray<MaterialCategory>;
  * the prompt-hint injection on both the frontend DAG executor and the
  * backend orchestrator.
  */
+
 type MoodCategory = "positive" | "negative" | "neutral" | "intense";
 interface Mood {
     readonly id: string;
@@ -3161,11 +3862,27 @@ interface Mood {
     readonly category: MoodCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term injected in compact hint mode (see `term.ts`).
+     *
+     * Written in the SAME register as the `promptHint`: this catalog describes
+     * the SUBJECT's emotional state, so a term names the expression / demeanor
+     * ("melancholic expression", "cocky smirk", "fierce, commanding intensity"),
+     * never the scene's mood — "melancholic mood" would instruct a different
+     * picture from the one full mode asks for.
+     */
+    readonly term?: string;
 }
 declare const MOODS: ReadonlyArray<Mood>;
 declare function getMood(id: string | undefined | null): Mood | undefined;
 declare function getMoodLabel(id: string | undefined | null, fallback?: string): string;
 declare function getMoodPromptHint(id: string | undefined | null): string;
+/**
+ * The COMPACT counterpart of `getMoodPromptHint`: the short professional term
+ * ("melancholic expression", "cocky smirk") a consumer injects instead of the
+ * full expression clause. Same lookup, same empty-string-on-miss behavior.
+ */
+declare function getMoodTerm(id: string | undefined | null): string;
 declare const MOOD_IDS: ReadonlyArray<string>;
 declare const MOOD_CATEGORY_LABELS: Readonly<Record<MoodCategory, string>>;
 declare const MOOD_CATEGORY_ORDER: ReadonlyArray<MoodCategory>;
@@ -3182,8 +3899,18 @@ interface MoodValue {
  * Build prompt hints from MoodData: optional pre-text, the selected mood's
  * hint (single or mixed), optional post-text. Returns array — caller joins
  * with ", ".
+ *
+ * @param mode `"compact"` swaps the mood fragment for its short professional
+ *   term (delegates to `buildMoodTerms`); pre/post free text is unaffected.
+ */
+declare function buildMoodHints(data: Record<string, unknown> & MoodValue, mode?: PickerHintMode): string[];
+/**
+ * Compact counterpart of `buildMoodHints`: the same pre-text → mood →
+ * post-text order, emitting the mood's short professional term ("melancholic
+ * expression", "cocky smirk") instead of the full expression clause. Free-text
+ * pre/post fields are user prose and pass through unchanged in both modes.
  */
-declare function buildMoodHints(data: Record<string, unknown> & MoodValue): string[];
+declare function buildMoodTerms(data: Record<string, unknown> & MoodValue): string[];
 
 /**
  * Canonical catalog of music genres for Suno / MiniMax / Text-to-Audio
@@ -3198,6 +3925,7 @@ declare function buildMoodHints(data: Record<string, unknown> & MoodValue): stri
  * are Splice-aligned (https://splice.com/sounds/genres) so the taxonomy
  * matches industry conventions.
  */
+
 type MusicGenreCategory = "hip-hop-rnb" | "electronic" | "pop" | "rock-metal" | "acoustic" | "global" | "cinematic";
 declare const MUSIC_GENRE_CATEGORY_ORDER: ReadonlyArray<MusicGenreCategory>;
 declare const MUSIC_GENRE_CATEGORY_LABELS: Readonly<Record<MusicGenreCategory, string>>;
@@ -3205,12 +3933,28 @@ interface MusicSubgenre {
     readonly id: string;
     readonly label: string;
     readonly promptHint: string;
+    /**
+     * Compact professional form injected in COMPACT hint mode (see `term.ts`).
+     * Authored where the lowercased label is not the genre name a producer would
+     * write — the picker drops the parent genre from the label to keep the tile
+     * short ("Conscious" → "conscious hip hop", "Beats" → "lo-fi beats"), the
+     * label is a UI compound the derivation mangles ("Drum & Bass",
+     * "Trap (EDM)"), or the bare word means something else entirely outside
+     * music ("Dub", "Swing", "Romantic"). Everywhere else the label IS the term.
+     */
+    readonly term?: string;
 }
 interface MusicGenre {
     readonly id: string;
     readonly label: string;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional form (see `term.ts`), authored where the lowercased
+     * label does not read as a music genre on its own — "World" → "world music",
+     * "R&B" → "rhythm and blues". Everywhere else the label IS the term.
+     */
+    readonly term?: string;
     readonly category: MusicGenreCategory;
     readonly subgenres: ReadonlyArray<MusicSubgenre>;
 }
@@ -3219,6 +3963,12 @@ interface MusicEra {
     readonly label: string;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional form (see `term.ts`). The decade labels already ARE
+     * the term; authored only for the named eras whose label is not what a
+     * producer writes ("Futurist" → "futuristic").
+     */
+    readonly term?: string;
 }
 declare const MUSIC_GENRES: ReadonlyArray<MusicGenre>;
 declare const MUSIC_ERAS: ReadonlyArray<MusicEra>;
@@ -3226,6 +3976,21 @@ declare function getMusicGenre(id: string | undefined): MusicGenre | undefined;
 declare function getMusicGenreLabel(id: string | undefined): string;
 declare function getMusicSubgenre(genreId: string | undefined, subgenreId: string | undefined): MusicSubgenre | undefined;
 declare function getMusicEra(id: string | undefined): MusicEra | undefined;
+/**
+ * Compact counterpart of a genre's `promptHint`: the short genre name a
+ * producer would write ("rhythm and blues", "world music"). Same lookup and
+ * same empty-string-on-miss behavior as `getMusicGenre`, so hint mode and
+ * compact mode can never disagree about which genre they describe.
+ */
+declare function getMusicGenreTerm(id: string | undefined | null): string;
+/**
+ * Compact counterpart for a subgenre. Keeps `getMusicSubgenre`'s two-argument
+ * lookup — a subgenre id is unique only within its parent genre, so a
+ * single-id term getter could not resolve one.
+ */
+declare function getMusicSubgenreTerm(genreId: string | undefined | null, subgenreId: string | undefined | null): string;
+/** Compact counterpart of an era's `promptHint` — the short period name. */
+declare function getMusicEraTerm(id: string | undefined | null): string;
 /**
  * Compose hints from MusicGenreData: optional preText, structured
  * [era] [subgenre|genre] (or " / "-joined genres for multi), optional
@@ -3242,6 +4007,20 @@ declare function buildMusicGenreHints(data: {
     readonly genre?: string | ReadonlyArray<string>;
     readonly subgenre?: string;
     readonly era?: string;
+}, mode?: PickerHintMode): string;
+/**
+ * Compact-mode mirror of `buildMusicGenreHints`: the same preText / [era]
+ * [subgenre|genre] / postText structure, built from each entry's short `term`
+ * instead of its `promptHint` ("1980s synth pop"). Multi-genre still joins
+ * with " / " and still ignores the subgenre, and preText / postText — user
+ * free text, not catalog copy — pass through untouched.
+ */
+declare function buildMusicGenreTerms(data: {
+    readonly preText?: string;
+    readonly postText?: string;
+    readonly genre?: string | ReadonlyArray<string>;
+    readonly subgenre?: string;
+    readonly era?: string;
 }): string;
 /** Default data when a music-genre node is dropped on canvas. Empty by design — forces a deliberate pick. */
 declare const MUSIC_GENRE_DEFAULT_DATA: {
@@ -3256,11 +4035,22 @@ declare const MUSIC_GENRE_DEFAULT_DATA: {
  * Music mood catalog: energy + emotion + vibe sub-fields.
  * Composed by buildMusicMoodHints into "[energy] [emotion] [vibe]".
  */
+
 interface MusicMoodEntry {
     readonly id: string;
     readonly label: string;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term injected in compact hint mode (see `term.ts`).
+     *
+     * Authored only where the lowercased label is NOT the phrase a music
+     * supervisor would write — the bare-degree energies ("Low"/"Moderate"/
+     * "High" mean nothing without "energy" attached) and the noun-shaped
+     * "Awe". Everywhere else the label already IS the trade descriptor and
+     * `resolveTerm` derives it.
+     */
+    readonly term?: string;
 }
 declare const MUSIC_ENERGIES: ReadonlyArray<MusicMoodEntry>;
 declare const MUSIC_EMOTIONS: ReadonlyArray<MusicMoodEntry>;
@@ -3268,13 +4058,30 @@ declare const MUSIC_VIBES: ReadonlyArray<MusicMoodEntry>;
 declare function getMusicEnergy(id: string | undefined): MusicMoodEntry | undefined;
 declare function getMusicEmotion(id: string | undefined): MusicMoodEntry | undefined;
 declare function getMusicVibe(id: string | undefined): MusicMoodEntry | undefined;
-declare function buildMusicMoodHints(data: {
+/**
+ * The COMPACT counterparts of the `promptHint` lookups: the short professional
+ * term a consumer injects instead of the entry's full fragment ("low-energy",
+ * "building energy", "awe-inspiring"). Same lookup as the getters above, same
+ * empty-string-on-miss behavior, so hint mode and term mode can never disagree
+ * about WHICH entry they are describing.
+ */
+declare function getMusicEnergyTerm(id: string | undefined | null): string;
+declare function getMusicEmotionTerm(id: string | undefined | null): string;
+declare function getMusicVibeTerm(id: string | undefined | null): string;
+interface MusicMoodData {
     readonly preText?: string;
     readonly postText?: string;
     readonly energy?: string;
     readonly emotion?: string | ReadonlyArray<string>;
     readonly vibe?: string | ReadonlyArray<string>;
-}): string;
+}
+declare function buildMusicMoodHints(data: MusicMoodData, mode?: PickerHintMode): string;
+/**
+ * The COMPACT counterpart of `buildMusicMoodHints`: the same field walk in the
+ * same canonical order, emitting each selection's short professional term
+ * instead of its full prompt fragment.
+ */
+declare function buildMusicMoodTerms(data: MusicMoodData): string;
 declare const MUSIC_MOOD_DEFAULT_DATA: {
     preText?: string;
     postText?: string;
@@ -3318,11 +4125,21 @@ interface PhotoGenre {
     readonly category: PhotoGenreCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term (see `term.ts`). Authored only where the
+     * lowercased label is not what a photographer would write in a prompt —
+     * UI compounds ("Campaign / Ad"), the "Signature" brand framing, and bare
+     * nouns that read as the SUBJECT rather than the genre ("documentary",
+     * "real estate", "advertising"). Elsewhere the label IS the term.
+     */
+    readonly term?: string;
 }
 declare const PHOTO_GENRES: ReadonlyArray<PhotoGenre>;
 declare function getPhotoGenre(id: string | undefined | null): PhotoGenre | undefined;
 declare function getPhotoGenreLabel(id: string | undefined | null, fallback?: string): string;
 declare function getPhotoGenrePromptHint(id: string | undefined | null): string;
+/** Compact-mode sibling of `getPhotoGenrePromptHint` — the short trade term. */
+declare function getPhotoGenreTerm(id: string | undefined | null): string;
 declare const PHOTO_GENRE_IDS: ReadonlyArray<string>;
 declare const PHOTO_GENRE_CATEGORY_LABELS: Readonly<Record<PhotoGenreCategory, string>>;
 declare const PHOTO_GENRE_CATEGORY_ORDER: ReadonlyArray<PhotoGenreCategory>;
@@ -3347,6 +4164,7 @@ declare const PHOTO_GENRE_CATEGORY_ORDER: ReadonlyArray<PhotoGenreCategory>;
  * and the prompt-hint injection on both the frontend DAG executor and the
  * backend orchestrator.
  */
+
 type PhotographerCategory = "editorial" | "documentary" | "cinematographer" | "concept" | "illustrator";
 interface Photographer {
     readonly id: string;
@@ -3354,17 +4172,55 @@ interface Photographer {
     readonly category: PhotographerCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact-mode term (see `term.ts`). Authored on EVERY entry here, which is
+     * the exception rather than the rule for a catalog — two reasons specific to
+     * artist styles:
+     *
+     *  1. The derived term would be a bare person's name. Injected raw into a
+     *     generation prompt, "annie leibovitz" reads as the SUBJECT to render,
+     *     not as an attribution — it asks for a picture OF the photographer.
+     *     Consumers inject `term` verbatim (they render `label` and inject
+     *     `term`), so the framing has to live in the term itself.
+     *  2. Per this file's own premise, the name token alone is too vague; the
+     *     model needs a little of the surrounding visual vocabulary to lock onto
+     *     the signature. So each term is `by <name>, <2-3 signature cues>` — a
+     *     compression of the promptHint's own shape, never a copy of it.
+     *     Cinematographers take the DP credit "shot by" instead.
+     *
+     * Optional per the `term.ts` convention, but in THIS catalog a new entry
+     * that omits it falls back to the bare-name derivation described above —
+     * author one alongside the promptHint.
+     */
+    readonly term?: string;
 }
 declare const PHOTOGRAPHERS: ReadonlyArray<Photographer>;
 declare function getPhotographer(id: string | undefined | null): Photographer | undefined;
 declare function getPhotographerLabel(id: string | undefined | null, fallback?: string): string;
 declare function getPhotographerPromptHint(id: string | undefined | null): string;
+/**
+ * Compact-mode sibling of `getPhotographerPromptHint` — same arity, same
+ * lookup, same empty-string-on-miss behavior, so the two can never disagree
+ * about which entry they are describing.
+ */
+declare function getPhotographerTerm(id: string | undefined | null): string;
 /**
  * Multi-pick variant: 1-2 photographer ids → blended hint. Single → entry's
  * own promptHint. Two → "shot in the blended language of {A} and {B}" — the
  * model interprets this as referencing both creators' visual signatures.
  */
-declare function buildPhotographerHints(value: unknown): string;
+declare function buildPhotographerHints(value: unknown, mode?: PickerHintMode): string;
+/**
+ * Compact-mode sibling of `buildPhotographerHints`, mirroring its structure:
+ * one id → that entry's term, two → a blend. The blend drops the per-entry
+ * signature cues and keeps only the credited names, because stacking two
+ * `by <name>, <cues>` fragments is longer than the compact mode exists to be.
+ *
+ * The credit verb is READ OFF the resolved terms rather than hardcoded, so a
+ * cinematographer's "shot by" survives the blend and the one-pick and two-pick
+ * paths can never disagree about how the same entry is credited.
+ */
+declare function buildPhotographerTerms(value: unknown): string;
 declare const PHOTOGRAPHER_IDS: ReadonlyArray<string>;
 declare const PHOTOGRAPHER_CATEGORY_LABELS: Readonly<Record<PhotographerCategory, string>>;
 declare const PHOTOGRAPHER_CATEGORY_ORDER: ReadonlyArray<PhotographerCategory>;
@@ -3390,6 +4246,7 @@ declare const PHOTOGRAPHER_CATEGORY_ORDER: ReadonlyArray<PhotographerCategory>;
  * the prompt-hint injection on both the frontend DAG executor and the
  * backend orchestrator.
  */
+
 type PoseCategory = "standing" | "seated" | "movement" | "action" | "resting" | "hand-position" | "body-lean" | "head-tilt" | "activity";
 interface Pose {
     readonly id: string;
@@ -3397,11 +4254,27 @@ interface Pose {
     readonly category: PoseCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term injected instead of `promptHint` in compact hint
+     * mode. Authored only where the lowercased label is not what a photographer
+     * would write for the pose — bare sub-dimension modifiers ("Tilted Side"),
+     * labels that collide with a different meaning in a generation prompt
+     * ("Painting"), and telegraphic UI phrasings ("Head Over Shoulder").
+     * Everywhere else the derived label already IS the term.
+     */
+    readonly term?: string;
 }
 declare const POSES: ReadonlyArray<Pose>;
 declare function getPose(id: string | undefined | null): Pose | undefined;
 declare function getPoseLabel(id: string | undefined | null, fallback?: string): string;
 declare function getPosePromptHint(id: string | undefined | null): string;
+/**
+ * Compact counterpart of `getPosePromptHint`: the short professional term this
+ * pose injects in compact hint mode ("mid-throw" where the hint is the full
+ * body-mechanics sentence). Empty string for an unknown id and for any entry
+ * that injects no hint at all.
+ */
+declare function getPoseTerm(id: string | undefined | null): string;
 declare const POSE_IDS: ReadonlyArray<string>;
 declare const POSE_CATEGORY_LABELS: Readonly<Record<PoseCategory, string>>;
 declare const POSE_CATEGORY_ORDER: ReadonlyArray<PoseCategory>;
@@ -3430,7 +4303,15 @@ interface PoseValue {
  * hint, the orthogonal hand-position / body-lean / head-tilt hints,
  * optional post-text. Returns array — caller joins with ", ".
  */
-declare function buildPoseHints(data: Record<string, unknown> & PoseValue): string[];
+declare function buildPoseHints(data: Record<string, unknown> & PoseValue, mode?: PickerHintMode): string[];
+/**
+ * Compact counterpart of `buildPoseHints`: the same pre-text → pose →
+ * hand-position → body-lean → head-tilt → activity → post-text order, emitted
+ * as short professional terms instead of full mechanism sentences
+ * ("mid-throw, hands clasped behind the head"). Free-text pre/post fields are
+ * user prose and pass through unchanged in both modes.
+ */
+declare function buildPoseTerms(data: Record<string, unknown> & PoseValue): string[];
 
 /**
  * Canonical catalog of Post-Process Effects choices.
@@ -3454,23 +4335,46 @@ declare function buildPoseHints(data: Record<string, unknown> & PoseValue): stri
  * Shared between picker UI and prompt-hint injection in the frontend DAG
  * executor and the backend orchestrator.
  */
+
 interface PostProcessEffect {
     readonly id: string;
     readonly label: string;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Optional authored compact term (see `term.ts`). Authored only where the
+     * lowercased label is not the phrase a colorist / retoucher would write in a
+     * prompt — "Bloom Glow" and "Color Fringe" are UI compounds, the trade terms
+     * are "highlight bloom" and "color fringing". Everywhere else the label IS
+     * the term.
+     */
+    readonly term?: string;
 }
 declare const POST_PROCESS_EFFECTS: ReadonlyArray<PostProcessEffect>;
 declare function getPostProcessEffect(id: string | undefined | null): PostProcessEffect | undefined;
 declare function getPostProcessEffectLabel(id: string | undefined | null, fallback?: string): string;
 declare function getPostProcessEffectPromptHint(id: string | undefined | null): string;
+/**
+ * Compact counterpart of `getPostProcessEffectPromptHint`: the short
+ * professional term this pass injects in compact hint mode ("dodge and burn"
+ * where the hint is the full mechanism sentence). Empty string for an unknown
+ * id and for any entry that injects no hint at all.
+ */
+declare function getPostProcessEffectTerm(id: string | undefined | null): string;
 /**
  * Multi-pick: 1-2 post-process effect ids → composite grading clause.
  * Common pairs: vignette + film-grain, halation + bloom, dodge-burn +
  * chromatic-aberration. Each entry already describes a complete grading
  * pass, so we emit independently and let the comma-join compose them.
  */
-declare function buildPostProcessHints(value: unknown): string[];
+declare function buildPostProcessHints(value: unknown, mode?: PickerHintMode): string[];
+/**
+ * Compact counterpart of `buildPostProcessHints`: the same 1-2 id multi-pick,
+ * emitted as short professional terms instead of full mechanism sentences
+ * ("soft vignette", "fine film grain"). Same collection order, same
+ * skip-the-no-ops behavior.
+ */
+declare function buildPostProcessTerms(value: unknown): string[];
 declare const POST_PROCESS_EFFECT_IDS: ReadonlyArray<string>;
 
 /**
@@ -3502,11 +4406,24 @@ interface RenderQuality {
     readonly label: string;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term (see `term.ts`). Authored only where the
+     * lowercased label is NOT what a professional writes in a prompt — a bare
+     * word that collides with ordinary English ("redshift", "aces"), an
+     * abbreviation ("pbr"), a non-standard coinage ("16k megapixel"), a bare
+     * modifier with no category noun ("denoised"), or a compound whose
+     * canonical prompt spelling is hyphenated. Every other label here is
+     * already the proper name of the thing ("octane render", "masterpiece")
+     * and carries no `term`.
+     */
+    readonly term?: string;
 }
 declare const RENDER_QUALITIES: ReadonlyArray<RenderQuality>;
 declare function getRenderQuality(id: string | undefined | null): RenderQuality | undefined;
 declare function getRenderQualityLabel(id: string | undefined | null, fallback?: string): string;
 declare function getRenderQualityPromptHint(id: string | undefined | null): string;
+/** Compact-mode sibling of `getRenderQualityPromptHint` — same lookup, short form. */
+declare function getRenderQualityTerm(id: string | undefined | null): string;
 declare const RENDER_QUALITY_IDS: ReadonlyArray<string>;
 
 /**
@@ -3536,11 +4453,22 @@ interface Setting {
     readonly category: SettingCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term (see `term.ts`). Authored only where the
+     * lowercased label is not what a location scout / cinematographer would
+     * write in a prompt — a building name standing in for the specific space
+     * inside it ("Hospital" → "hospital corridor"), or a label that reads
+     * ambiguously on its own ("Conservatory" → the greenhouse, not the music
+     * school). Everywhere else the lowercased label IS the term.
+     */
+    readonly term?: string;
 }
 declare const SETTINGS: ReadonlyArray<Setting>;
 declare function getSetting(id: string | undefined | null): Setting | undefined;
 declare function getSettingLabel(id: string | undefined | null, fallback?: string): string;
 declare function getSettingPromptHint(id: string | undefined | null): string;
+/** Compact counterpart of {@link getSettingPromptHint} — the short setting term. */
+declare function getSettingTerm(id: string | undefined | null): string;
 declare const SETTING_IDS: ReadonlyArray<string>;
 declare const SETTING_CATEGORY_LABELS: Readonly<Record<SettingCategory, string>>;
 
@@ -3570,11 +4498,24 @@ interface Style {
     readonly label: string;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term (see `term.ts`). Authored only where the
+     * lowercased label is not what an art director would write in a prompt —
+     * a UI compound ("Retro / Vintage"), a bare noun that reads as a SUBJECT
+     * rather than a medium ("Blueprint", "Chalkboard", "Graffiti"), a material
+     * where the trade term names the artwork ("Acrylic Paint" → "acrylic
+     * painting"), or a word that is ambiguous on its own ("Pastel" — the
+     * medium, not the color range). Everywhere else the lowercased label IS
+     * the term ("anime", "ukiyo-e", "cyberpunk") and nothing is authored.
+     */
+    readonly term?: string;
 }
 declare const STYLES: ReadonlyArray<Style>;
 declare function getStyle(id: string | undefined | null): Style | undefined;
 declare function getStyleLabel(id: string | undefined | null, fallback?: string): string;
 declare function getStylePromptHint(id: string | undefined | null): string;
+/** Compact counterpart of `getStylePromptHint` — see `term.ts`. */
+declare function getStyleTerm(id: string | undefined | null): string;
 declare const STYLE_IDS: ReadonlyArray<string>;
 
 /**
@@ -3624,6 +4565,7 @@ declare const STYLE_IDS: ReadonlyArray<string>;
  * Applies to BOTH image and video consumers. Includes pre/post free-text
  * fields for specifics the catalog can't express.
  */
+
 type StylingDimension = "makeup" | "eyewear" | "headwear" | "hair-cut" | "hair-treatment" | "hair-state" | "jewelry" | "nails" | "face-paint" | "outfit" | "top" | "bottom" | "outerwear" | "legwear" | "footwear" | "fabric" | "wardrobe-state";
 interface Styling {
     readonly id: string;
@@ -3631,6 +4573,26 @@ interface Styling {
     readonly dimension: StylingDimension;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term for hint-compact mode (see `term.ts`).
+     *
+     * The line this catalog authors on: a label that NAMES a garment, material
+     * or accessory ("Beanie", "Trench Coat", "Silk", "Hoop Earrings", "Doc
+     * Martens") already IS the term a stylist writes, and gets nothing. A label
+     * that is a bare MODIFIER — the whole of `hair-state`, `wardrobe-state`,
+     * `nails`, and the adjective half of `makeup` / `jewelry` — means nothing
+     * stripped of its category noun, so "Wet" becomes "wet hair" and "Gold"
+     * becomes "gold jewelry".
+     *
+     * The same rule resolves this catalog's internal collisions, where two
+     * dimensions share a label and would otherwise derive one indistinguishable
+     * fragment: `hair-wet` / `state-wet` (both "Wet"), `jewelry-layered` /
+     * `state-layered`, `makeup-goth` / `outfit-goth`. Homonym traps outside the
+     * catalog get the same treatment — "Highlights" is a lighting word before it
+     * is a hair word, "Cat-Eye" is eyeliner before it is eyewear, "Hood" is a
+     * car part, "Bun" is bread.
+     */
+    readonly term?: string;
 }
 declare const STYLINGS: ReadonlyArray<Styling>;
 declare const STYLING_DIMENSION_ORDER: ReadonlyArray<StylingDimension>;
@@ -3690,8 +4652,23 @@ interface StylingValue {
 declare function getStyling(id: string | undefined | null): Styling | undefined;
 declare function getStylingLabel(id: string | undefined | null, fallback?: string): string;
 declare function getStylingPromptHint(id: string | undefined | null): string;
+/**
+ * The COMPACT counterpart of `getStylingPromptHint`: the same lookup, same
+ * arity, same empty-string-on-miss, returning the entry's short professional
+ * term ("wet hair", "gold jewelry", "low ponytail") instead of its full
+ * mechanism clause.
+ */
+declare function getStylingTerm(id: string | undefined | null): string;
 declare const STYLING_IDS: ReadonlyArray<string>;
-declare function buildStylingHints(data: Record<string, unknown> & StylingValue): string[];
+declare function buildStylingHints(data: Record<string, unknown> & StylingValue, mode?: PickerHintMode): string[];
+/**
+ * The COMPACT counterpart of `buildStylingHints`: the same dimension walk in
+ * the same canonical order, under the same `makeup-bold-lips` dedupe, emitting
+ * each selection's short professional term ("wet hair", "leather jacket",
+ * "gold jewelry") instead of its full mechanism clause. Free-text pre/post
+ * fields are user prose and pass through unchanged in both modes.
+ */
+declare function buildStylingTerms(data: Record<string, unknown> & StylingValue): string[];
 
 /**
  * Canonical catalog of temporal modifiers.
@@ -3709,6 +4686,7 @@ declare function buildStylingHints(data: Record<string, unknown> & StylingValue)
  * Shared between the picker UI and the prompt-hint injection on both the
  * frontend DAG executor and the backend orchestrator.
  */
+
 type TemporalCategory = "speed" | "freeze" | "direction" | "shutter";
 interface Temporal {
     readonly id: string;
@@ -3716,6 +4694,16 @@ interface Temporal {
     readonly category: TemporalCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Compact professional term injected in compact hint mode (see `term.ts`).
+     *
+     * Authored where the picker label is a UI compound ("Reverse / Rewind",
+     * "Loop / Boomerang") or a bare word that reads as something else entirely
+     * inside a prompt — "Forward" as a camera move rather than playback
+     * direction, "Moving Subject" as a plain description of the action rather
+     * than the frozen-world effect it selects here.
+     */
+    readonly term?: string;
 }
 declare const TEMPORALS: ReadonlyArray<Temporal>;
 declare const TEMPORAL_CATEGORY_ORDER: ReadonlyArray<TemporalCategory>;
@@ -3723,6 +4711,13 @@ declare const TEMPORAL_CATEGORY_LABELS: Record<TemporalCategory, string>;
 declare function getTemporal(id: string | undefined | null): Temporal | undefined;
 declare function getTemporalLabel(id: string | undefined | null, fallback?: string): string;
 declare function getTemporalPromptHint(id: string | undefined | null): string;
+/**
+ * The COMPACT counterpart of `getTemporalPromptHint`: the short professional
+ * term ("super slow motion", "reverse playback", "boomerang loop") a consumer
+ * injects instead of the full mechanism description. Same lookup, same
+ * empty-string-on-miss behavior.
+ */
+declare function getTemporalTerm(id: string | undefined | null): string;
 declare const TEMPORAL_IDS: ReadonlyArray<string>;
 /**
  * Maps each TemporalCategory to the consumer data field name that holds the
@@ -3761,6 +4756,18 @@ declare function buildTemporalHints(data: Record<string, unknown> & {
     temporalFreeze?: unknown;
     temporalDirection?: unknown;
     temporalShutter?: unknown;
+}, mode?: PickerHintMode): string[];
+/**
+ * The COMPACT counterpart of `buildTemporalHints`: the same per-category walk
+ * in the same canonical order, emitting each selection's short professional
+ * term ("super slow motion", "bullet time", "reverse playback") instead of its
+ * full mechanism description.
+ */
+declare function buildTemporalTerms(data: Record<string, unknown> & {
+    temporalSpeed?: unknown;
+    temporalFreeze?: unknown;
+    temporalDirection?: unknown;
+    temporalShutter?: unknown;
 }): string[];
 
 /**
@@ -3776,6 +4783,7 @@ declare function buildTemporalHints(data: Record<string, unknown> & {
  * parameter nodes whose hints are folded into the composed clause as
  * "starting from <X>, ending at <Y>".
  */
+
 type TransitionCategory = "standard" | "time" | "element" | "morph" | "portal" | "physics" | "light" | "glitch";
 interface Transition {
     readonly id: string;
@@ -3783,6 +4791,16 @@ interface Transition {
     readonly category: TransitionCategory;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * Optional authored compact term (see `term.ts`). Authored where the
+     * lowercased label is not what an editor would write in a prompt — a UI
+     * compound ("None / Hard Cut" → "hard cut"), an annotation the derivation
+     * drops ("Fast-Forward (Day → Night)" → "day-to-night time-lapse"), a bare
+     * word that collides with another meaning ("Melt Down", "Channel Flip",
+     * "Roll"), or a coinage that is not the trade term ("Seamless Match" →
+     * "invisible cut"). Everywhere else the label IS the term.
+     */
+    readonly term?: string;
 }
 type TransitionPosition = "auto" | "start" | "middle" | "end" | "full";
 type TransitionDuration = "auto" | "instant" | "short" | "medium" | "long";
@@ -3798,6 +4816,16 @@ declare const TRANSITION_CATEGORY_LABELS: Readonly<Record<TransitionCategory, st
 declare function getTransition(id: string | undefined | null): Transition | undefined;
 declare function getTransitionLabel(id: string | undefined | null, fallback?: string): string;
 declare function getTransitionPromptHint(id: string | undefined | null): string;
+/**
+ * Compact professional TERM for an id — the short phrase an editor would write
+ * in a prompt ("hard cut", "invisible cut", "day-to-night time-lapse"), as
+ * opposed to the paragraph-length `promptHint`.
+ *
+ * Same lookup and same empty-string-on-miss behavior as
+ * `getTransitionPromptHint`, so the two can never disagree about which entry
+ * they describe. The no-op "Auto" entry resolves to `""` in both.
+ */
+declare function getTransitionTerm(id: string | undefined | null): string;
 declare const TRANSITION_IDS: ReadonlyArray<string>;
 /**
  * Compose a structural prompt-hint sentence from a transition id (or array
@@ -3810,8 +4838,14 @@ declare const TRANSITION_IDS: ReadonlyArray<string>;
  * - n base hints joined with ", and "
  * - Timing/start/end clauses apply ONCE at the outer layer, not per-id
  * - null input is treated like undefined (falsy short-circuit → returns "")
+ *
+ * @param mode `"compact"` builds the base from each transition's short
+ *   professional `term` ("hard cut") instead of its full mechanism paragraph.
+ *   Everything else — the ", and " multi-pick join, the position/duration/
+ *   intensity clauses, and the "starting from"/"ending at" clauses — is
+ *   emitted identically in both modes.
  */
-declare function composeTransitionHintFromConnections(transitionId: string | ReadonlyArray<string> | undefined, startHints: ReadonlyArray<string>, endHints: ReadonlyArray<string>, timing?: TransitionTiming): string;
+declare function composeTransitionHintFromConnections(transitionId: string | ReadonlyArray<string> | undefined, startHints: ReadonlyArray<string>, endHints: ReadonlyArray<string>, timing?: TransitionTiming, mode?: PickerHintMode): string;
 
 /**
  * Voice-character catalog: age + gender + language + accent + timbre. Feeds
@@ -3821,11 +4855,14 @@ declare function composeTransitionHintFromConnections(transitionId: string | Rea
  * voice work. Distinct from `accent` — accent is HOW it sounds, language
  * is WHAT'S being spoken.
  */
+
 interface VoiceCharacterEntry {
     readonly id: string;
     readonly label: string;
     readonly description: string;
     readonly promptHint: string;
+    /** Optional authored compact term (see `term.ts` for the convention). */
+    readonly term?: string;
 }
 declare const VOICE_AGES: ReadonlyArray<VoiceCharacterEntry>;
 declare const VOICE_GENDERS: ReadonlyArray<VoiceCharacterEntry>;
@@ -3837,6 +4874,40 @@ declare function getVoiceGender(id: string | undefined): VoiceCharacterEntry | u
 declare function getVoiceLanguage(id: string | undefined): VoiceCharacterEntry | undefined;
 declare function getVoiceAccent(id: string | undefined): VoiceCharacterEntry | undefined;
 declare function getVoiceTimbre(id: string | undefined): VoiceCharacterEntry | undefined;
+/**
+ * The COMPACT counterparts of the five sub-field lookups: the short
+ * professional term a consumer injects instead of the entry's hint fragment.
+ * Same lookup, same empty-string-on-miss behavior.
+ *
+ * Accent and timbre terms CARRY their dimension noun — "boston accent",
+ * "french accent", "warm timbre" — where the `promptHint` fragments are bare
+ * ("Boston", "French-accented", "warm") and only read as an accent or a
+ * timbre once `buildVoiceCharacterHints` appends the noun. The term has to
+ * stand on its own because a thin client injects one by itself (a picker
+ * chip), with no composer to append anything: a bare "french" there is
+ * indistinguishable from the LANGUAGE French sitting in the neighbouring
+ * dimension.
+ *
+ * Age, gender and language terms deliberately stay BARE — "male", "mature",
+ * "english". Do NOT "fix" them by authoring the noun into the data:
+ * `composeVoiceCharacter` appends " voice" to the age+gender group itself, so
+ * a "male voice" term would emit "...male voice voice".
+ */
+declare function getVoiceAgeTerm(id: string | undefined | null): string;
+declare function getVoiceGenderTerm(id: string | undefined | null): string;
+declare function getVoiceLanguageTerm(id: string | undefined | null): string;
+declare function getVoiceAccentTerm(id: string | undefined | null): string;
+declare function getVoiceTimbreTerm(id: string | undefined | null): string;
+/** The consumer fields a voice-character clause is composed from. */
+type VoiceCharacterFieldSource = {
+    readonly preText?: string;
+    readonly postText?: string;
+    readonly age?: string;
+    readonly gender?: string;
+    readonly language?: string | ReadonlyArray<string>;
+    readonly accent?: string;
+    readonly timbre?: string;
+};
 /**
  * Compose a natural-language voice character clause.
  * Examples (depending on which sub-fields are set):
@@ -3850,15 +4921,20 @@ declare function getVoiceTimbre(id: string | undefined): VoiceCharacterEntry | u
  * `language` is multi-pick — multiple languages emit "English / Spanish"
  * for codeswitching / multilingual voices.
  */
-declare function buildVoiceCharacterHints(data: {
-    readonly preText?: string;
-    readonly postText?: string;
-    readonly age?: string;
-    readonly gender?: string;
-    readonly language?: string | ReadonlyArray<string>;
-    readonly accent?: string;
-    readonly timbre?: string;
-}): string;
+declare function buildVoiceCharacterHints(data: VoiceCharacterFieldSource, mode?: PickerHintMode): string;
+/**
+ * The COMPACT counterpart of `buildVoiceCharacterHints`: the same clause
+ * skeleton, built from each selection's short professional term instead of its
+ * hint fragment. The dimension noun is attached idempotently — an authored
+ * term already carries it ("warm timbre", "received pronunciation accent") and
+ * passes through untouched.
+ * Examples:
+ *   { age, gender, timbre, accent } → "middle-aged male voice with warm timbre and received pronunciation accent"
+ *   { timbre }                      → "warm timbre"
+ *   { language: ["english","spanish"] } → "english / spanish voice"
+ *   { }                             → ""
+ */
+declare function buildVoiceCharacterTerms(data: VoiceCharacterFieldSource): string;
 declare const VOICE_CHARACTER_DEFAULT_DATA: {
     preText?: string;
     postText?: string;
@@ -3873,11 +4949,20 @@ declare const VOICE_CHARACTER_DEFAULT_DATA: {
  * Voice-delivery catalog: pace + emotion + archetype. Feeds
  * Voice Design's voiceDescription via the Sound aggregator.
  */
+
 interface VoiceDeliveryEntry {
     readonly id: string;
     readonly label: string;
     readonly description: string;
     readonly promptHint: string;
+    /**
+     * The COMPACT professional term this entry injects (see `./term.js`).
+     * Authored only where the lowercased label is not what a voice director
+     * would actually write — "drawled" not "drawl", "robotic" not "robot",
+     * "nature documentary narrator" not "nature narrator". Everywhere else the
+     * derived label already IS the term and nothing is stored.
+     */
+    readonly term?: string;
 }
 declare const VOICE_PACES: ReadonlyArray<VoiceDeliveryEntry>;
 declare const VOICE_EMOTIONS: ReadonlyArray<VoiceDeliveryEntry>;
@@ -3885,6 +4970,16 @@ declare const VOICE_ARCHETYPES: ReadonlyArray<VoiceDeliveryEntry>;
 declare function getVoicePace(id: string | undefined): VoiceDeliveryEntry | undefined;
 declare function getVoiceEmotion(id: string | undefined): VoiceDeliveryEntry | undefined;
 declare function getVoiceArchetype(id: string | undefined): VoiceDeliveryEntry | undefined;
+/**
+ * The COMPACT counterparts of the three lookups above: the short professional
+ * term a consumer injects instead of the full prompt fragment ("drawled",
+ * "reassuring", "nature documentary narrator"). Same lookup, same
+ * empty-string-on-miss behavior as the hint side, so the two can never
+ * disagree about which entry they describe.
+ */
+declare function getVoicePaceTerm(id: string | undefined | null): string;
+declare function getVoiceEmotionTerm(id: string | undefined | null): string;
+declare function getVoiceArchetypeTerm(id: string | undefined | null): string;
 /**
  * Compose a delivery clause.
  * Examples:
@@ -3899,6 +4994,20 @@ declare function buildVoiceDeliveryHints(data: {
     readonly pace?: string;
     readonly emotion?: string;
     readonly archetype?: string;
+}, mode?: PickerHintMode): string;
+/**
+ * Compact-mode mirror of `buildVoiceDeliveryHints`: the same preText /
+ * [pace] [archetype]-style delivery / [emotion] tone / postText structure,
+ * built from each selection's short `term` instead of its `promptHint`
+ * ("drawled noir-detective-style delivery, menacing tone"). preText and
+ * postText — user free text, not catalog copy — pass through untouched.
+ */
+declare function buildVoiceDeliveryTerms(data: {
+    readonly preText?: string;
+    readonly postText?: string;
+    readonly pace?: string;
+    readonly emotion?: string;
+    readonly archetype?: string;
 }): string;
 declare const VOICE_DELIVERY_DEFAULT_DATA: {
     preText?: string;
@@ -3995,6 +5104,34 @@ declare function getPromptDoctrine(providerId: string): ProviderPromptDoctrine |
 /** Compact tips for a provider id ([] when none) — used by list_models. */
 declare function getPromptTips(providerId: string): readonly string[];
 
+/**
+ * Reference-image prompting doctrine for IMAGE generation — the single source
+ * of truth for the `{image:N:label}` token idiom on `generate-image`. Consumed
+ * by backend/scripts/gen-skills (the `image-reference-prompting` block in the
+ * generate-image node skill), the same way `PROVIDER_PROMPT_DOCTRINES` feeds
+ * the video node skills.
+ *
+ * Unlike the per-provider video doctrines, this is a PLATFORM mechanism: the
+ * token grammar and expansion are Nodaro's own (`prompt-builder.ts` —
+ * `IMAGE_TOKEN_PATTERN`, `expandImageRefTokens`), so there is one doctrine,
+ * not one per model family.
+ *
+ * Source of truth for the semantics documented here (verified 2026-08-25):
+ * - `IMAGE_TOKEN_PATTERN` = `/\{image:(\d+)(?::([^}\n]+))?\}/gi`
+ * - `expandImageRefTokens`: `{image:N:label}` → `Image N (label)`,
+ *   `{image:N}` → `Image N`; out-of-range tokens are left untouched so the
+ *   author can see and fix them.
+ * - N is the reference's 1-based position in the assembled reference list
+ *   (connection order on the `references` handle).
+ */
+interface ImageReferenceDoctrine {
+    /** Human heading for skill docs. */
+    readonly heading: string;
+    /** Full markdown doctrine for generated skill docs. */
+    readonly doctrine: string;
+}
+declare const IMAGE_REFERENCE_PROMPT_DOCTRINE: ImageReferenceDoctrine;
+
 /**
  * Prompt Wizard — shared types, category definitions, and provider capabilities.
  *
@@ -4309,4 +5446,4 @@ declare function getPickerWiring(nodeType: string | undefined | null): PickerWir
  */
 declare function buildSurroundFillPrompt(direction: SurroundDirection, userPrompt?: string): string;
 
-export { ACTION_FX, ACTION_FX_CATEGORY_LABELS, ACTION_FX_CATEGORY_ORDER, ACTION_FX_IDS, AESTHETICS, AESTHETIC_CATEGORY_LABELS, AESTHETIC_CATEGORY_ORDER, AESTHETIC_IDS, ALL_PICKER_WIRING, ANALYZABLE_PICKER_TYPES, ANGLE_LABELS, ASPECT_RATIO_LABELS, ATMOSPHERES, ATMOSPHERE_IDS, AUDIO_WIZARD_CATEGORIES, type ActionFx, type ActionFxCategory, type Aesthetic, type AestheticCategory, type AssembleImageInput, type AssembleSunoInput, type AssembleSunoResult, type Atmosphere, BACKDROPS, BACKDROP_CATEGORY_LABELS, BACKDROP_CATEGORY_ORDER, BACKDROP_IDS, BRAND_PRESETS, BRAND_PRESET_IDS, BRAND_PRESET_META, type Backdrop, type BackdropCategory, type BrandCasing, type BrandFonts, type BrandLogo, type BrandPalette, type BrandPresetId, type BrandPresetMeta, type BrandTokens, type BrandTypeSpec, type BuildImagePromptConfig, type BuildImagePromptResult, type BuildImagePromptSegmentsResult, CAMERA_FORMATS, CAMERA_FORMAT_IDS, CAMERA_MOTIONS, CAMERA_MOTION_CATEGORY_LABELS, CAMERA_MOTION_CATEGORY_ORDER, CAMERA_MOTION_IDS, CHARACTER_FX, CHARACTER_FX_CATEGORY_LABELS, CHARACTER_FX_CATEGORY_ORDER, CHARACTER_FX_IDS, CINEMATIC_LOOK_TAIL, COLOR_LOOKS, COLOR_LOOK_CATEGORY_LABELS, COLOR_LOOK_CATEGORY_ORDER, COLOR_LOOK_IDS, COMPOSITION_EFFECTS, COMPOSITION_EFFECT_IDS, type CameraFormat, type CameraMotion, type CameraMotionCategory, type CategorizedInstrument, type CharacterFx, type CharacterFxCategory, type CharacterFxDuration, type CharacterFxIntensity, type CharacterFxPosition, type CharacterFxTiming, type CharacterMeta, type CharacterMotionPromptInput, type CharacterPromptInput, type ColorLook, type ColorLookCategory, type CompositionEffect, type ComputeNodePromptArgs, type CreaturePromptInput, DEFAULT_IDENTITY_LOCK, DEFAULT_TEMPLATES, type DirectionFields, ERAS, ERA_CATEGORY_LABELS, ERA_CATEGORY_ORDER, ERA_IDS, EXPOSURE_CATEGORY_LABELS, EXPOSURE_CATEGORY_ORDER, EXPOSURE_FIELD_BY_CATEGORY, EXPOSURE_IDS, EXPOSURE_SETTINGS, type Era, type EraCategory, type ExposureCategory, type ExposureSettings, type ExposureValue, FACTORY_PRESETS, FACTORY_SNIPPETS, FILM_STILL_PREFIX, FRAMINGS, FRAMING_CATEGORY_LABELS, FRAMING_CATEGORY_ORDER, FRAMING_FIELD_BY_CATEGORY, FRAMING_IDS, type FacePromptInput, type FactoryPreset, type FactoryPresetGroup, type FactorySnippet, type Framing, type FramingCategory, type FramingValue, GAPS_SCHEMA, type GeminiOmniI2vInputsArgs, type GeminiOmniI2vInputsResult, HELD_PROPS, HELD_PROP_CATEGORY_LABELS, HELD_PROP_CATEGORY_ORDER, HELD_PROP_IDS, type HeldProp, type HeldPropCategory, IMAGE_WIZARD_CATEGORIES, INSTRUMENTATION_DEFAULT_DATA, INSTRUMENTS, INSTRUMENT_CATEGORY_LABELS, INSTRUMENT_CATEGORY_ORDER, type IdentityLockMode, type InstrumentCategory, type InstrumentationEntry, LENSES, LENS_IDS, LIGHTINGS, LIGHTING_CATEGORY_LABELS, LIGHTING_CATEGORY_ORDER, LIGHTING_FIELD_BY_CATEGORY, LIGHTING_IDS, LLM_CHAT_WIZARD_CATEGORIES, LOOP_SUBJECTS, LOOP_SUBJECT_CATEGORY_LABELS, LOOP_SUBJECT_CATEGORY_ORDER, type Lens, type Lighting, type LightingCategory, type LightingValue, type LlmChatFieldArgs, type LocationMotionPromptInput, type LocationPromptInput, type LocationRefinePromptInput, type LoopSubject, type LoopSubjectCategory, MATERIALS, MATERIAL_CATEGORY_LABELS, MATERIAL_CATEGORY_ORDER, MATERIAL_IDS, MAX_SELECTED_BY_DIMENSION, MAX_SELECTED_BY_FRAMING_CATEGORY, MAX_SELECTED_BY_STYLING_DIMENSION, MOODS, MOOD_CATEGORY_LABELS, MOOD_CATEGORY_ORDER, MOOD_IDS, MOVEMENT_LABELS, MULTI_PICKER_WIRING, MUSIC_EMOTIONS, MUSIC_ENERGIES, MUSIC_ERAS, MUSIC_GENRES, MUSIC_GENRE_CATEGORY_LABELS, MUSIC_GENRE_CATEGORY_ORDER, MUSIC_GENRE_DEFAULT_DATA, MUSIC_MOOD_DEFAULT_DATA, MUSIC_VIBES, MUSIC_WIZARD_CATEGORIES, type Material, type MaterialCategory, type ModelChange, type Mood, type MoodCategory, type MoodValue, type MultiDimPickerWiring, type MultiPickerAnalyzerSpec, type MusicEra, type MusicGenre, type MusicGenreCategory, type MusicMoodEntry, type MusicSubgenre, NODE_PROMPT_CANDIDATE_FIELDS, OBJECT_ANGLE_PRESETS, OBJECT_ANGLE_PROMPTS, OBJECT_ASSET_PRESETS, OBJECT_ASSET_PROMPTS, OBJECT_MATERIAL_PRESETS, OBJECT_MATERIAL_PROMPTS, OBJECT_VARIATION_PRESETS, OBJECT_VARIATION_PROMPTS, type ObjectMotionPromptInput, type ObjectPresetAssetType, type ObjectPromptInput, PEOPLE, PERSON_DIMENSION_LABELS, PERSON_DIMENSION_ORDER, PERSON_DIMENSION_SECTIONS, PERSON_FIELD_BY_DIMENSION, PERSON_IDS, PHOTOGRAPHERS, PHOTOGRAPHER_CATEGORY_LABELS, PHOTOGRAPHER_CATEGORY_ORDER, PHOTOGRAPHER_IDS, PHOTO_GENRES, PHOTO_GENRE_CATEGORY_LABELS, PHOTO_GENRE_CATEGORY_ORDER, PHOTO_GENRE_IDS, PICKER_ANALYZER_FAMILIES, PICKER_ANALYZER_REGISTRY, PICKER_CATALOGS, PICKER_TYPES, POSES, POSE_CATEGORY_LABELS, POSE_CATEGORY_ORDER, POSE_IDS, POST_PROCESS_EFFECTS, POST_PROCESS_EFFECT_IDS, PRODUCTION_STYLES, PROVIDER_CAPABILITIES, PROVIDER_PROMPT_DOCTRINES, type Person, type PersonDimension, type PersonDimensionSection, type PersonValue, type PhotoGenre, type PhotoGenreCategory, type Photographer, type PhotographerCategory, type PickerAnalyzer, type PickerAnalyzerDescriptor, type PickerAnalyzerSpec, type PickerApplyMode, type PickerCatalog, type PickerCatalogDetail, type PickerCatalogSummary, type PickerDimension, type PickerDimensionSpec, type PickerGaps, type PickerOption, type PickerType, type PickerWiring, type PickerWiringEntry, type Pose, type PoseCategory, type PoseValue, type PostProcessEffect, type ProjectPickerCatalogOptions, type ProjectedPickerCatalog, type ProjectedPickerDimension, type ProjectedPickerOption, type PromptSegment, type PromptSegmentOrigin, type ProviderPromptDoctrine, REFERENCE_IMAGE_ROLES, REFERENCE_RULES, REFERENCE_RULES_MULTI_PERSON, REF_BINDING, RENDER_QUALITIES, RENDER_QUALITY_IDS, type RecommendedModel, type ReferenceCounts, type RenderQuality, type ResolveCharacterMentionsResult, type ResolveLocationMentionsResult, type ResolvePromptArgs, type ResolveVideoReferenceCoreArgs, SCENE_FRAME_RULE, SCENE_PROMPT_MAX_LENGTH, SETTINGS, SETTING_CATEGORY_LABELS, SETTING_IDS, SHOT_LABELS, SINGING_STYLES, SINGLE_PICKER_WIRING, SNIPPET_MEDIA_VALUES, STYLES, STYLE_IDS, STYLE_PRESETS, STYLINGS, STYLING_DIMENSION_LABELS, STYLING_DIMENSION_ORDER, STYLING_FIELD_BY_DIMENSION, STYLING_IDS, type Seedance2InputsArgs, type Seedance2InputsResult, type Seedance2Mode, type Setting, type SettingCategory, type SingleDimPickerWiring, type SnippetMedia, type SnippetTarget, type SoundComposition, type SoundCompositionFields, type SoundConsumerType, type StructuredPromptFields, type Style, type StylePreset, type Styling, type StylingDimension, type StylingValue, TEMPORALS, TEMPORAL_CATEGORY_LABELS, TEMPORAL_CATEGORY_ORDER, TEMPORAL_FIELD_BY_CATEGORY, TEMPORAL_IDS, TEXT_WIZARD_CATEGORIES, TRANSITIONS, TRANSITION_CATEGORY_LABELS, TRANSITION_CATEGORY_ORDER, TRANSITION_IDS, type Temporal, type TemporalCategory, type TemporalValue, type Transition, type TransitionCategory, type TransitionDuration, type TransitionIntensity, type TransitionPosition, type TransitionTiming, VIDEO_WIZARD_CATEGORIES, VOCAL_PRESENCE, VOCAL_PRESENCE_INSTRUMENTAL_ID, VOICE_ACCENTS, VOICE_AGES, VOICE_ARCHETYPES, VOICE_CHARACTER_DEFAULT_DATA, VOICE_DELIVERY_DEFAULT_DATA, VOICE_EMOTIONS, VOICE_GENDERS, VOICE_LANGUAGES, VOICE_PACES, VOICE_TIMBRES, type VeoI2vInputsArgs, type VeoI2vInputsResult, type VideoExtraRef, type VoiceCharacterEntry, type VoiceDeliveryEntry, WARDROBE, WARDROBE_CATEGORY_LABELS, WARDROBE_DIMENSION_ORDER, WARDROBE_FIELD_BY_DIMENSION, type WardrobeDimension, type WardrobeEntry, type WardrobeValue, type WizardCategory, type WizardNodeContext, type WizardOption, type WizardQuestion, type WizardSelection, appendField, appendMusicMeta, applyPickerJson, applyReferenceOrderToVideo, applyTemplate, assembleImageInput, assembleSunoInput, buildActionFxHints, buildAestheticHints, buildAgeHint, buildAtmosphereHints, buildCharacterPrompt, buildCreaturePrompt, buildExposureHints, buildFaceTemplateInputs, buildFramingHints, buildHeldPropHints, buildIdentityDirectives, buildIdentityLockLine, buildImagePrompt, buildImagePromptSegments, buildInstrumentationHints, buildLightingHints, buildLocationMotionPrompt, buildLocationPrompt, buildLocationRefinePrompt, buildMaterialHints, buildMoodHints, buildMotionPrompt, buildMultiPickerAnalyzerSpec, buildMusicGenreHints, buildMusicMoodHints, buildObjectMotionPrompt, buildObjectPrompt, buildPersonHints, buildPhotographerHints, buildPickerAnalyzerSpec, buildPickerLegend, buildPickerZodSchema, buildPoseHints, buildPostProcessHints, buildReferenceBlocks, buildScenePrompt, buildStylingHints, buildSurroundFillPrompt, buildTemporalHints, buildVoiceCharacterHints, buildVoiceDeliveryHints, buildWardrobeHints, characterLockToRefLock, collectIdentityLockClause, composeCameraMotionHintFromConnections, composeCharacterFxHintFromConnections, composeNegative, composeSoundHintFromConnections, composeTransitionHintFromConnections, computeLlmChatFields, computeNodePrompt, expandImagePositionRefs, expandImageRefTokens, filmStillPrefix, getActionFx, getActionFxLabel, getActionFxPromptHint, getAesthetic, getAestheticLabel, getAestheticPromptHint, getAtmosphere, getAtmosphereLabel, getAtmospherePromptHint, getBackdrop, getBackdropLabel, getBackdropPromptHint, getCameraFormat, getCameraFormatLabel, getCameraFormatPromptHint, getCameraMotion, getCameraMotionLabel, getCameraMotionPromptHint, getCategoriesForNodeType, getCharacterFx, getCharacterFxLabel, getCharacterFxPromptHint, getColorLook, getColorLookLabel, getColorLookPromptHint, getCompositionEffect, getCompositionEffectLabel, getCompositionEffectPromptHint, getEffectiveSunoCustomMode, getEra, getEraLabel, getEraPromptHint, getExposure, getExposureLabel, getExposurePromptHint, getFactoryPresets, getFactorySnippets, getFraming, getFramingCategoryLimit, getFramingLabel, getFramingPromptHint, getHeldProp, getHeldPropLabel, getHeldPropPromptHint, getIdentityLockClause, getInstrument, getLens, getLensLabel, getLensPromptHint, getLighting, getLightingLabel, getLightingPromptHint, getLoopSubject, getLoopSubjectLabel, getLoopSubjectPromptHint, getMaterial, getMaterialLabel, getMaterialPromptHint, getMood, getMoodLabel, getMoodPromptHint, getMusicEmotion, getMusicEnergy, getMusicEra, getMusicGenre, getMusicGenreLabel, getMusicSubgenre, getMusicVibe, getParameterPromptHint, getPerson, getPersonDimensionLimit, getPersonLabel, getPersonPromptHint, getPhotoGenre, getPhotoGenreLabel, getPhotoGenrePromptHint, getPhotographer, getPhotographerLabel, getPhotographerPromptHint, getPickerAnalyzer, getPickerCatalog, getPickerWiring, getPose, getPoseLabel, getPosePromptHint, getPostProcessEffect, getPostProcessEffectLabel, getPostProcessEffectPromptHint, getProductionStyle, getPromptDoctrine, getPromptTips, getRenderQuality, getRenderQualityLabel, getRenderQualityPromptHint, getSetting, getSettingLabel, getSettingPromptHint, getSingingStyle, getStyle, getStyleLabel, getStylePreset, getStylePromptHint, getStyling, getStylingDimensionLimit, getStylingLabel, getStylingPromptHint, getTemporal, getTemporalLabel, getTemporalPromptHint, getTransition, getTransitionLabel, getTransitionPromptHint, getVocalPresence, getVoiceAccent, getVoiceAge, getVoiceArchetype, getVoiceEmotion, getVoiceGender, getVoiceLanguage, getVoicePace, getVoiceTimbre, getWardrobeEntriesByDimension, getWardrobeEntry, getWardrobePromptHint, groupFactoryPresets, hasUpstreamCharacter, identityRefsSentence, isAnalyzablePicker, isInstrumentalVocal, isVantageFraming, isWizardSupported, listPickerCatalogs, migratePersonValue, pickerFanoutTargets, projectPickerCatalog, promptBindsFirstFrame, referenceRulesBlock, renderStructuredFields, resolveBrandInput, resolveCharacterMentions, resolveGeminiOmniI2vInputs, resolveLocationMentions, resolvePrompt, resolveReferenceTokens, resolveSeedance2Inputs, resolveTemplate, resolveVeoI2vInputs, resolveVideoReferenceCore, summarizePickerCatalogs, toIdentityLockMode, truncateForField, truncateText, withForcedIdentityLock };
+export { ACTION_FX, ACTION_FX_CATEGORY_LABELS, ACTION_FX_CATEGORY_ORDER, ACTION_FX_IDS, AESTHETICS, AESTHETIC_CATEGORY_LABELS, AESTHETIC_CATEGORY_ORDER, AESTHETIC_IDS, ALL_PICKER_WIRING, ANALYZABLE_PICKER_TYPES, ANGLE_LABELS, ASPECT_RATIO_LABELS, ATMOSPHERES, ATMOSPHERE_IDS, AUDIO_WIZARD_CATEGORIES, type ActionFx, type ActionFxCategory, type Aesthetic, type AestheticCategory, type AssembleImageInput, type AssembleSunoInput, type AssembleSunoResult, type Atmosphere, BACKDROPS, BACKDROP_CATEGORY_LABELS, BACKDROP_CATEGORY_ORDER, BACKDROP_IDS, BRAND_PRESETS, BRAND_PRESET_IDS, BRAND_PRESET_META, type Backdrop, type BackdropCategory, type BrandCasing, type BrandFonts, type BrandLogo, type BrandPalette, type BrandPresetId, type BrandPresetMeta, type BrandTokens, type BrandTypeSpec, type BuildImagePromptConfig, type BuildImagePromptResult, type BuildImagePromptSegmentsResult, CAMERA_FORMATS, CAMERA_FORMAT_IDS, CAMERA_MOTIONS, CAMERA_MOTION_CATEGORY_LABELS, CAMERA_MOTION_CATEGORY_ORDER, CAMERA_MOTION_IDS, CHARACTER_FX, CHARACTER_FX_CATEGORY_LABELS, CHARACTER_FX_CATEGORY_ORDER, CHARACTER_FX_IDS, CINEMATIC_LOOK_TAIL, COLOR_LOOKS, COLOR_LOOK_CATEGORY_LABELS, COLOR_LOOK_CATEGORY_ORDER, COLOR_LOOK_IDS, COMPOSITION_EFFECTS, COMPOSITION_EFFECT_IDS, type CameraFormat, type CameraMotion, type CameraMotionCategory, type CatalogPack, type CatalogPackMode, type CategorizedInstrument, type CharacterFx, type CharacterFxCategory, type CharacterFxDuration, type CharacterFxIntensity, type CharacterFxPosition, type CharacterFxTiming, type CharacterMeta, type CharacterMotionPromptInput, type CharacterPromptInput, type ColorLook, type ColorLookCategory, type CompositionEffect, type ComputeNodePromptArgs, type CreaturePromptInput, DEFAULT_IDENTITY_LOCK, DEFAULT_TEMPLATES, type DirectionFields, ERAS, ERA_CATEGORY_LABELS, ERA_CATEGORY_ORDER, ERA_IDS, EXPOSURE_CATEGORY_LABELS, EXPOSURE_CATEGORY_ORDER, EXPOSURE_FIELD_BY_CATEGORY, EXPOSURE_IDS, EXPOSURE_SETTINGS, type Era, type EraCategory, type ExposureCategory, type ExposureSettings, type ExposureValue, FACTORY_PRESETS, FACTORY_SNIPPETS, FILM_STILL_PREFIX, FRAMINGS, FRAMING_CATEGORY_LABELS, FRAMING_CATEGORY_ORDER, FRAMING_FIELD_BY_CATEGORY, FRAMING_IDS, type FacePromptInput, type FactoryPreset, type FactoryPresetGroup, type FactorySnippet, type Framing, type FramingCategory, type FramingValue, GAPS_SCHEMA, type GeminiOmniI2vInputsArgs, type GeminiOmniI2vInputsResult, HELD_PROPS, HELD_PROP_CATEGORY_LABELS, HELD_PROP_CATEGORY_ORDER, HELD_PROP_IDS, type HeldProp, type HeldPropCategory, IMAGE_REFERENCE_PROMPT_DOCTRINE, IMAGE_WIZARD_CATEGORIES, INSTRUMENTATION_DEFAULT_DATA, INSTRUMENTS, INSTRUMENT_CATEGORY_LABELS, INSTRUMENT_CATEGORY_ORDER, type IdentityLockMode, type ImageReferenceDoctrine, type InstrumentCategory, type InstrumentationEntry, LENSES, LENS_IDS, LIGHTINGS, LIGHTING_CATEGORY_LABELS, LIGHTING_CATEGORY_ORDER, LIGHTING_FIELD_BY_CATEGORY, LIGHTING_IDS, LLM_CHAT_WIZARD_CATEGORIES, LOOP_SUBJECTS, LOOP_SUBJECT_CATEGORY_LABELS, LOOP_SUBJECT_CATEGORY_ORDER, type Lens, type Lighting, type LightingCategory, type LightingValue, type LlmChatFieldArgs, type LocationMotionPromptInput, type LocationPromptInput, type LocationRefinePromptInput, type LoopSubject, type LoopSubjectCategory, MATERIALS, MATERIAL_CATEGORY_LABELS, MATERIAL_CATEGORY_ORDER, MATERIAL_IDS, MAX_SELECTED_BY_DIMENSION, MAX_SELECTED_BY_FRAMING_CATEGORY, MAX_SELECTED_BY_STYLING_DIMENSION, MOODS, MOOD_CATEGORY_LABELS, MOOD_CATEGORY_ORDER, MOOD_IDS, MOVEMENT_LABELS, MULTI_PICKER_WIRING, MUSIC_EMOTIONS, MUSIC_ENERGIES, MUSIC_ERAS, MUSIC_GENRES, MUSIC_GENRE_CATEGORY_LABELS, MUSIC_GENRE_CATEGORY_ORDER, MUSIC_GENRE_DEFAULT_DATA, MUSIC_MOOD_DEFAULT_DATA, MUSIC_VIBES, MUSIC_WIZARD_CATEGORIES, type Material, type MaterialCategory, type ModelChange, type Mood, type MoodCategory, type MoodValue, type MultiDimPickerWiring, type MultiPickerAnalyzerSpec, type MusicEra, type MusicGenre, type MusicGenreCategory, type MusicMoodData, type MusicMoodEntry, type MusicSubgenre, NODE_PROMPT_CANDIDATE_FIELDS, OBJECT_ANGLE_PRESETS, OBJECT_ANGLE_PROMPTS, OBJECT_ASSET_PRESETS, OBJECT_ASSET_PROMPTS, OBJECT_MATERIAL_PRESETS, OBJECT_MATERIAL_PROMPTS, OBJECT_VARIATION_PRESETS, OBJECT_VARIATION_PROMPTS, type ObjectMotionPromptInput, type ObjectPresetAssetType, type ObjectPromptInput, PEOPLE, PERSON_DIMENSION_LABELS, PERSON_DIMENSION_ORDER, PERSON_DIMENSION_SECTIONS, PERSON_FIELD_BY_DIMENSION, PERSON_IDS, PHOTOGRAPHERS, PHOTOGRAPHER_CATEGORY_LABELS, PHOTOGRAPHER_CATEGORY_ORDER, PHOTOGRAPHER_IDS, PHOTO_GENRES, PHOTO_GENRE_CATEGORY_LABELS, PHOTO_GENRE_CATEGORY_ORDER, PHOTO_GENRE_IDS, PICKER_ANALYZER_FAMILIES, PICKER_ANALYZER_REGISTRY, PICKER_CATALOGS, PICKER_TYPES, POSES, POSE_CATEGORY_LABELS, POSE_CATEGORY_ORDER, POSE_IDS, POST_PROCESS_EFFECTS, POST_PROCESS_EFFECT_IDS, PRODUCTION_STYLES, PROVIDER_CAPABILITIES, PROVIDER_PROMPT_DOCTRINES, type Person, type PersonDimension, type PersonDimensionSection, type PersonPack, type PersonValue, type PhotoGenre, type PhotoGenreCategory, type Photographer, type PhotographerCategory, type PickerAnalyzer, type PickerAnalyzerDescriptor, type PickerAnalyzerSpec, type PickerApplyMode, type PickerCatalog, type PickerCatalogDetail, type PickerCatalogInput, type PickerCatalogSummary, type PickerDimension, type PickerDimensionInput, type PickerDimensionSpec, type PickerGaps, type PickerHintMode, type PickerOption, type PickerOptionInput, type PickerType, type PickerWiring, type PickerWiringEntry, type Pose, type PoseCategory, type PoseValue, type PostProcessEffect, type ProjectPickerCatalogOptions, type ProjectedPickerCatalog, type ProjectedPickerDimension, type ProjectedPickerOption, type PromptSegment, type PromptSegmentOrigin, type ProviderPromptDoctrine, REFERENCE_IMAGE_ROLES, REFERENCE_RULES, REFERENCE_RULES_MULTI_PERSON, REF_BINDING, RENDER_QUALITIES, RENDER_QUALITY_IDS, type RecommendedModel, type ReferenceCounts, type RegisteredPersonEntry, type RenderQuality, type ResolveCharacterMentionsResult, type ResolveLocationMentionsResult, type ResolvePromptArgs, type ResolveVideoReferenceCoreArgs, SCENE_FRAME_RULE, SCENE_PROMPT_MAX_LENGTH, SETTINGS, SETTING_CATEGORY_LABELS, SETTING_IDS, SHOT_LABELS, SINGING_STYLES, SINGLE_PICKER_WIRING, SNIPPET_MEDIA_VALUES, STYLES, STYLE_IDS, STYLE_PRESETS, STYLINGS, STYLING_DIMENSION_LABELS, STYLING_DIMENSION_ORDER, STYLING_FIELD_BY_DIMENSION, STYLING_IDS, type Seedance2InputsArgs, type Seedance2InputsResult, type Seedance2Mode, type Setting, type SettingCategory, type SidecarCoverageReport, type SingleDimPickerWiring, type SnippetMedia, type SnippetTarget, type SoundComposition, type SoundCompositionFields, type SoundConsumerType, type StructuredPromptFields, type Style, type StylePreset, type Styling, type StylingDimension, type StylingValue, type SuspiciousTermOptions, TEMPORALS, TEMPORAL_CATEGORY_LABELS, TEMPORAL_CATEGORY_ORDER, TEMPORAL_FIELD_BY_CATEGORY, TEMPORAL_IDS, TERM_MAX_CHARS, TEXT_WIZARD_CATEGORIES, TRANSITIONS, TRANSITION_CATEGORY_LABELS, TRANSITION_CATEGORY_ORDER, TRANSITION_IDS, type Temporal, type TemporalCategory, type TemporalValue, type TermCarrier, type Transition, type TransitionCategory, type TransitionDuration, type TransitionIntensity, type TransitionPosition, type TransitionTiming, VIDEO_WIZARD_CATEGORIES, VOCAL_PRESENCE, VOCAL_PRESENCE_INSTRUMENTAL_ID, VOICE_ACCENTS, VOICE_AGES, VOICE_ARCHETYPES, VOICE_CHARACTER_DEFAULT_DATA, VOICE_DELIVERY_DEFAULT_DATA, VOICE_EMOTIONS, VOICE_GENDERS, VOICE_LANGUAGES, VOICE_PACES, VOICE_TIMBRES, type VeoI2vInputsArgs, type VeoI2vInputsResult, type VideoExtraRef, type VoiceCharacterEntry, type VoiceDeliveryEntry, WARDROBE, WARDROBE_CATEGORY_LABELS, WARDROBE_DIMENSION_ORDER, WARDROBE_FIELD_BY_DIMENSION, type WardrobeDimension, type WardrobeEntry, type WardrobeValue, type WizardCategory, type WizardNodeContext, type WizardOption, type WizardQuestion, type WizardSelection, appendField, appendMusicMeta, applyPickerJson, applyReferenceOrderToVideo, applyTemplate, assembleImageInput, assembleSunoInput, buildActionFxHints, buildActionFxTerms, buildAestheticHints, buildAestheticTerms, buildAgeHint, buildAtmosphereHints, buildAtmosphereTerms, buildCharacterPrompt, buildCreaturePrompt, buildExposureHints, buildExposureTerms, buildFaceTemplateInputs, buildFramingHints, buildFramingTerms, buildHeldPropHints, buildHeldPropTerms, buildIdentityDirectives, buildIdentityLockLine, buildImagePrompt, buildImagePromptSegments, buildInstrumentationHints, buildInstrumentationTerms, buildLightingHints, buildLightingTerms, buildLocationMotionPrompt, buildLocationPrompt, buildLocationRefinePrompt, buildMaterialHints, buildMaterialTerms, buildMoodHints, buildMoodTerms, buildMotionPrompt, buildMultiPickerAnalyzerSpec, buildMusicGenreHints, buildMusicGenreTerms, buildMusicMoodHints, buildMusicMoodTerms, buildObjectMotionPrompt, buildObjectPrompt, buildPersonHints, buildPersonTerms, buildPhotographerHints, buildPhotographerTerms, buildPickerAnalyzerSpec, buildPickerLegend, buildPickerZodSchema, buildPoseHints, buildPoseTerms, buildPostProcessHints, buildPostProcessTerms, buildReferenceBlocks, buildScenePrompt, buildStylingHints, buildStylingTerms, buildSurroundFillPrompt, buildTemporalHints, buildTemporalTerms, buildVoiceCharacterHints, buildVoiceCharacterTerms, buildVoiceDeliveryHints, buildVoiceDeliveryTerms, buildWardrobeHints, catalogPacksVersion, characterLockToRefLock, collectIdentityLockClause, composeCameraMotionHintFromConnections, composeCameraMotionTermFromConnections, composeCharacterFxHintFromConnections, composeNegative, composePickerCatalogs, composeSoundHintFromConnections, composeTransitionHintFromConnections, computeLlmChatFields, computeNodePrompt, computePackSidecarCoverage, deriveTerm, expandImagePositionRefs, expandImageRefTokens, filmStillPrefix, getActionFx, getActionFxLabel, getActionFxPromptHint, getActionFxTerm, getAesthetic, getAestheticLabel, getAestheticPromptHint, getAestheticTerm, getAtmosphere, getAtmosphereLabel, getAtmospherePromptHint, getAtmosphereTerm, getBackdrop, getBackdropLabel, getBackdropPromptHint, getBackdropTerm, getCameraFormat, getCameraFormatLabel, getCameraFormatPromptHint, getCameraFormatTerm, getCameraMotion, getCameraMotionLabel, getCameraMotionPromptHint, getCameraMotionTerm, getCategoriesForNodeType, getCharacterFx, getCharacterFxLabel, getCharacterFxPromptHint, getCharacterFxTerm, getColorLook, getColorLookLabel, getColorLookPromptHint, getColorLookTerm, getCompositionEffect, getCompositionEffectLabel, getCompositionEffectPromptHint, getCompositionEffectTerm, getEffectiveSunoCustomMode, getEra, getEraLabel, getEraPromptHint, getEraTerm, getExposure, getExposureLabel, getExposurePromptHint, getExposureTerm, getFactoryPresets, getFactorySnippets, getFraming, getFramingCategoryLimit, getFramingLabel, getFramingPromptHint, getFramingTerm, getHeldProp, getHeldPropLabel, getHeldPropPromptHint, getHeldPropTerm, getIdentityLockClause, getInstrument, getInstrumentTerm, getLens, getLensLabel, getLensPromptHint, getLensTerm, getLighting, getLightingLabel, getLightingPromptHint, getLightingTerm, getLoopSubject, getLoopSubjectLabel, getLoopSubjectPromptHint, getLoopSubjectTerm, getMaterial, getMaterialLabel, getMaterialPromptHint, getMaterialTerm, getMood, getMoodLabel, getMoodPromptHint, getMoodTerm, getMusicEmotion, getMusicEmotionTerm, getMusicEnergy, getMusicEnergyTerm, getMusicEra, getMusicEraTerm, getMusicGenre, getMusicGenreLabel, getMusicGenreTerm, getMusicSubgenre, getMusicSubgenreTerm, getMusicVibe, getMusicVibeTerm, getParameterPromptHint, getPerson, getPersonDimensionLimit, getPersonLabel, getPersonPromptHint, getPersonTerm, getPhotoGenre, getPhotoGenreLabel, getPhotoGenrePromptHint, getPhotoGenreTerm, getPhotographer, getPhotographerLabel, getPhotographerPromptHint, getPhotographerTerm, getPickerAnalyzer, getPickerCatalog, getPickerWiring, getPose, getPoseLabel, getPosePromptHint, getPoseTerm, getPostProcessEffect, getPostProcessEffectLabel, getPostProcessEffectPromptHint, getPostProcessEffectTerm, getProductionStyle, getProductionStyleTerm, getPromptDoctrine, getPromptTips, getRegisteredCatalogPacks, getRegisteredPeople, getRegisteredPersonDimensionLabels, getRegisteredPersonDimensionOrder, getRegisteredPersonFieldByDimension, getRegisteredPickerCatalogs, getRenderQuality, getRenderQualityLabel, getRenderQualityPromptHint, getRenderQualityTerm, getSetting, getSettingLabel, getSettingPromptHint, getSettingTerm, getSingingStyle, getSingingStyleTerm, getStyle, getStyleLabel, getStylePreset, getStylePromptHint, getStyleTerm, getStyling, getStylingDimensionLimit, getStylingLabel, getStylingPromptHint, getStylingTerm, getTemporal, getTemporalLabel, getTemporalPromptHint, getTemporalTerm, getTransition, getTransitionLabel, getTransitionPromptHint, getTransitionTerm, getVocalPresence, getVocalPresenceTerm, getVoiceAccent, getVoiceAccentTerm, getVoiceAge, getVoiceAgeTerm, getVoiceArchetype, getVoiceArchetypeTerm, getVoiceEmotion, getVoiceEmotionTerm, getVoiceGender, getVoiceGenderTerm, getVoiceLanguage, getVoiceLanguageTerm, getVoicePace, getVoicePaceTerm, getVoiceTimbre, getVoiceTimbreTerm, getWardrobeEntriesByDimension, getWardrobeEntry, getWardrobePromptHint, groupFactoryPresets, hasUpstreamCharacter, identityRefsSentence, isAnalyzablePicker, isInstrumentalVocal, isSuspiciousDerivedTerm, isVantageFraming, isWizardSupported, listPickerCatalogs, migratePersonValue, personPacksVersion, pickerFanoutTargets, projectAllCatalogs, projectPickerCatalog, promptBindsFirstFrame, referenceRulesBlock, registerCatalogPack, registerPersonPack, renderStructuredFields, resetCatalogPacks, resetPersonPacks, resolveBrandInput, resolveCharacterMentions, resolveGeminiOmniI2vInputs, resolveLocationMentions, resolvePrompt, resolveReferenceTokens, resolveSeedance2Inputs, resolveTemplate, resolveTerm, resolveVeoI2vInputs, resolveVideoReferenceCore, summarizePickerCatalogs, toIdentityLockMode, truncateForField, truncateText, withForcedIdentityLock };