@nodaro/prompts 1.11.0 → 1.13.0

package/dist/index.d.ts

@@ -896,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
@@ -1039,7 +1061,8 @@ declare function renderStructuredFields(fields: StructuredPromptFields): string;
  *    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.
+ *    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
@@ -1050,8 +1073,23 @@ declare function renderStructuredFields(fields: StructuredPromptFields): string;
 
 /** Which generation stages fold a dimension. */
 type DirectionSurface = "image" | "video" | "both";
-/** Verbosity family — the video policy folds `motion` compact, `look` full. */
+/**
+ * Verbosity family — the video policy folds `motion` compact, `look` full.
+ *
+ * It is ALSO the body/section split (`prompt-style-section.ts`): `motion` stays
+ * in the prompt body as shot prose, `look` moves to the `[style]` section. The
+ * two meanings are deliberately the same column: camera motion is part of the
+ * shot, not part of the look, on both axes, and a second column would let the
+ * verbosity policy and the section boundary drift apart one row at a time.
+ */
 type DirectionFamily = "look" | "motion";
+/**
+ * Which `[style]` line a LOOK row renders on. `"film"` = the four dimensions
+ * that describe the CAPTURE (stock, grade, style, era) plus the legacy camera
+ * format key; every other look row falls to the scene line. Absent on `motion`
+ * rows, which never reach the section at all.
+ */
+type DirectionStyleGroup = "film";
 interface DirectionFieldSpec {
     /**
      * Wire key — also the `DirectionFields` property name and the canvas
@@ -1066,6 +1104,12 @@ interface DirectionFieldSpec {
     readonly surface: DirectionSurface;
     /** Verbosity family. The video policy folds `motion` compact, `look` full. */
     readonly family: DirectionFamily;
+    /**
+     * `[style]`-section line for a `look` row. Omitted = the scene line. Meaningless
+     * on a `motion` row (those stay in the body), which is why it is optional
+     * rather than a required column with a null member.
+     */
+    readonly styleGroup?: DirectionStyleGroup;
     /** Ids honored per dimension. Extras are SLICED at render, never a 400. */
     readonly maxPicks: number;
     /**
@@ -1090,6 +1134,26 @@ interface DirectionFieldSpec {
  * 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 — SURVIVAL, NOT STRING 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 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. What position is NOT any more is the clause's
+ * place in the assembled STRING: every `look` row is lifted out of the body into
+ * the trailing `[style]` section (`prompt-style-section.ts`), so a look clause
+ * reads after every motion clause however early it folds. 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";
@@ -1143,6 +1207,7 @@ declare const DIRECTION_FIELDS: readonly [{
     readonly key: "cameraFormat";
     readonly surface: "both";
     readonly family: "look";
+    readonly styleGroup: "film";
     readonly maxPicks: 1;
     readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
 }, {
@@ -1203,6 +1268,7 @@ declare const DIRECTION_FIELDS: readonly [{
     readonly key: "colorLook";
     readonly surface: "both";
     readonly family: "look";
+    readonly styleGroup: "film";
     readonly maxPicks: 1;
     readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
 }, {
@@ -1221,6 +1287,7 @@ declare const DIRECTION_FIELDS: readonly [{
     readonly key: "style";
     readonly surface: "both";
     readonly family: "look";
+    readonly styleGroup: "film";
     readonly maxPicks: 1;
     readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
 }, {
@@ -1263,6 +1330,7 @@ declare const DIRECTION_FIELDS: readonly [{
     readonly key: "era";
     readonly surface: "both";
     readonly family: "look";
+    readonly styleGroup: "film";
     readonly maxPicks: 1;
     readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
 }, {
@@ -1341,6 +1409,7 @@ declare const DIRECTION_FIELDS: readonly [{
     readonly key: "cameraFormatId";
     readonly surface: "both";
     readonly family: "look";
+    readonly styleGroup: "film";
     readonly maxPicks: 1;
     readonly render: (ids: readonly string[], mode: PickerHintMode) => string[];
 }];
@@ -1369,6 +1438,13 @@ type DirectionFields = {
  * re-deriving one.
  */
 declare const DIRECTION_KEYS: ReadonlyArray<DirectionKey>;
+/**
+ * The rows that render on the `[style]` section's FILM line, in table order —
+ * derived from the table's `styleGroup` column so the grouping has exactly one
+ * definition. Exported for clients that render the section themselves; the
+ * platform's own renderer reads the column, not this list.
+ */
+declare const FILM_STYLE_KEYS: ReadonlyArray<DirectionKey>;
 /** Verbosity for a whole fold, or split per family. */
 type DirectionHintMode = PickerHintMode | {
     readonly look: PickerHintMode;
@@ -1398,6 +1474,23 @@ declare const DIRECTION_ARRAY_CEILING = 8;
 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>;
+/** One rendered clause, still carrying the table attributes it came from. */
+interface DirectionHintClause {
+    readonly key: DirectionKey;
+    readonly family: DirectionFamily;
+    readonly styleGroup?: DirectionStyleGroup;
+    readonly text: string;
+}
+/**
+ * `renderDirectionHints` with the row each clause came from still attached —
+ * what the `[style]` section needs to decide which line a clause belongs on
+ * without a second table. Same order, same surface filter, same dedupe; the
+ * plain renderer is this one's `.text` projection, so the two cannot drift.
+ */
+declare function renderDirectionHintClauses(direction: DirectionFields | undefined, opts: {
+    surface: "image" | "video";
+    mode?: DirectionHintMode;
+}): DirectionHintClause[];
 /**
  * Every clause the `direction` channel injects, in canonical table order.
  *
@@ -1417,13 +1510,282 @@ declare function directionFieldsForSurface(surface: "image" | "video"): Readonly
  * 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.
+ * clauses the server does instead of re-implementing the fold. A preview of the
+ * assembled STRING needs `prompt-style-section.ts` on top: the look clauses in
+ * this list do not read in this position any more.
  */
 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.
@@ -1436,6 +1798,15 @@ declare function renderDirectionHints(direction: DirectionFields | undefined, op
  * ("prompt. hint", not "prompt . hint"), and drop a blank body so the result
  * never starts with ". ".
  *
+ * WHAT THIS JOIN COVERS NOW: the prompt BODY only. A LOOK clause no longer
+ * reaches this function from either composer — it lifts into the trailing
+ * `[style]` section (`prompt-style-section.ts`), which is `". "`-joined WITHIN a
+ * line but hung off the body by a blank line. So "every folded clause is one
+ * `". "` further along the same string" stopped being true for a look-carrying
+ * call, deliberately; `composeSectionedPrompt` is the whole-prompt shape and
+ * this is the piece of it that assembles the body. The zero-hint no-op branch is
+ * untouched and still the thing the routes' `composed !== prompt` guard reads.
+ *
  * Never mutates its inputs.
  */
 /** The measured separator between the user's prompt and each folded hint. */
@@ -1450,6 +1821,168 @@ declare const PROMPT_HINT_SEPARATOR = ". ";
  */
 declare function joinPromptHints(userPrompt: string, hints: readonly string[]): string;
 
+/**
+ * The section header, verbatim. Lowercase and bracketed so it reads as
+ * structure rather than as a sentence — and so it can be found again by
+ * `buildImagePrompt`'s hybrid line-capitalizer, which must stop here
+ * (`[Style]:` would be a different token, and capitalized clause lines would
+ * corrupt the lowercase catalog wording).
+ */
+declare const STYLE_SECTION_HEADER = "[style]:";
+/** The blank line between the body and the section. Omitted for an empty body. */
+declare const STYLE_SECTION_GAP = "\n\n";
+/**
+ * Split a composed prompt into the BODY and the `[style]` section it ends with
+ * (`section: ""` when it carries none, the body then being the whole string;
+ * the section comes back WITHOUT the gap).
+ *
+ * Matched from the RIGHT: the composer always emits the section last, and a
+ * user's own prose is free to contain the same characters. A blank body drops
+ * the gap with it, so the section-only form is matched on its own.
+ */
+declare function splitStyleSection(prompt: string): {
+    body: string;
+    section: string;
+};
+/**
+ * Extend a composed prompt's BODY with more lines, AHEAD of the `[style]`
+ * section — what every assembler downstream of the composer needs, because the
+ * section has no terminator: a plain append lands under the header and reads as
+ * one more look clause. Reference bindings, element directives and character
+ * descriptions are scene content that belongs with the prose, and leaving the
+ * look clauses last is where a look tail was measured to cost nothing.
+ *
+ * With no section this IS the plain `"\n"` join every caller emitted before —
+ * the byte-parity path, down to the leading newline an empty prompt produces.
+ */
+declare function insertBeforeStyleSection(prompt: string, lines: readonly string[]): string;
+/**
+ * True when `prompt` ends INSIDE the section — its last `\n\n`-delimited block
+ * opens with the header. What the self-labeling control lines (`Style:`,
+ * `Avoid:`) read: they stay at the END of the prompt by design, so a blank line
+ * of their own is the only thing that can close the header's scope ahead of
+ * them.
+ */
+declare function endsInsideStyleSection(prompt: string): boolean;
+/** Where a rendered clause reads in the assembled prompt. */
+type PromptClauseSlot = "body" | "film" | "scene";
+/** A rendered clause plus the line it belongs on. */
+interface SlottedPromptClause {
+    readonly text: string;
+    readonly slot: PromptClauseSlot;
+}
+/**
+ * The slot a direction row's clause takes: motion stays in the body, the five
+ * `styleGroup: "film"` rows lead the section, every other look row follows on
+ * the scene line.
+ */
+declare function styleSlotFor(row: {
+    readonly family: DirectionFamily;
+    readonly styleGroup?: DirectionStyleGroup;
+}): PromptClauseSlot;
+/**
+ * The SUBJECT channel's clauses: always body. Who is in the shot is the noun
+ * phrase the look modifies, not part of the look.
+ */
+declare function asBodyClauses(texts: readonly string[]): SlottedPromptClause[];
+/**
+ * Fold a direction bag and tag each clause with its slot, in registry table
+ * order. The ORDER is the fold/survival order, not the string order — the
+ * composers slice this list from the tail when a cap forces a shed, and only
+ * then hand the surviving prefix to `composeSectionedPrompt`.
+ */
+declare function partitionStyleClauses(direction: DirectionFields | undefined, opts: {
+    surface: "image" | "video";
+    mode?: DirectionHintMode;
+}): SlottedPromptClause[];
+/**
+ * The section block for a set of clauses — `""` when none of them is a look
+ * clause. Each line is omitted entirely when its half of the split is empty, so
+ * a scene-only fold never emits a blank film line.
+ */
+declare function styleSectionFromClauses(clauses: readonly SlottedPromptClause[]): string;
+/**
+ * The section for a raw direction bag — the entry point a client renders its
+ * preview through, so the preview and the server emit the same bytes.
+ */
+declare function renderStyleSection(direction: DirectionFields | undefined, opts: {
+    surface: "image" | "video";
+    mode?: DirectionHintMode;
+}): string;
+/**
+ * The assembled prompt for a set of clauses: body clauses `". "`-joined onto the
+ * user's prompt, the structured fragment last in the body, then the section.
+ *
+ * TRIMMING follows `joinPromptHints`: the prompt is trimmed whenever ANYTHING
+ * folded — a section counts, so a look-only fold trims too, or the blank line
+ * would inherit the prompt's trailing whitespace. With nothing folded at all the
+ * prompt is returned VERBATIM AND UNTRIMMED (`undefined` passes straight
+ * through), which is the byte-parity contract every existing caller rests on.
+ *
+ * A blank body drops the gap with it, so the result never opens on a newline —
+ * the same reason `joinPromptHints` filters a blank prompt out of its join.
+ */
+declare function composeSectionedPrompt<T extends string | undefined>(userPrompt: T, clauses: readonly SlottedPromptClause[], structuredFragment: string): string | T;
+/**
+ * What each clause costs the assembled prompt, as the EXACT composed-length
+ * delta of adding it to the prefix below it. Feeds `keepableDirectionHints`,
+ * which walks the list tail-first.
+ *
+ * Exact deltas rather than "clause + separator" because the section's own bytes
+ * are not evenly distributed: the FIRST look clause carries the whole
+ * `"\n\n[style]:\n"` header (11 characters that only come back when the section
+ * disappears), the second look clause of a line carries a `". "`, the first of
+ * the scene line carries a `"\n"`. Flat costs would under-price the header, so
+ * the walk would cover a deficit with more clauses than it needs and over-shed
+ * — visible as a fold that drops two clauses where one would have fit. The
+ * deltas do not change between shed iterations (the walk only ever shortens the
+ * prefix), so they are computed once, before the loop.
+ */
+declare function sectionedClauseCosts(userPrompt: string | undefined, clauses: readonly SlottedPromptClause[], structuredFragment: string): number[];
+
+/**
+ * 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.
+ *
+ * `clauseCosts[i]` is what clause `i` really adds to the assembled prompt.
+ * Without it each clause is charged its text plus one separator, which is what
+ * a clause folded inline costs — but a clause that lands in the `[style]`
+ * section carries section bytes too (the first one carries the whole header),
+ * and under-charging it makes this walk cover the deficit with MORE clauses
+ * than it needs. Both in-package callers pass exact composed-length deltas
+ * (`sectionedClauseCosts`); the default keeps the pre-section arithmetic for
+ * anyone else.
+ *
+ * Still deliberately approximate (assembly is not perfectly additive — a
+ * downstream frame can grow or shrink around the body); the caller re-assembles
+ * and re-checks, and this function strictly decreases `kept` whenever
+ * `deficit > 0`, so that loop terminates however the costs are priced.
+ */
+declare function keepableDirectionHints(hintClauses: readonly string[], kept: number, deficit: number, clauseCosts?: readonly number[]): number;
+
 /**
  * The reference-binding surface string — `@image_N` / `@video_N` / `@audio_N`
  * — and the one identity sentence built on it. Split out of
@@ -1905,17 +2438,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):
- * a node that carries NO stored `direction` / `structured` (every workflow
- * authored before the canvas honored them) still reaches here with both 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 `direction` / `structured` when it carries them
- * (`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
- * same two levers directly.
+ * 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
@@ -1949,6 +2482,13 @@ interface AssembleImageInput {
      * 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;
     /**
@@ -2008,9 +2548,24 @@ 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;
 
@@ -2027,20 +2582,40 @@ declare function assembleImageInput(input: AssembleImageInput): BuildImagePrompt
  *
  * 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
+ * its `Use these characters:` block, hybrid prepends the lock lines and extends
+ * the body's END with the canonical role phrases and extras (spliced in ahead of
+ * the `[style]` section, which stays last). 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 SHAPE IT EMITS: the body (prose, subject fold, MOTION clauses, structured
+ * fragment) and then a trailing `[style]` section carrying every LOOK clause —
+ * `prompt-style-section.ts` owns those bytes. Camera motion is shot prose, not
+ * style, so the whole motion family stays in the body; the boundary is the
+ * registry's `family` column, deliberately the same column the verbosity policy
+ * below splits on.
+ *
  * 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).
+ * (`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 direction and no structured fields the caller's
+ * 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 →
@@ -2049,19 +2624,108 @@ declare function assembleImageInput(input: AssembleImageInput): BuildImagePrompt
  * `__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` — ONE
- * renderer serves both surfaces, so the image and video folds cannot drift.
+ * 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.
+ * `renderSubjectHints` + `partitionStyleClauses` + `composeSectionedPrompt`
+ * directly (or `renderStyleSection` for the section alone).
  */
 
 /**
- * Fold a video run's cinematic-direction ids (and optional structured fields)
- * into its prompt body.
- *
- * The direction hints land first, in the registry's canonical table order
- * (camera motion leads), and the structured fragment lands LAST — the same
- * ordering `composePromptText` uses for stills.
+ * 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 that end its body. None of it is sheddable and all of it is inside
+ *    what the clamp measures, so a budget blind to it under-sheds and hands the
+ *    remainder to the order-blind cut. 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.
+ *
+ * IN THE BODY: the SUBJECT hints first (who is in the shot — the noun phrase the
+ * cinematography modifies), then the MOTION direction hints in the registry's
+ * canonical table order (camera motion leads), then the structured fragment —
+ * the same ordering `composePromptText` uses for stills. The LOOK hints leave
+ * the body for the `[style]` section that follows it.
+ *
+ * `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.
@@ -2070,17 +2734,24 @@ declare function assembleImageInput(input: AssembleImageInput): BuildImagePrompt
  *   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 verbosity policy (a whole-fold
+ * @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;
-}): string | undefined;
+    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 `direction` / `structured` levers `assembleImageInput` accepts.
+ * 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.
@@ -2138,6 +2809,28 @@ declare function composeVideoPromptText(userPrompt: string | undefined, directio
  * 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;
@@ -6493,4 +7186,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, 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, 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, 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_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 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, 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, 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, listPickerCatalogs, migratePersonValue, modeForFamily, nodeHasInlinePrompt, nodeHasPromptField, nodeSupportsPromptAffixes, personPacksVersion, pickerFanoutTargets, projectAllCatalogs, projectPickerCatalog, promptAffixCoreField, promptBindsFirstFrame, promptFieldCarriesAffixes, promptPartSeparator, readDirectionFields, readStructuredFields, referenceRulesBlock, registerCatalogPack, registerPersonPack, renderDirectionHints, 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 DirectionHintClause, type DirectionHintMode, type DirectionKey, type DirectionStyleGroup, 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, FILM_STYLE_KEYS, 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 PromptClauseSlot, 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, STYLE_SECTION_GAP, STYLE_SECTION_HEADER, 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 SlottedPromptClause, 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, asBodyClauses, 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, composeSectionedPrompt, composeSoundHintFromConnections, composeTransitionHintFromConnections, composeVideoPromptText, computeLlmChatFields, computeNodePrompt, computePackSidecarCoverage, deriveTerm, directionFieldsForSurface, endsInsideStyleSection, 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, insertBeforeStyleSection, isAnalyzablePicker, isInstrumentalVocal, isSuspiciousDerivedTerm, isVantageFraming, isWizardSupported, joinPromptHints, joinPromptParts, keepableDirectionHints, listPickerCatalogs, migratePersonValue, modeForFamily, nodeHasInlinePrompt, nodeHasPromptField, nodeSupportsPromptAffixes, normalizeSubjectFields, partitionStyleClauses, personPacksVersion, pickerFanoutTargets, projectAllCatalogs, projectPickerCatalog, promptAffixCoreField, promptBindsFirstFrame, promptFieldCarriesAffixes, promptPartSeparator, readDirectionFields, readStructuredFields, readSubjectFields, referenceRulesBlock, registerCatalogPack, registerPersonPack, renderDirectionHintClauses, renderDirectionHints, renderStructuredFields, renderStyleSection, renderSubjectHints, resetCatalogPacks, resetPersonPacks, resolveBrandInput, resolveCharacterMentions, resolveGeminiOmniI2vInputs, resolveLocationMentions, resolvePrompt, resolveRefIdTokens, resolveReferenceTokens, resolveSeedance2Inputs, resolveTemplate, resolveTerm, resolveVeoI2vInputs, resolveVideoReferenceCore, sectionedClauseCosts, splitStyleSection, styleSectionFromClauses, styleSlotFor, subjectFieldsForSurface, summarizePickerCatalogs, toIdentityLockMode, truncateForField, truncateText, withForcedIdentityLock };