@nodaro/prompts 1.11.0 → 1.13.0

package/src/__tests__/read-node-subject.test.ts

@@ -0,0 +1,140 @@
+/**
+ * `readSubjectFields` is the CANVAS door into the subject fold — the twin of
+ * the route's `subjectSchema`. It reads untrusted persisted node JSONB (a
+ * workflow write is validated only as `z.record(z.string(), z.unknown())`), so
+ * every assertion here is on the three contracts it shares with
+ * `readDirectionFields`: drop-never-throw, `undefined` never `{}`, and bounds
+ * that MATCH the wire door by shared constant.
+ */
+import { describe, it, expect, beforeEach } from "vitest"
+import { readSubjectFields } from "../read-node-direction.js"
+import {
+  SUBJECT_ARRAY_CEILING,
+  SUBJECT_ID_MAX_CHARS,
+  SUBJECT_KEYS,
+  getRegisteredSubjectKeys,
+  renderSubjectHints,
+} from "../subject-registry.js"
+import { registerPersonPack, resetPersonPacks } from "../person-packs.js"
+import { resetCatalogPacks } from "../catalog-packs.js"
+import { getPersonPromptHint } from "../person.js"
+
+beforeEach(() => {
+  resetPersonPacks()
+  resetCatalogPacks()
+})
+
+const pack = {
+  id: "test/person-sector",
+  dimensions: [{ dimension: "sector-attire", field: "sectorAttire", label: "Sector Attire" }],
+  entries: [
+    {
+      id: "attire-modest-suit",
+      label: "Modest Suit",
+      group: "Attire",
+      dimension: "sector-attire",
+      description: "a modest tailored suit",
+      promptHint: "wearing a modest tailored suit",
+    },
+  ],
+}
+
+describe("readSubjectFields — shape", () => {
+  it("round-trips the ids a node actually stores", () => {
+    expect(
+      readSubjectFields({
+        type: "woman",
+        hairBase: "base-buzz",
+        jewelry: ["jewelry-gold", "jewelry-silver"],
+        animal: "dog-corgi",
+      }),
+    ).toEqual({
+      type: "woman",
+      hairBase: "base-buzz",
+      jewelry: ["jewelry-gold", "jewelry-silver"],
+      animal: "dog-corgi",
+    })
+  })
+
+  it("returns undefined — never {} — for a blob with nothing readable", () => {
+    expect(readSubjectFields(undefined)).toBeUndefined()
+    expect(readSubjectFields(null)).toBeUndefined()
+    expect(readSubjectFields("nope")).toBeUndefined()
+    expect(readSubjectFields([])).toBeUndefined()
+    expect(readSubjectFields({})).toBeUndefined()
+    expect(readSubjectFields({ notAField: "man" })).toBeUndefined()
+  })
+
+  it("drops junk instead of throwing on it", () => {
+    expect(
+      readSubjectFields({
+        type: { nested: true },
+        hairBase: 42,
+        jewelry: [null, { x: 1 }, "jewelry-gold"],
+        makeup: "",
+      }),
+    ).toEqual({ jewelry: ["jewelry-gold"] })
+  })
+
+  it("filters junk BEFORE the ceiling, so valid ids behind it survive", () => {
+    const v = [...Array.from({ length: SUBJECT_ARRAY_CEILING }, () => 1), "jewelry-gold"]
+    expect(readSubjectFields({ jewelry: v })).toEqual({ jewelry: ["jewelry-gold"] })
+  })
+})
+
+describe("readSubjectFields — bounds shared with the wire door", () => {
+  it("keeps the first SUBJECT_ARRAY_CEILING entries of an over-long array", () => {
+    const many = Array.from({ length: SUBJECT_ARRAY_CEILING + 5 }, (_, i) => `id-${i}`)
+    const out = readSubjectFields({ jewelry: many }) as Record<string, unknown>
+    expect(out.jewelry).toEqual(many.slice(0, SUBJECT_ARRAY_CEILING))
+  })
+
+  it("drops an id longer than SUBJECT_ID_MAX_CHARS, keeping one exactly at the bound", () => {
+    const ok = "x".repeat(SUBJECT_ID_MAX_CHARS)
+    const tooLong = "x".repeat(SUBJECT_ID_MAX_CHARS + 1)
+    expect(readSubjectFields({ type: tooLong })).toBeUndefined()
+    expect(readSubjectFields({ type: ok })).toEqual({ type: ok })
+    expect(readSubjectFields({ jewelry: [tooLong, ok] })).toEqual({ jewelry: [ok] })
+  })
+
+  it("does NOT apply the per-dimension cap — that stays the renderer's slice", () => {
+    const four = ["jewelry-subtle", "jewelry-statement", "jewelry-gold", "jewelry-silver"]
+    expect((readSubjectFields({ jewelry: four }) as Record<string, unknown>).jewelry).toEqual(four)
+  })
+})
+
+describe("readSubjectFields — customAge, the one number", () => {
+  it("passes a finite number through for the renderer to clamp", () => {
+    expect(readSubjectFields({ age: "age-custom", customAge: 34 })).toEqual({
+      age: "age-custom",
+      customAge: 34,
+    })
+    expect(readSubjectFields({ customAge: 9999 })).toEqual({ customAge: 9999 })
+    expect(renderSubjectHints(readSubjectFields({ age: "age-custom", customAge: 9999 }), {
+      surface: "image",
+    })).toEqual(["120 years old"])
+  })
+
+  it("drops a non-finite or non-number customAge", () => {
+    expect(readSubjectFields({ customAge: Number.NaN })).toBeUndefined()
+    expect(readSubjectFields({ customAge: "34" })).toBeUndefined()
+  })
+})
+
+describe("readSubjectFields — pack awareness", () => {
+  it("with no packs registered, the accepted key set IS SUBJECT_KEYS", () => {
+    expect(getRegisteredSubjectKeys()).toEqual([...SUBJECT_KEYS])
+  })
+
+  it("reads a deployment-registered pack dimension, and folds its hint", () => {
+    expect(readSubjectFields({ sectorAttire: "attire-modest-suit" })).toBeUndefined()
+    registerPersonPack(pack)
+    expect(getRegisteredSubjectKeys()).toContain("sectorAttire")
+    expect(readSubjectFields({ sectorAttire: "attire-modest-suit" })).toEqual({
+      sectorAttire: "attire-modest-suit",
+    })
+    expect(
+      renderSubjectHints({ type: "woman", sectorAttire: "attire-modest-suit" }, { surface: "image" }),
+    ).toEqual([`${getPersonPromptHint("woman")}, wearing a modest tailored suit`])
+  })
+})

