@nodaro/prompts 1.10.0 → 1.12.0

package/src/__tests__/mention-splice-spacing.test.ts

@@ -0,0 +1,257 @@
+import { describe, it, expect } from "vitest"
+import { buildImagePrompt } from "../prompt-builder.js"
+import type { ConnectedReference } from "@nodaro/shared"
+
+/**
+ * Seam whitespace at a resolved mention (image path).
+ *
+ * A live prod payload assembled to
+ *
+ *   "the person from reference image A  and reference image C walking …"
+ *
+ * — TWO spaces after the character phrase. An editor serializes a mention chip
+ * as its token plus its own trailing space, and the prose that follows carries
+ * the space the author typed, so an ordinary sentence reaches the route as
+ * `@panda:1  and @panda2:2 …`. The VIDEO core never shows this: every return of
+ * `resolveVideoReferenceCore` runs `resolveReferenceTokens`, whose
+ * `[^\S\r\n]{2,}` collapse tidies the gap. The image path had no such tidy, so
+ * the doubled space landed in the model's prompt exactly where the reference is
+ * being described.
+ *
+ * `spliceMentionPhrase` now collapses the horizontal whitespace on either side
+ * of each splice seam — scoped to the seam, so prose the author double-spaced
+ * elsewhere is left alone and an already-single-spaced prompt is byte-identical.
+ */
+
+const panda: ConnectedReference = {
+  id: "c1", defaultName: "Panda", source: "wired-character",
+  url: "https://cdn/panda.png", characterSlug: "panda",
+}
+const panda2: ConnectedReference = {
+  id: "n2", defaultName: "Panda2", source: "wired-image", url: "https://cdn/panda2.png",
+}
+const beach: ConnectedReference = {
+  id: "l1", defaultName: "Beach", source: "wired-location",
+  url: "https://cdn/beach.png", locationSlug: "beach",
+}
+
+const REFS = [panda, panda2, beach]
+
+/** Mention URLs merge character → location → image, so the letters are
+ *  A = the character, B = the location, C = the named image. */
+const EXPECTED =
+  "the person from reference image A and reference image C walking in "
+  + "the location from reference image B at dusk"
+
+const build = (prompt: string) => buildImagePrompt({
+  prompt,
+  connectedReferences: REFS,
+  provider: "nano-banana-pro",
+  referenceFormat: "hybrid",
+}).prompt
+
+describe("mention splice — seam whitespace", () => {
+  it("Tal's shape: character + image + location in one sentence, single-spaced throughout", () => {
+    expect(build("@panda:1  and @panda2:2  walking in @beach:3  at dusk")).toBe(EXPECTED)
+  })
+
+  it("the already-single-spaced prompt is byte-identical (the collapse needs a 2+ run)", () => {
+    expect(build("@panda:1 and @panda2:2 walking in @beach:3 at dusk")).toBe(EXPECTED)
+  })
+
+  it("collapses on the LEADING side of a seam too", () => {
+    expect(build("@panda:1 and  @panda2:2 walking in  @beach:3 at dusk")).toBe(EXPECTED)
+  })
+
+  it("never emits a doubled space, whichever side of the chip carries it", () => {
+    for (const prompt of [
+      "@panda:1  and @panda2:2 walking in @beach:3 at dusk",
+      "@panda:1 and  @panda2:2 walking in @beach:3 at dusk",
+      "@panda:1   and   @panda2:2   walking in   @beach:3   at dusk",
+    ]) {
+      expect(build(prompt)).toBe(EXPECTED)
+    }
+  })
+
+  it("leaves a doubled space the author put in their own prose alone (seam-scoped, not a body tidy)", () => {
+    expect(build("@panda:1 walks  slowly past @beach:3")).toBe(
+      "the person from reference image A walks  slowly past the location from reference image B",
+    )
+  })
+
+  it("preserves newlines — the collapse class is horizontal-only", () => {
+    expect(build("@panda:1  runs\n\n@beach:3  at dusk")).toBe(
+      "the person from reference image A runs\n\nthe location from reference image B at dusk",
+    )
+  })
+})
+
+// The `{image:N:label}` positional pill is a mention chip like any other:
+// `buildRefPillNodes` appends its own trailing space to EVERY pill it builds,
+// the positional `imageRef` node included. Its hybrid expansion used a raw
+// `.replace`, so the same doubled space survived on this path after the three
+// `@`-mention resolvers were fixed.
+describe("mention splice — the {image:N:label} positional pill", () => {
+  const hat: ConnectedReference = {
+    id: "n1", defaultName: "Hat", source: "wired-image", url: "https://cdn/hat.png",
+  }
+  const coat: ConnectedReference = {
+    id: "n2", defaultName: "Coat", source: "wired-image", url: "https://cdn/coat.png",
+  }
+  const buildTokens = (prompt: string, refs: readonly ConnectedReference[]) => buildImagePrompt({
+    prompt,
+    connectedReferences: [...refs],
+    referenceImageUrls: refs.map((r) => r.url!),
+    provider: "nano-banana-pro",
+    referenceFormat: "hybrid",
+  }).prompt
+
+  it("collapses the trailing seam the pill's own space creates", () => {
+    expect(buildTokens("a man wearing {image:1:hat}  in the park", [hat])).toBe(
+      "A man wearing the hat from reference image A in the park",
+    )
+  })
+
+  it("the already-single-spaced prompt is byte-identical", () => {
+    expect(buildTokens("a man wearing {image:1:hat} in the park", [hat])).toBe(
+      "A man wearing the hat from reference image A in the park",
+    )
+  })
+
+  it("two pills in one sentence both splice cleanly (right-to-left offsets stay valid)", () => {
+    expect(buildTokens("a man wearing {image:1:hat}  and  {image:2:coat}  walks", [hat, coat])).toBe(
+      "A man wearing the hat from reference image A and the coat from reference image B walks",
+    )
+  })
+
+  it("leaves a doubled space the author put in their own prose alone", () => {
+    expect(buildTokens("{image:1:hat} worn  loosely", [hat])).toBe(
+      "The hat from reference image A worn  loosely",
+    )
+  })
+
+  it("an out-of-range token stays visible, and its whitespace with it", () => {
+    expect(buildTokens("a man wearing {image:7:hat}  in the park", [hat])).toContain(
+      "{image:7:hat}  in the park",
+    )
+  })
+})
+
+// Indentation is structure, not a seam. A run that OPENS a line is the author's
+// layout (a shot list, a numbered beat sheet), so the leading collapse is
+// anchored to prose on the same line via `(?<=\S)`. Without that anchor a
+// mention starting an indented line flattened the indent to a single space —
+// the same class of damage as merging paragraphs, and it would have made the
+// "an already-single-spaced prompt is byte-identical" claim false for every
+// multi-line prompt.
+describe("mention splice — line-initial indentation survives", () => {
+  /** One character ref only, so no unmentioned ref appends a canonical phrase
+   *  and the assertions can be byte-exact on the multi-line shape. */
+  const buildOne = (prompt: string) => buildImagePrompt({
+    prompt,
+    connectedReferences: [panda],
+    provider: "nano-banana-pro",
+    referenceFormat: "hybrid",
+  }).prompt
+
+  it("a mention that opens an indented line keeps the indent verbatim", () => {
+    expect(buildOne("Scene:\n    @panda:1 stands")).toBe(
+      "Scene:\n    the person from reference image A stands",
+    )
+  })
+
+  it("indent preserved AND the trailing seam still collapses on the same mention", () => {
+    expect(buildOne("Scene:\n  @panda:1  stands")).toBe(
+      "Scene:\n  the person from reference image A stands",
+    )
+  })
+
+  it("a leading run at the very start of the prompt is indentation too", () => {
+    expect(buildOne("   @panda:1  stands")).toBe(
+      "   the person from reference image A stands",
+    )
+  })
+
+  it("mid-line prose before the run still collapses (the anchor is `\\S`, not `^`)", () => {
+    expect(buildOne("Scene:\n    a man and  @panda:1 stands")).toBe(
+      "Scene:\n    a man and the person from reference image A stands",
+    )
+  })
+})
+
+// Wired CREATURE / OBJECT mentions (`@<name-slug>:<index>[:<role>]`) are chips
+// too — `buildRefPillNodes` gives them the same trailing space every other pill
+// gets — so their resolver splices through `spliceMentionPhrase` alongside the
+// character, location and named-image ones. Without that, the seam bug would
+// have been fixed for three mention kinds and reintroduced by the fourth.
+describe("mention splice — wired creature / object mentions", () => {
+  const nessie: ConnectedReference = {
+    id: "cr1", defaultName: "Nessie", source: "wired-creature", url: "https://cdn/nessie.png",
+  }
+  const chair: ConnectedReference = {
+    id: "ob1", defaultName: "Chair", source: "wired-object", url: "https://cdn/chair.png",
+  }
+
+  /** BOTH entities are mentioned in every case, so neither appends a trailing
+   *  canonical phrase and the assertions stay byte-exact on one line. */
+  const buildEntities = (prompt: string) => buildImagePrompt({
+    prompt,
+    connectedReferences: [nessie, chair],
+    provider: "nano-banana-pro",
+    referenceFormat: "hybrid",
+  }).prompt
+
+  const ENTITIES_EXPECTED =
+    "the creature from reference image A looms over "
+    + "the object from reference image B in the fog"
+
+  it("collapses the seam whitespace the chips' own trailing spaces create", () => {
+    expect(buildEntities("@nessie:1  looms over @chair:2  in the fog")).toBe(ENTITIES_EXPECTED)
+  })
+
+  it("the already-single-spaced prompt is byte-identical (the collapse needs a 2+ run)", () => {
+    expect(buildEntities("@nessie:1 looms over @chair:2 in the fog")).toBe(ENTITIES_EXPECTED)
+  })
+
+  it("collapses on the LEADING side of an entity seam too", () => {
+    expect(buildEntities("@nessie:1 looms over  @chair:2 in the fog")).toBe(ENTITIES_EXPECTED)
+  })
+
+  it("never emits a doubled space, whichever side of the chip carries it", () => {
+    for (const prompt of [
+      "@nessie:1  looms over @chair:2 in the fog",
+      "@nessie:1 looms over  @chair:2 in the fog",
+      "@nessie:1   looms over   @chair:2   in the fog",
+    ]) {
+      expect(buildEntities(prompt)).toBe(ENTITIES_EXPECTED)
+    }
+  })
+
+  it("a ROLE segment splices the same way", () => {
+    expect(buildEntities("@nessie:1:markings  over @chair:2:material  in the fog")).toBe(
+      "the markings from reference image A over "
+      + "the material from reference image B in the fog",
+    )
+  })
+
+  it("leaves a doubled space the author put in their own prose alone (seam-scoped)", () => {
+    expect(buildEntities("@nessie:1 looms  slowly over @chair:2 in the fog")).toBe(
+      "the creature from reference image A looms  slowly over "
+      + "the object from reference image B in the fog",
+    )
+  })
+
+  it("preserves newlines — the collapse class is horizontal-only", () => {
+    expect(buildEntities("@nessie:1  looms\n\n@chair:2  in the fog")).toBe(
+      "the creature from reference image A looms\n\n"
+      + "the object from reference image B in the fog",
+    )
+  })
+
+  it("an entity mention that opens an indented line keeps the indent verbatim", () => {
+    expect(buildEntities("Scene:\n    @nessie:1  looms over @chair:2 in the fog")).toBe(
+      "Scene:\n    the creature from reference image A looms over "
+      + "the object from reference image B in the fog",
+    )
+  })
+})

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

