@nodaro/prompts 1.10.0 → 1.12.0

package/dist/index.d.cts

@@ -859,6 +859,12 @@ interface BuildImagePromptConfig {
      * (`flux-lora-character`) — the trigger word + LoRA carries identity, so
      * the directive bullets are redundant and the wired-character refs
      * shouldn't be injected as `Image N`.
+     *
+     * The strip regex is grammar-agnostic — it eats LOCATION and named-IMAGE
+     * mentions (`@town:3:background`) as well as character ones. That is
+     * INTENDED, not an oversight: this path drops `connectedReferences` outright,
+     * so there is no reference left for any mention to bind to and a surviving
+     * token would reach the model as literal noise. Do not narrow it.
      */
     skipCharacterMentions?: boolean;
 }
@@ -890,6 +896,28 @@ interface BuildImagePromptSegmentsResult extends BuildImagePromptResult {
  * origin-tagged decomposition.
  */
 declare function buildImagePrompt(config: BuildImagePromptConfig): BuildImagePromptResult;
+/** {@link buildImagePrompt} plus `overflowChars`. */
+interface BuildImagePromptOverflowResult extends BuildImagePromptResult {
+    /**
+     * Characters the provider's prompt cap forced off the tail — `0` when the
+     * assembled prompt fit. This is the amount of text that must LEAVE the body
+     * for the prompt to fit without a tail cut, so a caller can shed exactly
+     * enough of its own droppable text and re-assemble.
+     */
+    overflowChars: number;
+}
+/**
+ * `buildImagePrompt` plus the size of the cap overflow it had to clamp away.
+ *
+ * The prompt (and every other field) is BYTE-IDENTICAL to `buildImagePrompt` —
+ * the marks channel only observes. Exists because the tail clamp is ORDER-BLIND:
+ * it cuts whatever happens to be last, which on a low-cap provider can sever a
+ * reference directive or the user's own prose while a decorative hint clause
+ * survives. `assembleImageInput` uses this to drop its lowest-value text
+ * (direction-folded hint clauses) FIRST and re-assemble; the clamp then stays
+ * the last-resort fallback for a body that overflows on prose alone.
+ */
+declare function buildImagePromptWithOverflow(config: BuildImagePromptConfig): BuildImagePromptOverflowResult;
 /**
  * `buildImagePrompt` plus an origin-tagged decomposition of the assembled
  * `prompt`. The string output (and all other fields) is byte-identical to
@@ -999,6 +1027,768 @@ interface StructuredPromptFields {
  */
 declare function renderStructuredFields(fields: StructuredPromptFields): string;
 
+/**
+ * THE DIRECTION REGISTRY — the single, ordered table of every cinematic
+ * dimension the flat `direction` channel carries, plus the one renderer that
+ * folds it into prompt text.
+ *
+ * WHY IT EXISTS: before this module, five of the ~35 cinematic dimensions rode
+ * the `direction` wire channel and every other dimension was folded into prompt
+ * TEXT by the client. A production copied between clients therefore froze stale
+ * catalog wording, and each client re-implemented the fold. The table below is
+ * the platform-owned replacement: the wire carries ids, the platform renders
+ * the clauses, and the fold ORDER is exported so a client preview cannot drift
+ * from what the server actually emits.
+ *
+ * WIRE VOCABULARY: the keys are the platform's OWN node-data field names — the
+ * ones `SINGLE_PICKER_WIRING[].valueField` and the four `*_FIELD_BY_CATEGORY`
+ * maps already use (`shotSize`, `lightingStyle`, `isoValue`, `style`, `mood`,
+ * `cameraMotion`, …). A Studio-emitted graph and a hand-built canvas node
+ * therefore speak ONE vocabulary for one catalog, and every `build*Hints`
+ * already consumes these names.
+ *
+ * IMPORT RULE (hard): this module imports only `get*PromptHint` / `get*Term` /
+ * `build*Hints` FUNCTIONS — never a raw UPPERCASE catalog array.
+ * `catalog-funnel-ratchet.test.ts` derives its watch set from
+ * `picker-catalogs.ts`'s uppercase value imports and can only SHRINK, so a raw
+ * array import here would be a new offender. Nothing here reads an environment
+ * variable either (`content-free-contract.test.ts`) — verbosity and surface are
+ * threaded parameters, never deployment state.
+ *
+ * DELIBERATELY EXCLUDED, so neither is filed as a gap:
+ *  - `characterFx` — a per-shot composer with catalog timing levers
+ *    (`composeCharacterFxHintFromConnections`) positioned at an in-prose effect
+ *    token, not a bare id. A single-id channel cannot carry it.
+ *  - Subject / Styling / prop dimensions (`animal`, `heldProp`, `material`,
+ *    Person, Styling) — a separate `subject` channel, deliberately out of scope
+ *    here. It now exists: `subject-registry.ts`, same table-driven shape, its
+ *    key set DISJOINT from this one (pinned by a test) so nothing folds twice.
+ *
+ * PACK BLINDNESS (parity, not a regression): `get*PromptHint` reads the frozen
+ * base arrays, so ids added by a deployment-registered catalog pack resolve to
+ * `""` and contribute no clause. This is identical to the behavior of the five
+ * keys that shipped before this table; routing through `getPickerCatalog` is a
+ * deliberate non-goal.
+ */
+
+/** Which generation stages fold a dimension. */
+type DirectionSurface = "image" | "video" | "both";
+/** Verbosity family — the video policy folds `motion` compact, `look` full. */
+type DirectionFamily = "look" | "motion";
+interface DirectionFieldSpec {
+    /**
+     * Wire key — also the `DirectionFields` property name and the canvas
+     * node-data field name for the same catalog.
+     */
+    readonly key: string;
+    /**
+     * Which generation stages fold this dimension. Filtering happens in the
+     * RENDERER, never in the wire schema: an image-only key sent to
+     * `/v1/generate-video` is accepted and simply contributes no hint.
+     */
+    readonly surface: DirectionSurface;
+    /** Verbosity family. The video policy folds `motion` compact, `look` full. */
+    readonly family: DirectionFamily;
+    /** Ids honored per dimension. Extras are SLICED at render, never a 400. */
+    readonly maxPicks: number;
+    /**
+     * Render selected ids in this catalog's own doctrine: per-id for independent
+     * catalogs, ONE blended clause for Mood / Aesthetic / Photographer, the
+     * catalog's own multi builder where it has one. `[]` when nothing resolves.
+     */
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}
+/**
+ * THE TABLE. Declaration order IS fold order (`DIRECTION_KEYS`), pinned by
+ * `__tests__/direction-registry.test.ts`.
+ *
+ * Group order: camera motion leads (matching the video hint order the canvas
+ * and Studio both emit today), then composition → camera → exposure → light →
+ * style → scene → motion, then the LEGACY BLOCK last.
+ *
+ * THE LEGACY BLOCK (the last five rows) is the pre-registry published
+ * `DirectionFields`, placed LAST in today's exact `composePromptText` order so
+ * every existing caller's fold is byte-identical. They are WHOLE-CATALOG keys —
+ * `framingId` accepts ANY `FRAMINGS` id and `lightingId` ANY `LIGHTINGS` id —
+ * so they are NOT aliases of `shotSize` / `lightingStyle`, and an alias table
+ * would wrongly suppress a legal second selection. Overlap is handled instead
+ * by the exact-string dedupe in `renderDirectionHints`.
+ *
+ * SECOND MEANING OF POSITION: BOTH cap-aware assemblers — `assembleImageInput`
+ * (stills) and `composeVideoPromptText` (video) — shed hint clauses from the
+ * TAIL of this order when a provider's prompt cap overflows, through the one
+ * shared arithmetic in `hint-shedding.ts`. So a row's position is also its
+ * survival order under the cap on EVERY surface: reordering rows for one
+ * surface silently changes what the other drops first, and the row a
+ * video-surface reorder would most likely touch (`cameraMotion`) leads the
+ * fold. That is a consequence of reusing the fold order, not a ranking — this
+ * table stays a compatibility order; anything that needs a real importance
+ * ranking should add an explicit priority column rather than reorder these rows.
+ *
+ * WHERE THIS TABLE SITS IN THE COMBINED ORDER: both assemblers fold the SUBJECT
+ * channel (`subject-registry.ts`) BEFORE this one and shed the combined list
+ * tail-first, so every direction row here is dropped before any subject clause.
+ * Deliberate — see `hint-shedding.ts` for the argument.
+ */
+declare const DIRECTION_FIELDS: readonly [{
+    readonly key: "cameraMotion";
+    readonly surface: "video";
+    readonly family: "motion";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "shotSize";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "angle";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "coverage";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "composition";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 2;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "vantage";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "pose";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "compositionEffect";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "cameraFormat";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "lens";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "aperture";
+    readonly surface: "image";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "shutterSpeed";
+    readonly surface: "image";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "isoValue";
+    readonly surface: "image";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "timeOfDay";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "lightingStyle";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 2;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "lightingDirection";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "lightingRatio";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "colorTemperature";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "colorLook";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "atmosphere";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 2;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "postProcess";
+    readonly surface: "image";
+    readonly family: "look";
+    readonly maxPicks: 2;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "style";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "mood";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 2;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "aesthetic";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 2;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "photoGenre";
+    readonly surface: "image";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "photographer";
+    readonly surface: "image";
+    readonly family: "look";
+    readonly maxPicks: 2;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "renderQuality";
+    readonly surface: "image";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "setting";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "era";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "backdrop";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "actionFx";
+    readonly surface: "video";
+    readonly family: "motion";
+    readonly maxPicks: 2;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "temporalSpeed";
+    readonly surface: "video";
+    readonly family: "motion";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "temporalFreeze";
+    readonly surface: "video";
+    readonly family: "motion";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "temporalDirection";
+    readonly surface: "video";
+    readonly family: "motion";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "temporalShutter";
+    readonly surface: "video";
+    readonly family: "motion";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "transition";
+    readonly surface: "video";
+    readonly family: "motion";
+    readonly maxPicks: 2;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "loopSubject";
+    readonly surface: "video";
+    readonly family: "motion";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "framingId";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "framingAngleId";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "lightingId";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "lensId";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "cameraFormatId";
+    readonly surface: "both";
+    readonly family: "look";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}];
+type DirectionFieldRow = (typeof DIRECTION_FIELDS)[number];
+type DirectionKey = DirectionFieldRow["key"];
+type ImageDirectionKey = Extract<DirectionFieldRow, {
+    surface: "image" | "both";
+}>["key"];
+type VideoDirectionKey = Extract<DirectionFieldRow, {
+    surface: "video" | "both";
+}>["key"];
+/**
+ * Flat cinematic-direction ids (Studio / MCP / canvas node data).
+ *
+ * Every key accepts a single id OR an array: multi-pick dimensions always carry
+ * an array, and a single-pick key may legitimately carry one (a client's
+ * partition writer preserving legacy out-of-catalog ids). Absent ≠ empty — a
+ * missing key means "no hint", never a default.
+ */
+type DirectionFields = {
+    readonly [K in DirectionKey]?: string | readonly string[];
+};
+/**
+ * Table order — THE canonical fold order. Exported so a client's "will inject
+ * into prompt" preview folds in the exact order the server does instead of
+ * re-deriving one.
+ */
+declare const DIRECTION_KEYS: ReadonlyArray<DirectionKey>;
+/** Verbosity for a whole fold, or split per family. */
+type DirectionHintMode = PickerHintMode | {
+    readonly look: PickerHintMode;
+    readonly motion: PickerHintMode;
+};
+/** Image policy: full clause for every dimension (today's behavior). */
+declare const IMAGE_HINT_MODE_DEFAULT: DirectionHintMode;
+/** Video policy: full look clauses, compact motion terms. */
+declare const VIDEO_HINT_MODE_DEFAULT: DirectionHintMode;
+declare function modeForFamily(mode: DirectionHintMode, family: DirectionFamily): PickerHintMode;
+/**
+ * Wire tolerance ceiling for an array-valued direction key. The SEMANTIC cap is
+ * the per-row render-time slice (`maxPicks`) — this is only the point past
+ * which a body is malformed rather than merely over-generous.
+ */
+declare const DIRECTION_ARRAY_CEILING = 8;
+/**
+ * Tolerance ceiling for the LENGTH of a single direction id. Catalog ids are
+ * short slugs (<= ~40 chars); 100 is generous and closes an otherwise unbounded
+ * string channel that lands verbatim in `jobs.input_data`.
+ *
+ * ONE literal for BOTH doors into the fold — the route's `directionSchema`
+ * (`backend/src/lib/direction-schema.ts`) and the persisted-node reader
+ * (`read-node-direction.ts`) — so the wire and the canvas cannot start
+ * disagreeing about which strings are ids at all.
+ */
+declare const DIRECTION_ID_MAX_CHARS = 100;
+/** The rows a given generation stage folds, in table order. */
+declare function directionFieldsForSurface(surface: "image" | "video"): ReadonlyArray<DirectionFieldSpec>;
+/**
+ * Every clause the `direction` channel injects, in canonical table order.
+ *
+ * Iterates the TABLE (never the caller's object), so unknown wire keys are
+ * ignored, the order is platform-owned, and off-surface dimensions are inert.
+ * Unknown IDS are silently skipped too — every `get*PromptHint` returns `""` on
+ * a miss, so a retired or pack-only id contributes no clause rather than a 400.
+ *
+ * DEDUPE: the result is de-duplicated by exact clause string, FIRST OCCURRENCE
+ * WINS (order-preserving). This is what lets the five legacy whole-catalog keys
+ * (`framingId`, `lightingId`, …) coexist with their canonical counterparts
+ * without an alias table: a caller sending `framingId` and `shotSize` with the
+ * SAME id emits the clause once, while `lightingId: "golden-hour"` alongside
+ * `lightingStyle: "rembrandt"` correctly emits BOTH (they are different ids in
+ * the same catalog — an alias table would have wrongly suppressed one).
+ * A caller sending two DIFFERENT ids for the same dimension gets both clauses,
+ * exactly as two wired picker nodes of one family behave today.
+ *
+ * Exported so a client's "will inject into prompt" preview renders the exact
+ * server output instead of re-implementing the fold.
+ */
+declare function renderDirectionHints(direction: DirectionFields | undefined, opts: {
+    surface: "image" | "video";
+    mode?: DirectionHintMode;
+}): string[];
+
+/**
+ * THE SUBJECT REGISTRY — the ordered table of every SUBJECT dimension the flat
+ * `subject` channel carries (who is in the shot: Person, Styling, and the three
+ * prop catalogs), plus the one renderer that folds it into prompt text.
+ *
+ * WHY A SECOND CHANNEL, NOT `StructuredPromptFields`: that type is FREE TEXT
+ * (`person.hair?: string` → "with {hair} hair"), its reader is a hand-authored
+ * field table whose totality is compile-time enforced by mapped types, its
+ * values are bounded as prose (200 chars), and it renders as headed sentences
+ * ("Subject: …. Style: …."). None of those survive contact with ~50 CATALOG IDS
+ * plus deployment-registered pack dimensions unknown at compile time, whose
+ * hints are authored as comma-joinable compound clauses. `direction-registry.ts`
+ * already has the four properties this channel needs — a platform-owned fold
+ * order exported for client preview parity, a DERIVED wire schema and node
+ * reader, unknown-key/unknown-id inertness, and shared bounds across both doors
+ * — so this module mirrors it. `direction-registry.ts` hands this scope off by
+ * name in its own header.
+ *
+ * WIRE VOCABULARY: the keys are the platform's OWN node-data field names — the
+ * ones `PERSON_FIELD_BY_DIMENSION` / `STYLING_FIELD_BY_DIMENSION` and the prop
+ * pickers' `valueField` already use (`hairBase`, `lipState`, `wardrobeState`,
+ * `heldProp`, `material`, `animal`, …). A canvas person/styling node stores
+ * exactly these, and every `build*Hints` already consumes them.
+ *
+ * THE WIRE IS A FLAT BAG, AND THE FLATNESS IS LOAD-BEARING (not a shortcut):
+ * `collectStylingFragments` reads `data.lipState` — a PERSON field — to skip
+ * `makeup-bold-lips` when `lip-state-bold-red` is already selected. That dedupe
+ * only fires for a consumer folding both pickers off ONE shared value map,
+ * which is precisely what this channel is. Nesting `person` / `styling` as
+ * sub-records would hand the styling builder a bag with no `lipState` in it and
+ * the lipstick clause would silently double. Hence: flat wire, and the group
+ * rows below receive the WHOLE normalized bag rather than a slice of it.
+ *
+ * PRE/POST FREE TEXT IS DELIBERATELY OFF THE WIRE (v1): `PersonValue` and
+ * `StylingValue` BOTH declare `preText`/`postText` and both `collect*Fragments`
+ * read them, so a shared flat bag would emit the same prose twice. They are the
+ * only genuine key collision in the set and are simply not `SUBJECT_KEYS`, so
+ * the normalizer drops them. Per-subject free text is the one future need that
+ * would force either nesting or suffixed keys (`personPreText` / …).
+ *
+ * IMPORT RULE (hard, inherited from the direction registry): this module
+ * imports only `get*PromptHint` / `get*Term` / `build*Hints` FUNCTIONS and the
+ * `*_FIELD_BY_DIMENSION` / `*_DIMENSION_ORDER` maps — never a raw UPPERCASE
+ * catalog array (`PEOPLE`, `STYLINGS`, `ANIMALS`). `catalog-funnel-ratchet.test.ts`
+ * derives its watch set from `picker-catalogs.ts`'s uppercase value imports and
+ * can only SHRINK, so a raw array import here would be a new offender — which
+ * is exactly why the animal getters live in `@nodaro/shared`. Nothing here
+ * reads an environment variable either (`content-free-contract.test.ts`):
+ * verbosity and surface are threaded parameters, never deployment state.
+ *
+ * DISJOINT FROM `direction` BY CONTRACT: `SUBJECT_KEYS ∩ DIRECTION_KEYS = ∅`,
+ * pinned by a test. `pose` rides `direction` even though the picker wiring files
+ * it under "Subject / Object"; keeping the two key sets disjoint is what stops
+ * one selection emitting two clauses.
+ */
+
+/** Which generation stages fold a dimension (mirrors `DirectionSurface`). */
+type SubjectSurface = "image" | "video" | "both";
+/**
+ * Flat subject ids — the wire shape and the canvas node-data shape.
+ *
+ * Keys are the platform's own field names; a value is one id, a list of ids, or
+ * (for `customAge` alone) a number. Absent ≠ empty: a missing key means "no
+ * hint", never a default.
+ */
+type SubjectFields = Readonly<Record<string, string | readonly string[] | number>>;
+/**
+ * A fold row whose render consumes the WHOLE normalized bag and returns ONE
+ * already-joined clause.
+ *
+ * Two reasons this kind exists rather than one row per person/styling field:
+ *  1. the cross-catalog dedupe described in the module header needs the whole
+ *     bag in one call;
+ *  2. these builders emit FRAGMENTS, not clauses — 30 person fragments handed
+ *     to the `". "` prompt-hint join read as "a beautiful woman. in her 30s.
+ *     East Asian." The catalogs' own grammar is a comma-joined compound clause,
+ *     so the row joins with ", " and hands back a single piece.
+ */
+interface SubjectGroupFieldSpec {
+    /** Fold-row id. NOT a wire key — a group row reads many of them. */
+    readonly key: string;
+    readonly kind: "group";
+    readonly surface: SubjectSurface;
+    /** The whole normalized bag in, one joined clause out (`[]` when empty). */
+    readonly render: (subject: SubjectFields, mode: PickerHintMode) => string[];
+}
+/** A fold row that reads ONE wire key holding catalog ids (the prop catalogs). */
+interface SubjectIdsFieldSpec {
+    /** Wire key AND fold-row id — these rows are one key each. */
+    readonly key: string;
+    readonly kind: "ids";
+    readonly surface: SubjectSurface;
+    /** Ids honored. Extras are SLICED by the normalizer, never a 400. */
+    readonly maxPicks: number;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}
+type SubjectFieldSpec = SubjectGroupFieldSpec | SubjectIdsFieldSpec;
+/**
+ * THE TABLE. Declaration order IS fold order (`SUBJECT_FOLD_KEYS`), pinned by
+ * `__tests__/subject-registry.test.ts`.
+ *
+ * Person leads (who), then how they are styled, then what they hold, what it is
+ * made of, and finally the animal in frame. Both group rows run over the SAME
+ * normalized bag, in this order, which is what keeps the styling builder's
+ * `lipState` dedupe alive.
+ *
+ * SECOND MEANING OF POSITION (same as `DIRECTION_FIELDS`): both cap-aware
+ * assemblers fold this table AHEAD of the direction table into ONE sheddable
+ * list and shed it TAIL-FIRST through `hint-shedding.ts`, so a row's position
+ * here is also its survival order under a provider's prompt cap — subject
+ * clauses outlive every direction clause, and within this block `animal` leaves
+ * before `person`. A compatibility order, not a ranking; anything needing a
+ * real ranking adds an explicit priority column rather than reordering rows.
+ */
+declare const SUBJECT_FIELDS: readonly [{
+    readonly key: "person";
+    readonly kind: "group";
+    readonly surface: "both";
+    readonly render: (subject: SubjectFields, mode: PickerHintMode) => string[];
+}, {
+    readonly key: "styling";
+    readonly kind: "group";
+    readonly surface: "both";
+    readonly render: (subject: SubjectFields, mode: PickerHintMode) => string[];
+}, {
+    readonly key: "heldProp";
+    readonly kind: "ids";
+    readonly surface: "both";
+    readonly maxPicks: 2;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "material";
+    readonly kind: "ids";
+    readonly surface: "both";
+    readonly maxPicks: 2;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}, {
+    readonly key: "animal";
+    readonly kind: "ids";
+    readonly surface: "both";
+    readonly maxPicks: 1;
+    readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
+}];
+type SubjectFieldRow = (typeof SUBJECT_FIELDS)[number];
+/**
+ * Table order — THE canonical fold order, over ROWS (not wire keys). Exported
+ * so a client's "will inject into prompt" preview folds in the exact order the
+ * server does, the way `DIRECTION_KEYS` does for direction.
+ */
+declare const SUBJECT_FOLD_KEYS: ReadonlyArray<string>;
+/**
+ * The one person field that is a NUMBER, not ids: the literal age in years,
+ * consulted only when `age === "age-custom"` (`buildAgeFragment`). It has no
+ * styling twin, so it rides the flat bag without collision.
+ */
+declare const SUBJECT_CUSTOM_AGE_KEY = "customAge";
+/**
+ * THE WIRE KEY SET, derived — every person field, `customAge`, every styling
+ * field, then the prop rows, in fold order. Never hand-listed: a dimension
+ * added to either catalog joins the channel by construction.
+ *
+ * BASE ONLY, deliberately: a deployment-registered person pack adds dimensions
+ * at RUNTIME, so the pack-aware set is computed per call inside
+ * `normalizeSubjectFields` (and inside `readSubjectFields`). This constant is
+ * what a client enumerates to build its projection; a pack dimension it cannot
+ * know about still rides the wire and still folds.
+ *
+ * ONE CONSEQUENCE, noted rather than fixed: the person builder's legacy `lips`
+ * fallback field is not a dimension and so is not here, making it unreachable
+ * through this channel. Intended — the wire speaks the current vocabulary; the
+ * fallback stays for node blobs written before the split.
+ */
+declare const SUBJECT_KEYS: ReadonlyArray<string>;
+/**
+ * `SUBJECT_KEYS` plus whatever a deployment-registered person pack added — the
+ * set the DOORS accept (`readSubjectFields`, and any route-side normalize).
+ *
+ * Rebuilt per call because pack registration happens at boot, after this module
+ * is imported. With no packs registered it is `SUBJECT_KEYS` exactly, pinned by
+ * a test.
+ */
+declare function getRegisteredSubjectKeys(): ReadonlyArray<string>;
+/** Verbosity for a whole subject fold. No family split — subject is one family. */
+type SubjectHintMode = PickerHintMode;
+/** Image policy: the full mechanism clause for every dimension. */
+declare const SUBJECT_IMAGE_HINT_MODE_DEFAULT: SubjectHintMode;
+/**
+ * Video policy: the compact professional term.
+ *
+ * A fully specified person at `"full"` is ~30 paragraph clauses, and on the
+ * video stage the start frame already carries the subject's identity — the
+ * clip's prompt needs the subject NAMED, not re-described. (The image stage,
+ * which is where the subject is actually being built, keeps `"full"`.)
+ */
+declare const SUBJECT_VIDEO_HINT_MODE_DEFAULT: SubjectHintMode;
+/**
+ * Wire tolerance ceiling for an array-valued subject key, and the ceiling for
+ * one id's length. DEFINED AS the direction constants rather than re-typed, so
+ * ONE literal governs both channels and both doors (the route schema and the
+ * persisted-node reader) — the wire and the canvas cannot start disagreeing
+ * about which strings are ids at all.
+ */
+declare const SUBJECT_ARRAY_CEILING = 8;
+declare const SUBJECT_ID_MAX_CHARS = 100;
+/**
+ * Bound on the NUMBER of keys in a subject bag. `SUBJECT_KEYS` is 54 today;
+ * this leaves generous headroom for deployment-registered pack dimensions while
+ * still closing an otherwise unbounded record that lands verbatim in
+ * `jobs.input_data`. Unknown keys are inert (the renderer never reads them), so
+ * this is storage hygiene, not validation.
+ */
+declare const MAX_SUBJECT_KEYS = 128;
+/** Bound on the LENGTH of one wire key. Field names are short identifiers. */
+declare const SUBJECT_KEY_MAX_CHARS = 64;
+/**
+ * THE NORMALIZER — a known-key, per-dimension-capped copy of a subject bag.
+ *
+ * WHY IT EXISTS (and why the fold is unusable without it): the subject builders
+ * do NOT cap. `collectPersonFragments` / `collectStylingFragments` /
+ * `emitIndependentFragments` emit EVERY id they are handed; `normalizePickIds`
+ * and `pickHeldPropIds` dedupe but never slice; only `buildMaterialHints` caps,
+ * and only structurally at 2. `MAX_SELECTED_BY_DIMENSION`'s own doc names its
+ * consumers as the picker UI, the analyzer schema and the Zod validator — NOT
+ * the builders. Straight off the wire, then, a bag is a clause amplifier: 8 ids
+ * (the array ceiling) on each of ~50 dimensions. This is where the per-dimension
+ * cap actually gets enforced.
+ *
+ * It also:
+ *  - DROPS UNKNOWN KEYS, so `jobs.input_data` stays the platform's vocabulary
+ *    (unknown IDS stay inert instead — every getter resolves a miss to `""`);
+ *  - UNWRAPS a single-id array to a bare string. Load-bearing:
+ *    `collectPersonFragments` reads a single-pick dimension with
+ *    `typeof raw === "string"`, so a legitimate `["hair-base-long"]` from a
+ *    client's array-shaped store would otherwise contribute NOTHING;
+ *  - clamps `customAge` to a whole `0..120`, mirroring `buildAgeFragment`.
+ *
+ * Copy-on-write: the caller's object is never mutated. Idempotent, so calling it
+ * at a door AND inside the renderer is free.
+ */
+declare function normalizeSubjectFields(subject: SubjectFields | undefined): SubjectFields | undefined;
+/** The rows a given generation stage folds, in table order. */
+declare function subjectFieldsForSurface(surface: "image" | "video"): ReadonlyArray<SubjectFieldSpec>;
+/**
+ * Every clause the `subject` channel injects, in canonical table order.
+ *
+ * NORMALIZES ONCE, at the top, and hands THE SAME bag to both group rows — that
+ * single shared bag is the mechanism behind the styling builder's cross-catalog
+ * `lipState` dedupe, and it must not depend on a door having normalized first
+ * (the normalizer is idempotent, so a door may do it too).
+ *
+ * Iterates the TABLE, never the caller's object: unknown wire keys contribute
+ * nothing, the order is platform-owned, and an off-surface row is inert.
+ * Unknown IDS are skipped too — every `get*PromptHint` returns `""` on a miss,
+ * so a retired or pack-only id costs no clause rather than a 400.
+ *
+ * DEDUPE by exact clause string, FIRST OCCURRENCE WINS (order-preserving),
+ * matching `renderDirectionHints`.
+ *
+ * Exported so a client's "will inject into prompt" preview renders the exact
+ * server output — called on the very object the client sends — instead of
+ * re-implementing the fold.
+ */
+declare function renderSubjectHints(subject: SubjectFields | undefined, opts: {
+    surface: "image" | "video";
+    mode?: SubjectHintMode;
+}): string[];
+
+/**
+ * The measured hint join, shared by the image (`composePromptText`) and video
+ * (`composeVideoPromptText`) composers so the two can never drift.
+ *
+ * EXACT NO-OP: zero hints → the user's prompt back VERBATIM AND UNTRIMMED (the
+ * platform-caller byte-parity contract — the old platform path passed the
+ * prompt straight to `buildImagePrompt`, which never trims, so trimming here
+ * would change the assembled prompt and the recorded `jobs.input_data`
+ * byte-for-byte). With hints → trim the body so the join reads cleanly
+ * ("prompt. hint", not "prompt . hint"), and drop a blank body so the result
+ * never starts with ". ".
+ *
+ * Never mutates its inputs.
+ */
+/** The measured separator between the user's prompt and each folded hint. */
+declare const PROMPT_HINT_SEPARATOR = ". ";
+/**
+ * Join a user prompt with its folded hint clauses.
+ *
+ * The trailing `.filter((p) => p.length > 0)` on the join array is
+ * parity-critical — do NOT remove it as "redundant": `hints` arrives
+ * pre-filtered but `userPrompt` does not, so a blank user prompt would
+ * otherwise make the result start with ". ".
+ */
+declare function joinPromptHints(userPrompt: string, hints: readonly string[]): string;
+
+/**
+ * How many of the first `kept` hint clauses may STAY if `deficit`
+ * characters have to leave the body. Walks the fold order from the TAIL,
+ * subtracting each clause plus the separator it brought, and stops as soon as
+ * enough has been reclaimed.
+ *
+ * The name is historical (direction was the first and for a while the only
+ * channel); the list both callers pass is now the COMBINED fold —
+ * `[...subject, ...direction]` on both surfaces — so the shed order is that
+ * combined order REVERSED: the direction block empties first, then the subject
+ * block. Deliberate, and the reason the two folds share one list: a fully
+ * specified person renders ~30 clauses, so a subject fold left unsheddable
+ * would be the single biggest way to push an overflow into the order-blind
+ * clamp, while a decorative grade or ISO value survives.
+ *
+ * Within the direction block the order is `DIRECTION_FIELDS` order REVERSED
+ * (and within the subject block, `SUBJECT_FIELDS` reversed). Note what that
+ * is and is not: each table's order is a COMPATIBILITY order (grouped by family,
+ * with the legacy `DirectionFields` block pinned last so every pre-registry
+ * caller's fold stays byte-identical) — it is NOT a ranking of how load-bearing
+ * a dimension is, and this function does not claim one. Tail-first is chosen
+ * because it is deterministic, matches the fold order the API documents, and
+ * needs no second ordering to drift out of sync with the table. A caller mixing
+ * legacy keys with the newer ones can therefore lose e.g. `lightingId` before a
+ * decorative `isoValue` clause; if that ever matters, the fix is an explicit
+ * priority column on `DIRECTION_FIELDS`, not a second hand-kept list here.
+ *
+ * Deliberately approximate (assembly is not perfectly additive); the caller
+ * re-assembles and re-checks, and this function strictly decreases `kept`
+ * whenever `deficit > 0`, so that loop terminates.
+ */
+declare function keepableDirectionHints(hintClauses: readonly string[], kept: number, deficit: number): number;
+
 /**
  * The reference-binding surface string — `@image_N` / `@video_N` / `@audio_N`
  * — and the one identity sentence built on it. Split out of
@@ -1454,13 +2244,17 @@ declare function assembleSunoInput(input: AssembleSunoInput): AssembleSunoResult
  * This wrapper collapses them into one.
  *
  * THE NO-OP CONTRACT (load-bearing — the platform-caller parity relies on it):
- * the two platform callers (`execute-node` / `payload-builder`) compose their
- * prompt from the canvas graph themselves and pass NO cinematic `direction`
- * ids and NO `structured` fields. In that case `composePromptText` MUST return
- * the caller's `userPrompt` byte-for-byte unchanged, so the wrapper degenerates
- * to exactly the `buildImagePrompt(...)` call those sites make today. Studio
- * (and the MCP route) supply `direction` / `structured` and get the id-hint
- * composition on top.
+ * a node that carries NO stored `subject` / `direction` / `structured` (every
+ * workflow authored before the canvas honored them) still reaches here with all
+ * three absent, and `composePromptText` MUST return the caller's `userPrompt`
+ * byte-for-byte unchanged, so the wrapper degenerates to exactly the
+ * `buildImagePrompt(...)` call those sites made before. The platform callers
+ * (`execute-node` / `payload-builder`) compose their prompt from the canvas GRAPH themselves and
+ * ALSO forward a node's STORED `subject` / `direction` / `structured` when it
+ * carries them (`readSubjectFields` / `readDirectionFields` /
+ * `readStructuredFields`); those nodes get the id-hint composition on top,
+ * ADDITIVE to the graph-wired cinematography hints the caller already folded
+ * into `userPrompt`. Studio and the MCP route supply the levers directly.
  *
  * THE EMPTY-CHECK FLAG (also load-bearing for parity): `execute-node` rejects a
  * truly-empty assembled prompt (its "type one, mention a character, or connect
@@ -1470,21 +2264,6 @@ declare function assembleSunoInput(input: AssembleSunoInput): AssembleSunoResult
  * guard (frontend, Studio, route) pass `throwOnEmpty: true`.
  */
 
-/**
- * Flat cinematic-direction ids the Studio framing UI (and the MCP route)
- * expose — all optional. Promoted here from Studio's `assembly.ts` so the
- * id → hint composition lives in one place. The platform callers pass none of
- * these (they fold their hints from the graph into `userPrompt` themselves).
- */
-interface DirectionFields {
-    /** Shot Type — the FRAMINGS shot-size/coverage/composition/vantage dimensions. */
-    framingId?: string;
-    /** Angle — the FRAMINGS angle dimension (separate pill, so it can coexist with Shot Type). */
-    framingAngleId?: string;
-    lightingId?: string;
-    lensId?: string;
-    cameraFormatId?: string;
-}
 /**
  * Input to `assembleImageInput`. A faithful SUPERSET of what the two platform
  * callers pass to `buildImagePrompt` today (so they can route through this
@@ -1504,10 +2283,18 @@ interface AssembleImageInput {
     connectedReferences?: ConnectedReference[];
     /**
      * Flat cinematic-direction ids → folded into the prompt as hints. Studio /
-     * MCP-route use; the platform callers pass none (so `composePromptText` is a
-     * no-op for them and the result is byte-identical to today).
+     * MCP-route use, and the platform callers' narrow-read of a node's STORED
+     * `data.direction`; absent on a node that carries none (so `composePromptText`
+     * is a no-op for it and the result is byte-identical to today).
      */
     direction?: DirectionFields;
+    /**
+     * Flat subject ids (Person / Styling / props) → folded into the prompt AHEAD
+     * of the direction clauses: the subject is the noun phrase the cinematography
+     * then modifies. Same provenance as `direction` — Studio / MCP-route, or the
+     * platform callers' narrow-read of a node's STORED `data.subject`.
+     */
+    subject?: SubjectFields;
     /** Path-1 structured fields → composed fragment appended to the prompt. */
     structured?: StructuredPromptFields;
     /**
@@ -1567,12 +2354,282 @@ interface AssembleImageInput {
  * Assemble a node's image-generation inputs into a `BuildImagePromptResult`
  * (`{ prompt, nativeNegativePrompt, referenceImageUrls }`).
  *
- * Order: (1) compose the prompt text (no-op when no direction/structured),
+ * Order: (1) compose the prompt text (no-op when no subject/direction/structured),
  * (2) `buildImagePrompt(...)` — exactly the call the three sites make today,
- * (3) optional post-assembly empty-prompt throw (gated by `throwOnEmpty`).
+ * (3) shed hint clauses and re-assemble while the provider cap overflows,
+ * (4) optional post-assembly empty-prompt throw (gated by `throwOnEmpty`).
+ *
+ * TRUNCATION ORDERING (step 3): `buildImagePrompt`'s cap clamp cuts the TAIL,
+ * which is ORDER-BLIND — on a low-cap provider (seedream = 3000) a maximal
+ * direction fold renders ~3.3K characters of clauses and the cut can sever a
+ * reference directive, mention-resolved text or the user's own prose while a
+ * decorative clause survives. So the ASSEMBLER decides instead: it knows which
+ * clauses are hints because it just built them, and drops them last-folded
+ * first until the prompt fits. Everything else — references, prose, the
+ * structured fragment, the Style/Avoid suffixes — outranks a hint. A body that
+ * still overflows with ZERO hints (long prose or many directives on its own)
+ * falls back to the builder's clamp, unchanged.
+ *
+ * UNDER-CAP PARITY: the first pass folds every hint, so a prompt that fits is
+ * byte-identical to before — the retry only ever runs on an over-cap assembly.
  */
 declare function assembleImageInput(input: AssembleImageInput): BuildImagePromptResult;
 
+/**
+ * `composeVideoPromptText` — the video twin of `assemble-image-input.ts`'s
+ * `composePromptText`: fold cinematic-direction picker IDS into the prompt BODY,
+ * server-side, at the model call.
+ *
+ * WHY THIS EXISTS: `/v1/generate-video` had no structured direction channel, so
+ * every client baked the hint TEXT itself. A copied scene then carried stale
+ * catalog wording forever, a re-generate double-baked it, and each client
+ * re-implemented the fold with its own separator and its own order. The wire
+ * now carries ids; the platform renders the clauses.
+ *
+ * WHERE IT RUNS (load-bearing): on the prompt BODY, BEFORE
+ * `resolveVideoReferenceCore`. That resolver FRAMES the body — legacy prepends
+ * its `Use these characters:` block, hybrid prepends the lock lines and APPENDS
+ * the canonical role phrases and extras. Folding afterwards would push the
+ * scene/look description PAST the identity directives, a worse version of the
+ * bug this channel exists to fix. The image side is structurally identical
+ * (`assembleImageInput` = `composePromptText` → `buildImagePrompt`).
+ *
+ * That ordering is also why cap-aware shedding here takes a `frame` callback
+ * rather than a provider id: the shed must run at the FOLD site (before the
+ * resolver) but be decided on the RESOLVED length (after it), so the binding
+ * text the resolver adds is inside the budget and can never be the thing that
+ * gets dropped. See {@link VideoPromptCapOptions}. Both catalog channels —
+ * SUBJECT and direction — fold into the one sheddable list that budget walks.
+ *
+ * THE VERBOSITY POLICY LIVES HERE, NOT IN THE CLIENT: motion dimensions render
+ * their compact professional term, look dimensions their full clause
+ * (`VIDEO_HINT_MODE_DEFAULT`, resolved per row's `family` by the registry). The
+ * SUBJECT fold has its own policy — compact on video
+ * (`SUBJECT_VIDEO_HINT_MODE_DEFAULT`), because a fully specified person at full
+ * verbosity is ~30 paragraph clauses and the start frame already carries the
+ * subject's identity into the clip.
+ * It is a threaded PARAMETER with a pure default — never deployment state:
+ * `__tests__/content-free-contract.test.ts` hard-fails any environment read
+ * under `packages/prompts/src`, and this module has nothing to read anyway.
+ *
+ * EXACT NO-OP CONTRACT: with no subject, no direction and no structured fields
+ * the caller's
+ * `userPrompt` comes back VERBATIM AND UNTRIMMED — `undefined` included, since
+ * a video prompt is optional on the route. That is what keeps every existing
+ * caller byte-identical (the "backward-compatible: no connectedReferences →
+ * prompt + flat refs pass through unchanged" oracle in
+ * `backend/src/routes/__tests__/generate-video.test.ts`, restated locally in
+ * `__tests__/assemble-video-input.test.ts`).
+ *
+ * WHAT IS DELIBERATELY NOT HERE: the dimension table, the fold order, the
+ * dedupe and the surface filter all live in `direction-registry.ts` (and
+ * `subject-registry.ts` for the subject channel) — ONE renderer per channel
+ * serves both surfaces, so the image and video folds cannot drift.
+ * Clients render their "will inject into prompt" preview by importing
+ * `renderDirectionHints` + `joinPromptHints` directly.
+ */
+
+/**
+ * Cap-aware shedding, opt-in. Absent → the composer is exactly what it always
+ * was (every existing caller stays byte-identical, and the no-op path below is
+ * never even reached differently).
+ *
+ * WHY A NUMBER AND A CALLBACK, NOT A PROVIDER ID — the two halves of the video
+ * surface's problem, which the image half did not have:
+ *
+ *  - `cap` is the caller's EFFECTIVE ceiling, not `getMaxVideoPromptChars` read
+ *    here. The routes compute it with `effectiveVideoPromptCeiling`, which
+ *    mirrors `applyVideoNegativePrompt`'s reservation of the `"\nAvoid: …"`
+ *    suffix for a provider with no native negative param. Re-deriving the cap
+ *    inside this package would put a second copy of that reservation one
+ *    refactor away from drifting from the clamp it is supposed to predict.
+ *
+ *  - `frame` is the REFERENCE RESOLVER, and it is what makes the shed correct
+ *    end-to-end. The fold runs BEFORE `resolveVideoReferenceCore` (see the
+ *    module header — folding afterwards strands the scene description past the
+ *    identity directives). The resolver then ADDS binding text: legacy's
+ *    "Use these characters:" block, hybrid's lock lines and the canonical role
+ *    phrases it APPENDS. That added text is exactly what an order-blind tail cut
+ *    destroys first, so it must be inside the budget — but it must never be
+ *    shed. Measuring THROUGH the caller's framing gives both properties at once:
+ *    the shed decision sees the final length, while the only thing it can drop
+ *    is a hint clause it rendered itself.
+ *
+ * Re-framing a SUBSET of the hints is sound because a hint can never change how
+ * the resolver reads the rest of the body: no registered catalog hint, term or
+ * label contains a `{image:N}` / `{ref:` / `@slug:N` shape
+ * (`__tests__/direction-hint-token-safety.test.ts` pins that for every catalog),
+ * so dropping one cannot renumber or unbind a reference.
+ */
+interface VideoPromptCapOptions {
+    /**
+     * The maximum length the FRAMED prompt may reach. Sheds only while the framed
+     * body exceeds it; `undefined` (the default) disables shedding entirely.
+     */
+    readonly cap?: number;
+    /**
+     * The downstream framing the cap is measured through — the caller's reference
+     * assembly. Identity when omitted (a caller with a cap but no references).
+     * Must be PURE: it is called once per shed iteration, and the caller re-runs
+     * its own real assembly on the returned body afterwards.
+     */
+    readonly frame?: (body: string | undefined) => string | undefined;
+}
+/**
+ * Fold a video run's subject and cinematic-direction ids (and optional
+ * structured fields) into its prompt body.
+ *
+ * The SUBJECT hints land first (who is in the shot — the noun phrase the
+ * cinematography modifies), then the direction hints in the registry's
+ * canonical table order (camera motion leads), and the structured fragment
+ * lands LAST — the same ordering `composePromptText` uses for stills.
+ *
+ * `subject` rides `opts` rather than a fourth positional parameter on purpose:
+ * every existing caller passes `(prompt, direction)` or
+ * `(prompt, direction, structured)` positionally, and a new positional would
+ * have made the two levers' order a memorization test.
+ *
+ * TRUNCATION ORDERING (opt-in via `opts.cap`): the provider clamp
+ * (`applyVideoNegativePrompt`) slices the prompt TAIL, which is ORDER-BLIND —
+ * on a low-cap provider (kling = 1000) a broad direction renders more than the
+ * whole ceiling and the cut severs reference bindings and the end of the user's
+ * prose while decorative clauses survive. With a cap the composer decides
+ * instead: it knows which clauses are hints because it just rendered them, and
+ * drops them LAST-FOLDED FIRST until the framed prompt fits. Everything else —
+ * the user's prose, the structured fragment (user CONTENT, never a garnish) and
+ * every byte the resolver's framing adds — outranks a hint.
+ *
+ * SUBJECT CLAUSES ARE SHED CANDIDATES TOO, and they shed AFTER the direction
+ * clauses. Both folds are catalog decoration of the same class — ids the
+ * platform rendered into wording — so exempting one would just move the
+ * overflow into the order-blind clamp, which is the bug this machinery exists
+ * to prevent. They ride the SAME `hintClauses` list the shed already walks
+ * (subject first, direction second, tail-first shedding), so there is exactly
+ * one shed arithmetic (`hint-shedding.ts`) across both channels and both
+ * surfaces. Neither channel ever sheds before the prose, the references or the
+ * structured fragment.
+ *
+ * WHAT THE BUDGET DELIBERATELY EXCLUDES: the route's later opt-in identity
+ * injection (an async DB read that appends a canonical description) and any
+ * registered `applyPromptPolicies` transform both run AFTER the reference
+ * assembly and are not modelled here. Pricing them in would mean folding an
+ * await into this pure composer; instead the provider clamp stays their last
+ * resort, exactly as today. Same for a body that still overflows with ZERO
+ * hints left — long prose, or many bound references on their own.
+ *
+ * UNDER-CAP PARITY: the first pass folds every hint, so a prompt that fits is
+ * byte-identical to a capless call, and a caller with no
+ * `subject`/`direction`/`structured` takes the same exact no-op path it always
+ * did.
+ *
+ * @param userPrompt The user's prompt. Optional: an image-to-video run may
+ *   legitimately have none, and it is returned as-is when nothing folds.
+ * @param direction Flat catalog ids. Unknown keys, off-surface keys (an
+ *   image-only dimension sent to a video run) and unknown ids all contribute
+ *   nothing — never a throw.
+ * @param structured Path-1 structured fields. Not a `/v1/generate-video` wire
+ *   field today; the canvas orchestrator passes it directly.
+ * @param opts.hintMode Override the direction verbosity policy (a whole-fold
+ *   `PickerHintMode`, or a `{ look, motion }` split).
+ * @param opts.subject Flat subject ids (Person / Styling / props), same
+ *   inertness contract as `direction`.
+ * @param opts.subjectHintMode Override the subject verbosity policy.
+ * @param opts.cap / `opts.frame` See {@link VideoPromptCapOptions}.
+ */
+declare function composeVideoPromptText(userPrompt: string | undefined, direction: DirectionFields | undefined, structured?: StructuredPromptFields, opts?: {
+    readonly hintMode?: DirectionHintMode;
+    readonly subject?: SubjectFields;
+    readonly subjectHintMode?: SubjectHintMode;
+} & VideoPromptCapOptions): string | undefined;
+
+/**
+ * Narrow readers turning UNTRUSTED persisted node data (`workflows.nodes`
+ * JSONB — import, MCP write, node preset, a Studio-emitted graph) into the
+ * typed `subject` / `direction` / `structured` levers `assembleImageInput`
+ * accepts.
+ * `buildPayload` has no zod and workflow writes are
+ * `z.record(z.string(), z.unknown())`, so this blob may have been written years
+ * ago by any client.
+ *
+ * Used by ALL THREE image-assembly sites so what the canvas accepts cannot
+ * drift between them: the frontend single-node executor (`execute-node.ts`),
+ * the orchestrator (`payload-builder.ts`), and the config-panel final-prompt
+ * preview (`build-image-assemble-input.ts`).
+ *
+ * `readDirectionFields` is DERIVED FROM `DIRECTION_FIELDS`, never a hand list:
+ * a dimension added to the registry is honored here by construction, so the
+ * reader can never silently drop a key the wire schema and the renderer both
+ * know about. Anything unrecognised is DROPPED, never thrown on — a malformed
+ * blob must not fail a canvas run, and an unknown catalog ID already degrades
+ * to `""` inside each `get*PromptHint`, so this validates SHAPE only.
+ *
+ * BOUNDS MATCH THE WIRE SCHEMA where both exist, by SHARED CONSTANT:
+ * `DIRECTION_ID_MAX_CHARS` and `DIRECTION_ARRAY_CEILING` are the same two
+ * literals the `generate-image` route's `directionSchema` enforces, imported
+ * from the registry rather than re-typed here — a body the route accepts and a
+ * node the canvas re-runs must not disagree about which strings are ids.
+ *
+ * DELIBERATELY STRICTER THAN THE WIRE SCHEMA on `structured` values: the
+ * route's `structuredPromptFieldsSchema` declares every field as a bare
+ * `z.string().optional()` (unbounded), while `MAX_STRUCTURED_VALUE_CHARS` below
+ * bounds them at 200. Do not "fix" that asymmetry by loosening HERE — this
+ * reads a blob any client may have written years ago, and the values land
+ * verbatim in `jobs.input_data.prompt`. Tightening the ROUTE instead would be a
+ * new 400 on currently-accepted input, so a >200-char structured value stored
+ * on a node is dropped on a canvas run while `POST /v1/generate-image` still
+ * renders it. That is the one known divergence; it is bounded to a field the
+ * canvas UI never writes that long.
+ *
+ * RETURNS `undefined`, NEVER `{}`: an empty object would still be a *defined*
+ * `direction`, and the call sites' `...(x !== undefined ? { x } : {})` spread
+ * would then hand `assembleImageInput` a defined-but-empty lever. Returning
+ * `undefined` keeps that spread honest and the exact no-op branch taken.
+ */
+
+/**
+ * Read a node's stored cinematic-direction ids. Accepts a single id OR an array
+ * on every key (multi-pick dimensions carry arrays; a single-pick key may
+ * legitimately carry one).
+ *
+ * The SEMANTIC per-dimension cap stays the renderer's slice (`maxPicks`) — this
+ * reader does not know a row's pick budget and must not guess it. But it DOES
+ * bound cardinality at `DIRECTION_ARRAY_CEILING`, the same ceiling the wire
+ * schema enforces: the value is untrusted persisted JSONB (a node blob is
+ * validated only as `z.record(z.string(), z.unknown())` on write), and handing
+ * an unbounded array to `renderDirectionHints` would put an `includes`-dedupe
+ * scan in front of that slice. Keeping the FIRST `DIRECTION_ARRAY_CEILING`
+ * survivors is what the wire door already does to the same input.
+ *
+ * Junk is filtered BEFORE the cap, so valid ids sitting behind malformed
+ * entries survive rather than being crowded out by them.
+ */
+declare function readDirectionFields(value: unknown): DirectionFields | undefined;
+/**
+ * Read a node's stored SUBJECT ids — the flat Person / Styling / prop bag the
+ * `subject` channel carries. Same three contracts as `readDirectionFields`:
+ * drop-never-throw, `undefined` never `{}`, and bounds shared with the wire
+ * door by CONSTANT (`SUBJECT_ID_MAX_CHARS` / `SUBJECT_ARRAY_CEILING`, which are
+ * defined AS the direction constants) so a body the route accepts and the same
+ * node re-run from the canvas cannot disagree about which strings are ids.
+ *
+ * DERIVED from `getRegisteredSubjectKeys()`, never a hand-authored field list —
+ * that is the whole lesson of `readStructuredFields` below, whose hand table is
+ * only viable because `StructuredPromptFields` is a small hand-authored type.
+ * The subject vocabulary is ~54 catalog-derived fields PLUS deployment-registered
+ * pack dimensions unknown at compile time, so it is read from the registry at
+ * call time. Iterating the KEY SET (never `Object.keys(value)`) is also what
+ * keeps an adversarial blob's key count off the hot path.
+ *
+ * The SEMANTIC per-dimension cap stays the renderer's job
+ * (`normalizeSubjectFields`), exactly as `maxPicks` does for direction: this
+ * reader bounds cardinality only. `customAge` is the one number on the wire and
+ * is passed through finite-only — the renderer clamps it.
+ */
+declare function readSubjectFields(value: unknown): SubjectFields | undefined;
+/** Read a node's stored Path-1 structured prompt fields. Same drop-never-throw
+ *  and `undefined`-never-`{}` contract as `readDirectionFields`. */
+declare function readStructuredFields(value: unknown): StructuredPromptFields | undefined;
+
 type Seedance2Mode = "first-frame" | "first-last-frame" | "reference";
 interface Seedance2InputsArgs {
     /** The generation prompt — used ONLY to detect an existing first-frame
@@ -5924,4 +6981,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_DURATIONS, CHARACTER_FX_IDS, CHARACTER_FX_INTENSITIES, CHARACTER_FX_POSITIONS, 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 CharacterFxTimingOption, 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, NODE_PROMPT_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, PROMPT_AFFIX_CORE_FIELD_OVERRIDES, PROMPT_AFFIX_NODE_TYPES, 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 PromptFieldSpec, type PromptIconKind, 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 RefIdTokenContext, 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_DURATIONS, TRANSITION_IDS, TRANSITION_INTENSITIES, TRANSITION_POSITIONS, type Temporal, type TemporalCategory, type TemporalValue, type TermCarrier, type Transition, type TransitionCategory, type TransitionDuration, type TransitionIntensity, type TransitionPosition, type TransitionTiming, type TransitionTimingOption, 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, applyPromptAffixes, 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, getPromptFields, getPromptTips, getRegisteredCatalogPacks, getRegisteredPeople, getRegisteredPersonDimensionLabels, getRegisteredPersonDimensionOrder, getRegisteredPersonFieldByDimension, getRegisteredPickerCatalogs, getRenderQuality, getRenderQualityLabel, getRenderQualityPromptHint, getRenderQualityTerm, getSetting, getSettingLabel, getSettingPromptHint, getSettingTerm, getSingingStyle, getSingingStyleTerm, getSnippetMedia, 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, joinPromptParts, listPickerCatalogs, migratePersonValue, nodeHasInlinePrompt, nodeHasPromptField, nodeSupportsPromptAffixes, personPacksVersion, pickerFanoutTargets, projectAllCatalogs, projectPickerCatalog, promptAffixCoreField, promptBindsFirstFrame, promptFieldCarriesAffixes, promptPartSeparator, referenceRulesBlock, registerCatalogPack, registerPersonPack, renderStructuredFields, resetCatalogPacks, resetPersonPacks, resolveBrandInput, resolveCharacterMentions, resolveGeminiOmniI2vInputs, resolveLocationMentions, resolvePrompt, resolveRefIdTokens, resolveReferenceTokens, resolveSeedance2Inputs, resolveTemplate, resolveTerm, 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 BuildImagePromptOverflowResult, 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_DURATIONS, CHARACTER_FX_IDS, CHARACTER_FX_INTENSITIES, CHARACTER_FX_POSITIONS, 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 CharacterFxTimingOption, type CharacterMeta, type CharacterMotionPromptInput, type CharacterPromptInput, type ColorLook, type ColorLookCategory, type CompositionEffect, type ComputeNodePromptArgs, type CreaturePromptInput, DEFAULT_IDENTITY_LOCK, DEFAULT_TEMPLATES, DIRECTION_ARRAY_CEILING, DIRECTION_FIELDS, DIRECTION_ID_MAX_CHARS, DIRECTION_KEYS, type DirectionFamily, type DirectionFieldRow, type DirectionFieldSpec, type DirectionFields, type DirectionHintMode, type DirectionKey, type DirectionSurface, 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_HINT_MODE_DEFAULT, IMAGE_REFERENCE_PROMPT_DOCTRINE, IMAGE_WIZARD_CATEGORIES, INSTRUMENTATION_DEFAULT_DATA, INSTRUMENTS, INSTRUMENT_CATEGORY_LABELS, INSTRUMENT_CATEGORY_ORDER, type IdentityLockMode, type ImageDirectionKey, 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, MAX_SUBJECT_KEYS, 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, NODE_PROMPT_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, PROMPT_AFFIX_CORE_FIELD_OVERRIDES, PROMPT_AFFIX_NODE_TYPES, PROMPT_HINT_SEPARATOR, 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 PromptFieldSpec, type PromptIconKind, 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 RefIdTokenContext, 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, SUBJECT_ARRAY_CEILING, SUBJECT_CUSTOM_AGE_KEY, SUBJECT_FIELDS, SUBJECT_FOLD_KEYS, SUBJECT_ID_MAX_CHARS, SUBJECT_IMAGE_HINT_MODE_DEFAULT, SUBJECT_KEYS, SUBJECT_KEY_MAX_CHARS, SUBJECT_VIDEO_HINT_MODE_DEFAULT, 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 SubjectFieldRow, type SubjectFieldSpec, type SubjectFields, type SubjectGroupFieldSpec, type SubjectHintMode, type SubjectIdsFieldSpec, type SubjectSurface, 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_DURATIONS, TRANSITION_IDS, TRANSITION_INTENSITIES, TRANSITION_POSITIONS, type Temporal, type TemporalCategory, type TemporalValue, type TermCarrier, type Transition, type TransitionCategory, type TransitionDuration, type TransitionIntensity, type TransitionPosition, type TransitionTiming, type TransitionTimingOption, VIDEO_HINT_MODE_DEFAULT, 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 VideoDirectionKey, type VideoExtraRef, type VideoPromptCapOptions, 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, applyPromptAffixes, applyReferenceOrderToVideo, applyTemplate, assembleImageInput, assembleSunoInput, buildActionFxHints, buildActionFxTerms, buildAestheticHints, buildAestheticTerms, buildAgeHint, buildAtmosphereHints, buildAtmosphereTerms, buildCharacterPrompt, buildCreaturePrompt, buildExposureHints, buildExposureTerms, buildFaceTemplateInputs, buildFramingHints, buildFramingTerms, buildHeldPropHints, buildHeldPropTerms, buildIdentityDirectives, buildIdentityLockLine, buildImagePrompt, buildImagePromptSegments, buildImagePromptWithOverflow, 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, composeVideoPromptText, computeLlmChatFields, computeNodePrompt, computePackSidecarCoverage, deriveTerm, directionFieldsForSurface, 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, getPromptFields, getPromptTips, getRegisteredCatalogPacks, getRegisteredPeople, getRegisteredPersonDimensionLabels, getRegisteredPersonDimensionOrder, getRegisteredPersonFieldByDimension, getRegisteredPickerCatalogs, getRegisteredSubjectKeys, getRenderQuality, getRenderQualityLabel, getRenderQualityPromptHint, getRenderQualityTerm, getSetting, getSettingLabel, getSettingPromptHint, getSettingTerm, getSingingStyle, getSingingStyleTerm, getSnippetMedia, 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, joinPromptHints, joinPromptParts, keepableDirectionHints, listPickerCatalogs, migratePersonValue, modeForFamily, nodeHasInlinePrompt, nodeHasPromptField, nodeSupportsPromptAffixes, normalizeSubjectFields, personPacksVersion, pickerFanoutTargets, projectAllCatalogs, projectPickerCatalog, promptAffixCoreField, promptBindsFirstFrame, promptFieldCarriesAffixes, promptPartSeparator, readDirectionFields, readStructuredFields, readSubjectFields, referenceRulesBlock, registerCatalogPack, registerPersonPack, renderDirectionHints, renderStructuredFields, renderSubjectHints, resetCatalogPacks, resetPersonPacks, resolveBrandInput, resolveCharacterMentions, resolveGeminiOmniI2vInputs, resolveLocationMentions, resolvePrompt, resolveRefIdTokens, resolveReferenceTokens, resolveSeedance2Inputs, resolveTemplate, resolveTerm, resolveVeoI2vInputs, resolveVideoReferenceCore, subjectFieldsForSurface, summarizePickerCatalogs, toIdentityLockMode, truncateForField, truncateText, withForcedIdentityLock };