package/src/__tests__/style-section-boundary.test.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect } from "vitest"
+import { applyVideoNegativePrompt, getMaxImagePromptChars } from "@nodaro/shared"
+import type { CharacterDef, ConnectedReference } from "@nodaro/shared"
+import { buildImagePrompt } from "../prompt-builder.js"
+import { assembleImageInput } from "../assemble-image-input.js"
+import { composeVideoPromptText } from "../assemble-video-input.js"
+import { resolveVideoReferenceCore } from "../video-reference-resolver.js"
+import { getStylePromptHint } from "../style.js"
+
+/**
+ * WHERE THE `[style]` SECTION ENDS. The section has no terminator and every
+ * assembler downstream of the composer appends to the string it returns — the
+ * reference resolvers' role phrases and element directives, the legacy
+ * character descriptions, `Style:` and `Avoid:`. Line-joined onto a prompt that
+ * ENDS with the section, each of them reads as one more look clause under the
+ * header, which is exactly the confusion the section exists to remove.
+ *
+ * Two shapes keep them out, one per kind of text:
+ *  - BODY content — a reference binding, an element directive, a character
+ *    description — is SPLICED in ahead of the section, where the prose it
+ *    belongs with already is. The look tail stays last, which is where it was
+ *    measured to be free.
+ *  - The self-labeling control lines (`Style:` / `Avoid:`) stay at the end and
+ *    close the header's scope with a blank line instead.
+ *
+ * Assertions read the header as a LITERAL and the clause wording through the
+ * catalogs, so this suite pins the BOUNDARY, not the catalog copy.
+ */
+
+/** The `\n\n`-delimited block the `[style]:` header opens — every line the
+ *  model reads as a look clause. `""` when the prompt carries no section. */
+const styleBlockOf = (prompt: string): string =>
+  prompt.split("\n\n").find((b) => b.startsWith("[style]:")) ?? ""
+
+const LIBRARY: ConnectedReference = {
+  id: "l", defaultName: "Old Library", source: "wired-location",
+  url: "https://cdn/library.png", locationSlug: "old-library",
+}
+
+const KIRA: ConnectedReference = {
+  id: "kira", defaultName: "Kira", source: "wired-character",
+  url: "https://cdn/kira.png", characterSlug: "kira",
+  characterCanonicalDescription: "a young woman with copper hair",
+  variantSlug: undefined, variantDescription: null, variantDisplayName: "canonical",
+}
+
+const KIRA_DEF: CharacterDef = {
+  id: "kira", name: "Kira", type: "description", category: "character",
+  description: "auburn hair, hazel eyes",
+}
+
+/** Look on both lines: `style` is a film clause, `shotSize` a scene clause. */
+const DIRECTION = { style: "anime", shotSize: "wide-shot" } as const
+
+/** What the inline `style` text renders as in the `Style:` control line. */
+const CINEMATIC = getStylePromptHint("cinematic")
+
+/** The trailing role phrase a canonical (unmentioned) wired location renders. */
+const LOCATION_PHRASE = "the location from reference image A"
+/** The video twin, bound to the resolver's `@image_N` shape. */
+const CHARACTER_PHRASE = "the person from @image_1"
+
+describe("image assembly — nothing lands under the `[style]` header", () => {
+  const hybrid = assembleImageInput({
+    userPrompt: "a man walks",
+    provider: "nano-banana",
+    direction: DIRECTION,
+    connectedReferences: [LIBRARY],
+    referenceFormat: "hybrid",
+    style: "cinematic",
+    negativePrompt: "blurry",
+  }).prompt
+
+  it("splices the reference binding into the body, ahead of the section", () => {
+    // Non-vacuity: the section really is there, carrying both look lines.
+    expect(styleBlockOf(hybrid)).toContain("[style]:\n")
+    expect(styleBlockOf(hybrid)).toContain("wide shot")
+
+    expect(styleBlockOf(hybrid)).not.toContain(LOCATION_PHRASE)
+    expect(hybrid.indexOf(LOCATION_PHRASE)).toBeGreaterThan(-1)
+    expect(hybrid.indexOf(LOCATION_PHRASE)).toBeLessThan(hybrid.indexOf("[style]:"))
+  })
+
+  it("closes the section with a blank line before `Style:` / `Avoid:`", () => {
+    expect(styleBlockOf(hybrid)).not.toContain("Style:")
+    expect(styleBlockOf(hybrid)).not.toContain("Avoid:")
+    // The control lines stay together at the very end, one block of their own:
+    // the blank line is `Style:`'s to add, and `Avoid:` sees a closed section.
+    expect(hybrid.endsWith(`\n\nStyle: ${CINEMATIC}\nAvoid: blurry`)).toBe(true)
+  })
+
+  it("splices the LEGACY character description into the body too", () => {
+    const legacy = assembleImageInput({
+      userPrompt: "a man walks",
+      provider: "nano-banana",
+      direction: DIRECTION,
+      characterDefs: [KIRA_DEF],
+    }).prompt
+    const desc = "Include character 'Kira': auburn hair, hazel eyes."
+    expect(legacy).toContain(desc)
+    expect(styleBlockOf(legacy)).not.toContain(desc)
+    expect(legacy.indexOf(desc)).toBeLessThan(legacy.indexOf("[style]:"))
+  })
+
+  it("honors a user-overridden wrapper template while keeping the section last", () => {
+    const legacy = assembleImageInput({
+      userPrompt: "a man walks",
+      provider: "nano-banana",
+      direction: DIRECTION,
+      characterDefs: [KIRA_DEF],
+      userTemplates: { "generate-image-wrapper": "{assetDescriptions} // {userPrompt}" },
+    }).prompt
+    expect(legacy.startsWith("Include character 'Kira': auburn hair, hazel eyes. // a man walks")).toBe(true)
+    expect(styleBlockOf(legacy)).not.toContain("Kira")
+  })
+
+  it("re-derives the separator after the cap's tail cut, within the reservation", () => {
+    // The control lines are reserved BEFORE the cut and rendered AFTER it, and
+    // the cut moves the boundary they read. Both directions, one cap:
+    const cap = getMaxImagePromptChars("seedream")
+    const cut = (prompt: string) =>
+      buildImagePrompt({ prompt, provider: "seedream", style: "cinematic", negativePrompt: "blurry" }).prompt
+    const tail = `\nStyle: ${CINEMATIC}\nAvoid: blurry`
+
+    // (a) a short section, cut away entirely → the separator narrows to `\n`.
+    const shortSection = cut(`${"a man walks. ".repeat(400)}\n\n[style]:\nanime style`)
+    expect(shortSection.length).toBeLessThanOrEqual(cap)
+    expect(shortSection.endsWith(`...${tail}`)).toBe(true)
+
+    // (b) a section longer than the reservation, so the cut lands INSIDE it →
+    // the separator stays a blank line, exactly what was reserved.
+    const look = "anime style, ".repeat(24)
+    const longSection = cut(`${"x".repeat(cap - look.length - 60)}\n\n[style]:\n${look}`)
+    expect(longSection.length).toBeLessThanOrEqual(cap)
+    expect(longSection.endsWith(`...\n${tail}`)).toBe(true)
+  })
+
+  it("keeps the no-section shapes byte-identical (the append fallback)", () => {
+    const noSection = assembleImageInput({
+      userPrompt: "a man walks",
+      provider: "nano-banana",
+      connectedReferences: [LIBRARY],
+      referenceFormat: "hybrid",
+      style: "cinematic",
+      negativePrompt: "blurry",
+    }).prompt
+    expect(noSection).toBe(
+      `A man walks\n${LOCATION_PHRASE}\nStyle: ${CINEMATIC}\nAvoid: blurry`,
+    )
+  })
+})
+
+describe("video assembly — nothing lands under the `[style]` header", () => {
+  const body = composeVideoPromptText("a knight rides", DIRECTION)
+  const framed = resolveVideoReferenceCore({
+    prompt: body,
+    wiredCharRefs: [KIRA],
+    hybridRoles: true,
+  }).prompt!
+
+  it("splices the resolver's role phrase ahead of the section, which ends the prompt", () => {
+    expect(styleBlockOf(framed)).toContain("[style]:\n")
+    expect(styleBlockOf(framed)).not.toContain(CHARACTER_PHRASE)
+    expect(framed.indexOf(CHARACTER_PHRASE)).toBeLessThan(framed.indexOf("[style]:"))
+    // The look tail really is the tail: nothing follows the section.
+    expect(framed.endsWith(styleBlockOf(framed))).toBe(true)
+  })
+
+  it("closes the section with a blank line before the folded `Avoid:`", () => {
+    const withNeg = applyVideoNegativePrompt(framed, "blurry, watermark", "seedance-2").prompt!
+    expect(styleBlockOf(withNeg)).not.toContain("Avoid:")
+    expect(withNeg.endsWith("\n\nAvoid: blurry, watermark")).toBe(true)
+  })
+
+  it("keeps the sectionless `Avoid:` join byte-identical", () => {
+    const plain = applyVideoNegativePrompt("a knight rides", "blurry", "seedance-2").prompt
+    expect(plain).toBe("a knight rides\nAvoid: blurry")
+  })
+})