@@ -0,0 +1,154 @@
+import { describe, it, expect } from "vitest"
+import { readDirectionFields, readStructuredFields } from "../read-node-direction.js"
+import {
+  DIRECTION_ARRAY_CEILING,
+  DIRECTION_KEYS,
+  renderDirectionHints,
+} from "../direction-registry.js"
+
+/**
+ * The narrow readers are the ONLY thing standing between untrusted persisted
+ * node JSONB (`workflows.nodes` — import, MCP write, node preset, a
+ * Studio-emitted graph) and the prompt text a model sees. These cases pin the
+ * VALUE SHAPE contract; the accepted KEY SET is not pinned here on purpose —
+ * it is derived from `DIRECTION_FIELDS`, whose order + membership are pinned by
+ * `direction-registry.test.ts`. A hand list here would be exactly the
+ * "remember to update the list" the registry walk removes.
+ */
+describe("readDirectionFields", () => {
+  it("rejects non-object roots", () => {
+    expect(readDirectionFields(undefined)).toBeUndefined()
+    expect(readDirectionFields(null)).toBeUndefined()
+    expect(readDirectionFields("shotSize")).toBeUndefined()
+    expect(readDirectionFields(42)).toBeUndefined()
+    expect(readDirectionFields([])).toBeUndefined()
+    expect(readDirectionFields([{ shotSize: "medium-shot" }])).toBeUndefined()
+  })
+
+  it("returns undefined, never {}, when nothing survives", () => {
+    // Load-bearing: `{}` is a DEFINED direction, which would flip the call
+    // sites' `...(x !== undefined ? { x } : {})` spread on and take the join
+    // branch instead of the exact no-op branch.
+    expect(readDirectionFields({})).toBeUndefined()
+    expect(readDirectionFields({ shotSize: "" })).toBeUndefined()
+    expect(readDirectionFields({ mood: [] })).toBeUndefined()
+    expect(readDirectionFields({ mood: ["", 5, null] })).toBeUndefined()
+    expect(readDirectionFields({ nothing: "here" })).toBeUndefined()
+  })
+
+  it("keeps a registry key and drops everything unrecognised", () => {
+    expect(readDirectionFields({ shotSize: "medium-shot", bogus: "x" })).toEqual({
+      shotSize: "medium-shot",
+    })
+  })
+
+  it("accepts an array on any key and filters junk entries out of it", () => {
+    expect(readDirectionFields({ mood: ["serene", "", 5, null, "tense"] })).toEqual({
+      mood: ["serene", "tense"],
+    })
+    // An array on a single-pick key is legal at the reader; the per-dimension
+    // cap is the renderer's slice, never a drop here.
+    expect(readDirectionFields({ style: ["anime", "cinematic"] })).toEqual({
+      style: ["anime", "cinematic"],
+    })
+  })
+
+  it("drops non-string / over-length ids", () => {
+    expect(readDirectionFields({ shotSize: 123, style: "anime" })).toEqual({ style: "anime" })
+    expect(readDirectionFields({ shotSize: { id: "medium-shot" } })).toBeUndefined()
+    const overLong = "x".repeat(101)
+    expect(readDirectionFields({ shotSize: overLong })).toBeUndefined()
+    expect(readDirectionFields({ shotSize: "x".repeat(100) })).toEqual({
+      shotSize: "x".repeat(100),
+    })
+    expect(readDirectionFields({ mood: [overLong, "serene"] })).toEqual({ mood: ["serene"] })
+  })
+
+  it("caps an array at the wire ceiling, filtering junk BEFORE the cap", () => {
+    // Cardinality is bounded, not just per-id length: node data is validated
+    // only as `z.record(z.string(), z.unknown())` on write, so an unbounded
+    // array would otherwise reach `renderDirectionHints`' includes-dedupe.
+    const many = Array.from({ length: DIRECTION_ARRAY_CEILING + 20 }, (_, i) => `id-${i}`)
+    expect(readDirectionFields({ mood: many })).toEqual({
+      mood: many.slice(0, DIRECTION_ARRAY_CEILING),
+    })
+    // Junk entries must not consume the budget: 8 unusable entries in front of
+    // the real ids still leaves a full ceiling of real ids.
+    const junk = [...Array.from({ length: DIRECTION_ARRAY_CEILING }, () => ""), ...many]
+    expect(readDirectionFields({ mood: junk })).toEqual({
+      mood: many.slice(0, DIRECTION_ARRAY_CEILING),
+    })
+  })
+
+  it("bounds the work a stored blob can force on the renderer", () => {
+    // Pre-fix this pair was quadratic in the stored array's length (the dedupe
+    // scan ran over the FULL array before the per-row slice), so a node any
+    // authenticated user can persist blocked the event loop for seconds in the
+    // orchestrator and in the user's tab. No timing assertion — the default
+    // vitest timeout is the guard.
+    const huge = Array.from({ length: 200_000 }, (_, i) => `id-${i}`)
+    const direction = readDirectionFields({ mood: huge, lightingStyle: huge })
+    expect(direction?.mood).toHaveLength(DIRECTION_ARRAY_CEILING)
+    expect(() => renderDirectionHints(direction, { surface: "image" })).not.toThrow()
+  })
+
+  it("honors every registry key by construction (a new dimension needs no edit here)", () => {
+    const everyKey = Object.fromEntries(DIRECTION_KEYS.map((k) => [k, "some-id"]))
+    expect(Object.keys(readDirectionFields(everyKey) ?? {}).sort()).toEqual(
+      [...DIRECTION_KEYS].sort(),
+    )
+  })
+})
+
+describe("readStructuredFields", () => {
+  it("rejects non-object roots and returns undefined when nothing survives", () => {
+    expect(readStructuredFields(undefined)).toBeUndefined()
+    expect(readStructuredFields(null)).toBeUndefined()
+    expect(readStructuredFields("person")).toBeUndefined()
+    expect(readStructuredFields([])).toBeUndefined()
+    expect(readStructuredFields({})).toBeUndefined()
+    expect(readStructuredFields({ person: "hello" })).toBeUndefined()
+    expect(readStructuredFields({ person: {}, styling: [] })).toBeUndefined()
+    expect(readStructuredFields({ nothing: "here" })).toBeUndefined()
+  })
+
+  it("drops junk field values instead of rendering them verbatim", () => {
+    // `renderStructuredFields` never throws on junk but DOES render it —
+    // `person: { age: "drop table" }` would become "Subject: drop table years
+    // old." inside `jobs.input_data.prompt`. The field table is what blocks it.
+    expect(readStructuredFields({ person: { age: "drop table" } })).toBeUndefined()
+    expect(readStructuredFields({ person: { age: Number.NaN } })).toBeUndefined()
+    expect(readStructuredFields({ person: { gender: "robot" } })).toBeUndefined()
+    expect(readStructuredFields({ person: { hair: 7 } })).toBeUndefined()
+    expect(readStructuredFields({ person: { hair: "x".repeat(201) } })).toBeUndefined()
+    expect(readStructuredFields({ person: { age: 34, bogus: "x" } })).toEqual({
+      person: { age: 34 },
+    })
+  })
+
+  it("round-trips every group plus the mood shorthand", () => {
+    const full = {
+      person: {
+        age: 34,
+        gender: "woman",
+        hair: "auburn",
+        eyes: "green",
+        expression: "wry",
+        profession: "archivist",
+        warriorType: "ranger",
+      },
+      styling: { mood: "brooding", lighting: "soft", aesthetic: "noir", colorLook: "teal" },
+      setting: { era: "1970s", atmosphere: "humid", backdrop: "a rain-slick street" },
+      camera: { framing: "medium", motion: "slow push", format: "35mm" },
+      lens: { focalLength: "85mm", aperture: "1.4" },
+      mood: "brooding",
+    }
+    expect(readStructuredFields(full)).toEqual(full)
+  })
+
+  it("keeps the surviving fields of a partially-junk group", () => {
+    expect(
+      readStructuredFields({ person: { age: 34, gender: "robot" }, styling: "nope" }),
+    ).toEqual({ person: { age: 34 } })
+  })
+})

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`])
+  })
+})