@nodaro/prompts 1.11.0 → 1.12.0

package/src/assemble-video-input.ts

@@ -17,14 +17,26 @@
  * 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).
+ * (`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 →
@@ -33,8 +45,9 @@
  * `__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.
  */
@@ -44,19 +57,112 @@ import {
   type DirectionFields,
   type DirectionHintMode,
 } from "./direction-registry.js"
+import {
+  renderSubjectHints,
+  SUBJECT_VIDEO_HINT_MODE_DEFAULT,
+  type SubjectFields,
+  type SubjectHintMode,
+} from "./subject-registry.js"
 import { joinPromptHints } from "./prompt-hint-join.js"
+import { keepableDirectionHints } from "./hint-shedding.js"
 import {
   renderStructuredFields,
   type StructuredPromptFields,
 } from "./prompt-builder-structured-fields.js"
 
 /**
- * Fold a video run's cinematic-direction ids (and optional structured fields)
- * into its prompt body.
+ * 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.
+ */
+export 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 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.
+ * 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.
@@ -65,25 +171,74 @@ import {
  *   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}.
  */
 export function composeVideoPromptText(
   userPrompt: string | undefined,
   direction: DirectionFields | undefined,
   structured?: StructuredPromptFields,
-  opts?: { readonly hintMode?: DirectionHintMode },
+  opts?: {
+    readonly hintMode?: DirectionHintMode
+    readonly subject?: SubjectFields
+    readonly subjectHintMode?: SubjectHintMode
+  } & VideoPromptCapOptions,
 ): string | undefined {
-  const hints = [
+  // ONE sheddable list, subject FIRST then direction — because the shed walks it
+  // from the TAIL, so this order IS the survival order: a direction clause
+  // leaves before a subject clause. Deliberate, and the same order the image
+  // side uses (`renderImageHintPieces`): the subject is the noun phrase the
+  // cinematography modifies, so losing "who is in the shot" to keep a
+  // decorative grade would be the wrong trade. With no `subject` the list IS
+  // the direction fold, so every pre-subject caller is byte-identical.
+  const hintClauses = [
+    ...renderSubjectHints(opts?.subject, {
+      surface: "video",
+      mode: opts?.subjectHintMode ?? SUBJECT_VIDEO_HINT_MODE_DEFAULT,
+    }),
     ...renderDirectionHints(direction, {
       surface: "video",
       mode: opts?.hintMode ?? VIDEO_HINT_MODE_DEFAULT,
     }),
-    structured ? renderStructuredFields(structured) : "",
   ].filter((p) => p.length > 0)
-  // Nothing to fold → the caller's value straight back, `undefined` included.
-  // Do NOT collapse this into `joinPromptHints(userPrompt ?? "", hints)`: that
-  // would turn an absent prompt into `""` and break the no-op contract above.
-  if (hints.length === 0) return userPrompt
-  return joinPromptHints(userPrompt ?? "", hints)
+  // User CONTENT, not a garnish: never sheddable, always last.
+  const structuredFragment = structured ? renderStructuredFields(structured) : ""
+
+  const composeWith = (kept: number): string | undefined => {
+    const hints = [...hintClauses.slice(0, kept), structuredFragment].filter(
+      (p) => p.length > 0,
+    )
+    // Nothing to fold → the caller's value straight back, `undefined` included.
+    // Do NOT collapse this into `joinPromptHints(userPrompt ?? "", hints)`: that
+    // would turn an absent prompt into `""` and break the no-op contract above.
+    // A FULL shed lands here too, which is what keeps the no-op contract intact
+    // at `kept === 0` — the route's `composed !== prompt` guard then correctly
+    // leaves `input_data.userPrompt` unpinned.
+    if (hints.length === 0) return userPrompt
+    return joinPromptHints(userPrompt ?? "", hints)
+  }
+
+  const cap = opts?.cap
+  if (cap === undefined) return composeWith(hintClauses.length)
+
+  // Fold everything first (the under-cap byte-parity pass), then shed from the
+  // tail of the fold order while the FRAMED prompt overflows the ceiling.
+  // `keepableDirectionHints` — the ONE shed arithmetic, shared with the image
+  // assembler — strictly decreases `kept` whenever there is a deficit, so this
+  // terminates at `kept === 0` in the worst case, at which point nothing
+  // droppable is left and the provider clamp stands.
+  const frame = opts?.frame ?? ((body: string | undefined) => body)
+  let kept = hintClauses.length
+  let body = composeWith(kept)
+  let framedLength = frame(body)?.length ?? 0
+  while (framedLength > cap && kept > 0) {
+    kept = keepableDirectionHints(hintClauses, kept, framedLength - cap)
+    body = composeWith(kept)
+    framedLength = frame(body)?.length ?? 0
+  }
+  return body
 }

package/src/direction-registry.ts

@@ -32,7 +32,8 @@
  *    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
@@ -158,6 +159,22 @@ const temporal = perId(getTemporalPromptHint, getTemporalTerm)
  * 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.
  */
 export const DIRECTION_FIELDS = [
   { key: "cameraMotion", surface: "video", family: "motion", maxPicks: 1, render: perId(getCameraMotionPromptHint, getCameraMotionTerm) },

package/src/hint-shedding.ts

@@ -0,0 +1,68 @@
+/**
+ * The shed arithmetic shared by the image (`assembleImageInput`) and video
+ * (`composeVideoPromptText`) cap-aware assemblers, so the two surfaces cannot
+ * drift in WHICH clause goes first when a provider's prompt cap overflows.
+ *
+ * Only the arithmetic lives here. Each surface keeps its own loop, because what
+ * they MEASURE differs: the image side reads `buildImagePrompt`'s
+ * `overflowChars` (the cap clamp reports how much it cut), while the video side
+ * measures the resolver-FRAMED body against the route's effective ceiling. Both
+ * hand this function the same question — "how many of the first `kept` clauses
+ * may stay if `deficit` characters have to leave the body?" — and both re-assemble
+ * and re-check afterwards.
+ *
+ * WHAT COUNTS AS A SHEDDABLE CLAUSE (both surfaces, one answer): every clause
+ * the platform RENDERED from catalog ids — the SUBJECT fold and the cinematic
+ * DIRECTION fold alike. They are decoration of the same class, so exempting
+ * either would not save it: the overflow would simply land in the provider's
+ * order-blind tail clamp, severing reference bindings or the end of the user's
+ * prose instead — precisely the bug this machinery exists to prevent. Never
+ * sheddable: the user's prose, the bound references and the framing text the
+ * reference resolver adds, and the structured fragment (user CONTENT).
+ */
+import { PROMPT_HINT_SEPARATOR } from "./prompt-hint-join.js"
+
+/**
+ * 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.
+ */
+export function keepableDirectionHints(
+  hintClauses: readonly string[],
+  kept: number,
+  deficit: number,
+): number {
+  let remaining = deficit
+  let next = kept
+  while (next > 0 && remaining > 0) {
+    next -= 1
+    remaining -= hintClauses[next]!.length + PROMPT_HINT_SEPARATOR.length
+  }
+  return next
+}

package/src/index.ts

@@ -19,7 +19,9 @@ export * from "./brand-tokens.js"
 export * from "./prompt-builder.js"
 export * from "./prompt-builder-structured-fields.js"
 export * from "./direction-registry.js"
+export * from "./subject-registry.js"
 export * from "./prompt-hint-join.js"
+export * from "./hint-shedding.js"
 export * from "./video-reference-resolver.js"
 export * from "./sound-aggregator.js"
 export * from "./assemble-suno-input.js"

package/src/parameter-prompt-hint.ts

@@ -38,7 +38,7 @@ import { composeCameraMotionHintFromConnections } from "./camera-motions.js"
 import { composeTransitionHintFromConnections, type TransitionDuration, type TransitionIntensity, type TransitionPosition, type TransitionTiming } from "./transitions.js"
 import { composeCharacterFxHintFromConnections, type CharacterFxDuration, type CharacterFxIntensity, type CharacterFxPosition, type CharacterFxTiming } from "./character-fx.js"
 import { buildMaterialHints } from "./materials.js"
-import { getAnimal } from "@nodaro/shared"
+import { getAnimalPromptHint, getAnimalTerm } from "@nodaro/shared"
 import { getVehicle } from "@nodaro/shared"
 import { getWeapon } from "@nodaro/shared"
 import { getFurniture } from "@nodaro/shared"
@@ -322,15 +322,16 @@ function resolveBaseHint(
       return withCustomText(data, byMode(mode, getLoopSubjectPromptHint, getLoopSubjectTerm)(asStr(data.loopSubject)))
     case "material":
       return withCustomText(data, buildMaterialHints(data.material, mode))
-    case "animal": {
-      const animal = getAnimal(asStr(data.animal))
+    // Animal is the one Object-entity catalog whose phrasing has a single
+    // owner: `@nodaro/shared`'s `getAnimalPromptHint` / `getAnimalTerm`, which
+    // the picker-catalog funnel calls too. Both getters already return "" on a
+    // miss, so the entry lookup and the `animal ? … : ""` guard are the
+    // getters' job now, not this switch's.
+    case "animal":
       return withCustomText(
         data,
-        animal
-          ? byMode(mode, `featuring a ${animal.label.toLowerCase()}, ${animal.description}`, objectEntityTerm(animal))
-          : "",
+        byMode(mode, getAnimalPromptHint, getAnimalTerm)(asStr(data.animal)),
       )
-    }
     case "vehicle": {
       const vehicle = getVehicle(asStr(data.vehicle))
       return withCustomText(

package/src/picker-catalogs.ts

@@ -69,7 +69,7 @@ import {
 } from "./character-fx.js"
 import { POSES, POSE_CATEGORY_LABELS, POSE_CATEGORY_ORDER } from "./pose.js"
 import { MATERIALS, MATERIAL_CATEGORY_LABELS, MATERIAL_CATEGORY_ORDER } from "./materials.js"
-import { ANIMALS, ANIMAL_SUBCATEGORY_LABELS, ANIMAL_SUBCATEGORY_ORDER } from "@nodaro/shared"
+import { ANIMALS, ANIMAL_SUBCATEGORY_LABELS, ANIMAL_SUBCATEGORY_ORDER, getAnimalPromptHint } from "@nodaro/shared"
 import { VEHICLES, VEHICLE_SUBCATEGORY_LABELS, VEHICLE_SUBCATEGORY_ORDER } from "@nodaro/shared"
 import { WEAPONS, WEAPON_SUBCATEGORY_LABELS, WEAPON_SUBCATEGORY_ORDER } from "@nodaro/shared"
 import { FURNITURE, FURNITURE_SUBCATEGORY_LABELS, FURNITURE_SUBCATEGORY_ORDER } from "@nodaro/shared"
@@ -193,6 +193,13 @@ function toOptions<T extends BaseCatalogEntry>(
  * label + description. Reproduce the exact phrasing from
  * `getParameterPromptHint` so the registry stays faithful + every option's
  * `promptHint` is non-empty.
+ *
+ * ANIMALS is the exception, and the direction of travel for the other three:
+ * its phrasing now has ONE owner, `@nodaro/shared`'s `getAnimalPromptHint`,
+ * which this funnel and `getParameterPromptHint` both call instead of
+ * re-authoring the sentence. `phrase` therefore takes the ENTRY (not
+ * label+description), so a catalog whose phrasing has moved to a getter can be
+ * pointed at it.
  */
 interface ObjectCatalogEntry {
   readonly id: string
@@ -204,14 +211,14 @@ interface ObjectCatalogEntry {
 }
 function objectOptions(
   arr: ReadonlyArray<ObjectCatalogEntry>,
-  phrase: (label: string, description: string) => string,
+  phrase: (entry: ObjectCatalogEntry) => string,
 ): ReadonlyArray<PickerOption> {
   return arr.map((e) => ({
     id: e.id,
     label: e.label,
     description: e.description,
     category: e.subcategory,
-    promptHint: phrase(e.label.toLowerCase(), e.description),
+    promptHint: phrase(e),
     // Object entities have no `promptHint` field of their own (it is
     // synthesized above), so the term cannot come from `resolveTerm`'s
     // empty-hint rule: an authored `term` wins, and otherwise the label IS the
@@ -608,7 +615,7 @@ const SINGLE_CATALOGS: readonly PickerCatalog[] = [
     defaultValue: "dog-golden-retriever",
     categoryOrder: ANIMAL_SUBCATEGORY_ORDER,
     categoryLabels: ANIMAL_SUBCATEGORY_LABELS,
-    options: objectOptions(ANIMALS, (label, description) => `featuring a ${label}, ${description}`),
+    options: objectOptions(ANIMALS, (e) => getAnimalPromptHint(e.id)),
   },
   {
     nodeType: "vehicle",
@@ -619,7 +626,7 @@ const SINGLE_CATALOGS: readonly PickerCatalog[] = [
     defaultValue: "sedan",
     categoryOrder: VEHICLE_SUBCATEGORY_ORDER,
     categoryLabels: VEHICLE_SUBCATEGORY_LABELS,
-    options: objectOptions(VEHICLES, (label, description) => `featuring a ${label}, ${description}`),
+    options: objectOptions(VEHICLES, (e) => `featuring a ${e.label.toLowerCase()}, ${e.description}`),
   },
   {
     nodeType: "weapon",
@@ -630,7 +637,7 @@ const SINGLE_CATALOGS: readonly PickerCatalog[] = [
     defaultValue: "katana",
     categoryOrder: WEAPON_SUBCATEGORY_ORDER,
     categoryLabels: WEAPON_SUBCATEGORY_LABELS,
-    options: objectOptions(WEAPONS, (label, description) => `with a ${label}, ${description}`),
+    options: objectOptions(WEAPONS, (e) => `with a ${e.label.toLowerCase()}, ${e.description}`),
   },
   {
     nodeType: "furniture",
@@ -641,7 +648,7 @@ const SINGLE_CATALOGS: readonly PickerCatalog[] = [
     defaultValue: "sofa",
     categoryOrder: FURNITURE_SUBCATEGORY_ORDER,
     categoryLabels: FURNITURE_SUBCATEGORY_LABELS,
-    options: objectOptions(FURNITURE, (label, description) => `including a ${label}, ${description}`),
+    options: objectOptions(FURNITURE, (e) => `including a ${e.label.toLowerCase()}, ${e.description}`),
   },
   {
     nodeType: "held-prop",