package/src/__tests__/subject-fold.test.ts

@@ -0,0 +1,251 @@
+/**
+ * The `subject` fold where it actually lands: `assembleImageInput` (stills) and
+ * `composeVideoPromptText` (clips).
+ *
+ * THE LOAD-BEARING TEST IN THIS FILE is the NO-SUBJECT ORACLE: with no
+ * `subject` — which is every caller in the world on the day this ships — the
+ * assembled prompt must be byte-for-byte what it was before the channel
+ * existed. That is what makes the rollout dark. The oracle is written as an
+ * independent recomputation (`joinPromptHints` over `renderDirectionHints`),
+ * not as a snapshot, so it keeps testing the claim if the catalogs change.
+ */
+import { describe, it, expect } from "vitest"
+import { assembleImageInput } from "../assemble-image-input.js"
+import { composeVideoPromptText } from "../assemble-video-input.js"
+import { buildImagePrompt } from "../prompt-builder.js"
+import { joinPromptHints, PROMPT_HINT_SEPARATOR } from "../prompt-hint-join.js"
+import { renderDirectionHints, IMAGE_HINT_MODE_DEFAULT, VIDEO_HINT_MODE_DEFAULT } from "../direction-registry.js"
+import { renderStyleSection } from "../prompt-style-section.js"
+import {
+  renderSubjectHints,
+  SUBJECT_IMAGE_HINT_MODE_DEFAULT,
+  SUBJECT_VIDEO_HINT_MODE_DEFAULT,
+} from "../subject-registry.js"
+import { getMaxImagePromptChars } from "@nodaro/shared"
+import type { ConnectedReference } from "@nodaro/shared"
+
+const DIRECTION = {
+  shotSize: "wide-shot",
+  timeOfDay: "golden-hour",
+  lens: "wide-24mm",
+  style: "anime",
+} as const
+
+const SUBJECT = {
+  type: "woman",
+  ethnicity: "east-asian",
+  hairBase: "base-short-straight",
+  makeup: "makeup-smoky",
+  animal: "dog-corgi",
+} as const
+
+const STRUCTURED = { person: { age: 34, hair: "auburn" } } as const
+
+const KIRA: ConnectedReference = {
+  id: "kira-id",
+  defaultName: "Kira",
+  source: "wired-character",
+  url: "https://r2.example/kira.png",
+  characterSlug: "kira",
+  variantSlug: undefined,
+  characterCanonicalDescription: "a young woman with copper hair",
+  variantDescription: null,
+  variantDisplayName: "canonical",
+}
+
+describe("the no-subject oracle — the fold is dark until a caller opts in", () => {
+  const cases: ReadonlyArray<{ name: string; input: Parameters<typeof assembleImageInput>[0] }> = [
+    {
+      name: "bare prompt (the exact no-op contract, untrimmed)",
+      input: { userPrompt: "  a knight on a hill  ", provider: "nano-banana" },
+    },
+    {
+      name: "direction only",
+      input: { userPrompt: "a knight on a hill", provider: "nano-banana", direction: DIRECTION },
+    },
+    {
+      name: "structured only",
+      input: { userPrompt: "a knight on a hill", provider: "nano-banana", structured: STRUCTURED },
+    },
+    {
+      name: "direction + structured + a bound reference",
+      input: {
+        userPrompt: "@kira:1 on a hill",
+        provider: "nano-banana",
+        connectedReferences: [KIRA],
+        direction: DIRECTION,
+        structured: STRUCTURED,
+      },
+    },
+  ]
+
+  for (const { name, input } of cases) {
+    it(`is unchanged by the channel's existence — ${name}`, () => {
+      const withNothing = assembleImageInput(input)
+      // An explicitly-undefined subject, an empty bag, and a bag of keys the
+      // platform does not know are all the same as not passing one.
+      expect(assembleImageInput({ ...input, subject: undefined })).toEqual(withNothing)
+      expect(assembleImageInput({ ...input, subject: {} })).toEqual(withNothing)
+      expect(assembleImageInput({ ...input, subject: { notAField: "x" } })).toEqual(withNothing)
+    })
+  }
+
+  it("returns the user's prompt VERBATIM AND UNTRIMMED with no lever at all", () => {
+    const userPrompt = "  a knight on a hill  "
+    expect(assembleImageInput({ userPrompt, provider: "nano-banana" }).prompt).toBe(userPrompt)
+  })
+
+  it("matches an independent recomputation of the direction-only fold", () => {
+    // Every image-surface direction row is `look`, so a direction-only fold
+    // adds NOTHING to the body: the prompt is trimmed (something folded) and
+    // the whole fold reads in the section.
+    const userPrompt = "a knight on a hill"
+    const expected = buildImagePrompt({
+      prompt: `${userPrompt}\n\n${renderStyleSection(DIRECTION, {
+        surface: "image",
+        mode: IMAGE_HINT_MODE_DEFAULT,
+      })}`,
+      provider: "nano-banana",
+    })
+    expect(assembleImageInput({ userPrompt, provider: "nano-banana", direction: DIRECTION })).toEqual(
+      expected,
+    )
+  })
+
+  it("leaves the video composer's no-op contract intact (undefined stays undefined)", () => {
+    expect(composeVideoPromptText(undefined, undefined)).toBeUndefined()
+    expect(composeVideoPromptText(undefined, undefined, undefined, { subject: {} })).toBeUndefined()
+    expect(
+      composeVideoPromptText(undefined, undefined, undefined, { subject: { notAField: "x" } }),
+    ).toBeUndefined()
+    expect(composeVideoPromptText("  a clip  ", undefined, undefined, { subject: {} })).toBe(
+      "  a clip  ",
+    )
+  })
+})
+
+describe("the subject fold — position and content", () => {
+  it("lands the subject clauses in the BODY, ahead of the direction section", () => {
+    const userPrompt = "on the seawall"
+    const subjectHints = renderSubjectHints(SUBJECT, {
+      surface: "image",
+      mode: SUBJECT_IMAGE_HINT_MODE_DEFAULT,
+    })
+    const directionHints = renderDirectionHints(DIRECTION, {
+      surface: "image",
+      mode: IMAGE_HINT_MODE_DEFAULT,
+    })
+    const result = assembleImageInput({
+      userPrompt,
+      provider: "nano-banana",
+      subject: SUBJECT,
+      direction: DIRECTION,
+    })
+    // The subject is the noun phrase the look modifies, so it stays inline with
+    // the prose; the direction fold lifts out behind it.
+    expect(result.prompt).toBe(
+      buildImagePrompt({
+        prompt: `${joinPromptHints(userPrompt, subjectHints)}\n\n${renderStyleSection(DIRECTION, {
+          surface: "image",
+          mode: IMAGE_HINT_MODE_DEFAULT,
+        })}`,
+        provider: "nano-banana",
+      }).prompt,
+    )
+    expect(result.prompt.indexOf(subjectHints[0]!)).toBeLessThan(
+      result.prompt.indexOf(directionHints[0]!),
+    )
+  })
+
+  it("joins person and styling as ONE clause each, not N sentence fragments", () => {
+    const result = assembleImageInput({
+      userPrompt: "on the seawall",
+      provider: "nano-banana",
+      subject: { type: "woman", ethnicity: "east-asian", makeup: "makeup-smoky" },
+    })
+    // Three catalog fragments, but only ONE sentence separator from the person
+    // clause: the person row comma-joins its own fragments.
+    const sentences = result.prompt.split(PROMPT_HINT_SEPARATOR)
+    expect(sentences).toHaveLength(3) // prose. person clause. styling clause.
+    expect(sentences[1]).toContain(", ")
+  })
+
+  it("folds the subject on the video surface, compact, in the body", () => {
+    const composed = composeVideoPromptText("she walks", DIRECTION, undefined, { subject: SUBJECT })
+    expect(composed).toBe(
+      `${joinPromptHints(
+        "she walks",
+        renderSubjectHints(SUBJECT, {
+          surface: "video",
+          mode: SUBJECT_VIDEO_HINT_MODE_DEFAULT,
+        }),
+      )}\n\n${renderStyleSection(DIRECTION, {
+        surface: "video",
+        mode: VIDEO_HINT_MODE_DEFAULT,
+      })}`,
+    )
+  })
+
+  it("honors an explicit subject verbosity override", () => {
+    const full = composeVideoPromptText("she walks", undefined, undefined, {
+      subject: SUBJECT,
+      subjectHintMode: "full",
+    })
+    const compact = composeVideoPromptText("she walks", undefined, undefined, { subject: SUBJECT })
+    expect(full).not.toBe(compact)
+    expect(full!.length).toBeGreaterThan(compact!.length)
+  })
+})
+
+describe("the subject fold — under the provider cap", () => {
+  const SEEDREAM_CAP = getMaxImagePromptChars("seedream")
+  // A broad direction fold plus a broad subject fold, on prose long enough that
+  // the three together clear the lowest cap in the catalog.
+  const BIG_DIRECTION = {
+    ...DIRECTION,
+    angle: "low-angle",
+    cameraFormat: "16mm-film",
+    isoValue: "iso-100",
+    lightingStyle: "rembrandt",
+    colorLook: "teal-orange",
+    atmosphere: ["fog"],
+    mood: ["happy", "joyful"],
+    photographer: ["annie-leibovitz"],
+    setting: "forest",
+  } as const
+  const PROSE = "She walks the seawall at dusk. " + "The waves are loud. ".repeat(90)
+
+  it("sheds the direction fold BEFORE the subject fold", () => {
+    const subjectHints = renderSubjectHints(SUBJECT, {
+      surface: "image",
+      mode: SUBJECT_IMAGE_HINT_MODE_DEFAULT,
+    })
+    const directionHints = renderDirectionHints(BIG_DIRECTION, {
+      surface: "image",
+      mode: IMAGE_HINT_MODE_DEFAULT,
+    })
+    // Non-vacuity: the un-shed fold really does overflow. Measured through a
+    // high-cap provider so the oracle is the assembler's own composition, not a
+    // hand-rebuilt approximation of it.
+    expect(
+      assembleImageInput({
+        userPrompt: PROSE,
+        provider: "nano-banana-pro",
+        subject: SUBJECT,
+        direction: BIG_DIRECTION,
+      }).prompt.length,
+    ).toBeGreaterThan(SEEDREAM_CAP)
+
+    const result = assembleImageInput({
+      userPrompt: PROSE,
+      provider: "seedream",
+      subject: SUBJECT,
+      direction: BIG_DIRECTION,
+    })
+    expect(result.prompt.length).toBeLessThanOrEqual(SEEDREAM_CAP)
+    expect(result.prompt.endsWith("...")).toBe(false)
+    // Who is in the shot outlived how it was lit.
+    expect(result.prompt).toContain(subjectHints[0])
+    expect(result.prompt).not.toContain(directionHints[directionHints.length - 1])
+  })
+})