@nodaro/shared 1.4.2

package/src/__tests__/node-refs-canonical.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from "vitest"
+import {
+  resolveNodeRefs,
+  extractReferencedLabels,
+  combineSameLabelRefs,
+  canonicalVarName,
+} from "../node-refs.js"
+
+// Node-name variables are CASE-INSENSITIVE with lowercase as canonical: nodes
+// labeled TEXt / TEXT / text all feed ONE {text} variable, and {TEXT}/{Text}/
+// {text} in a prompt all resolve to it.
+describe("case-insensitive node variables (canonicalVarName)", () => {
+  it("canonicalVarName trims + lowercases", () => {
+    expect(canonicalVarName("  TEXt ")).toBe("text")
+    expect(canonicalVarName("TEXT")).toBe("text")
+    expect(canonicalVarName("text")).toBe("text")
+  })
+
+  it("resolveNodeRefs resolves {TEXT}/{Text}/{text} against a canonical-keyed map", () => {
+    const map = new Map([["text", "a cat"]])
+    expect(resolveNodeRefs("{TEXT}", map)).toBe("a cat")
+    expect(resolveNodeRefs("{Text}", map)).toBe("a cat")
+    expect(resolveNodeRefs("{text}", map)).toBe("a cat")
+  })
+
+  it("resolveNodeRefs still honors an exact-cased map first (condition-variables)", () => {
+    // Original-cased maps (e.g. selector/filter condition variables) keep working.
+    const map = new Map([["MyVar", "v"]])
+    expect(resolveNodeRefs("{MyVar}", map)).toBe("v")
+  })
+
+  it("extractReferencedLabels returns canonical (lowercase) names", () => {
+    const refs = extractReferencedLabels("a {TEXt} and {FOO}")
+    expect(refs.has("text")).toBe(true)
+    expect(refs.has("foo")).toBe(true)
+    expect(refs.has("TEXt")).toBe(false)
+  })
+
+  it("combineSameLabelRefs collapses TEXt/TEXT/text into one canonical {text}", () => {
+    const combined = combineSameLabelRefs([
+      { label: "TEXt", output: "p", category: 0 }, // prompt handle
+      { label: "TEXT", output: "e", category: 1 }, // elements handle
+      { label: "text", output: "l", category: 2 }, // look handle
+    ])
+    expect([...combined.keys()]).toEqual(["text"])
+    expect(combined.get("text")).toBe("p, e, l") // prompt → elements → look
+  })
+
+  it("reserved template vars stay case-sensitive (left literal, not canonicalized)", () => {
+    const map = new Map([["userprompt", "x"]])
+    // {userPrompt} is reserved → untouched, NOT resolved to the `userprompt` entry.
+    expect(resolveNodeRefs("{userPrompt}", map)).toBe("{userPrompt}")
+  })
+})

package/src/__tests__/node-refs-combine.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from "vitest"
+import { extractReferencedLabels, combineSameLabelRefs, refHandleCategory } from "../node-refs.js"
+
+describe("extractReferencedLabels", () => {
+  it("collects {label} names across texts, strips ||fallback, skips reserved/image/empty", () => {
+    const s = extractReferencedLabels(
+      "a {Hero} in {City || town}",
+      "no {Hero} {userPrompt} {image:1:subject} {}",
+    )
+    expect([...s].sort()).toEqual(["city", "hero"]) // canonical (lowercase), fallback stripped, dedup, no reserved/image/empty
+  })
+  it("ignores undefined / null / empty inputs", () => {
+    expect(extractReferencedLabels(undefined, "", null).size).toBe(0)
+  })
+})
+
+describe("refHandleCategory", () => {
+  it("orders prompt(0) < elements(1) < look family(2); others -1", () => {
+    expect(refHandleCategory("prompt")).toBe(0)
+    expect(refHandleCategory("elements")).toBe(1)
+    expect(refHandleCategory("look")).toBe(2)
+    expect(refHandleCategory("cinematography")).toBe(2)
+    expect(refHandleCategory("style")).toBe(2)
+    expect(refHandleCategory("image")).toBe(-1)
+    expect(refHandleCategory(null)).toBe(-1)
+  })
+})
+
+describe("combineSameLabelRefs", () => {
+  it("merges ≥2 same-label candidates ordered prompt→elements→look (input order ignored)", () => {
+    const m = combineSameLabelRefs([
+      { label: "X", output: "lookVal", category: 2 },
+      { label: "X", output: "promptVal", category: 0 },
+      { label: "X", output: "elemVal", category: 1 },
+      { label: "Y", output: "solo", category: 1 }, // single → not combined
+    ])
+    expect(m.get("x")).toBe("promptVal, elemVal, lookVal") // canonical key
+    expect(m.has("y")).toBe(false)
+  })
+  it("preserves edge order within a category (stable)", () => {
+    const m = combineSameLabelRefs([
+      { label: "X", output: "elem1", category: 1 },
+      { label: "X", output: "elem2", category: 1 },
+    ])
+    expect(m.get("x")).toBe("elem1, elem2")
+  })
+  it("never combines non-combinable handles (category -1)", () => {
+    const m = combineSameLabelRefs([
+      { label: "X", output: "a", category: -1 },
+      { label: "X", output: "b", category: -1 },
+    ])
+    expect(m.has("x")).toBe(false)
+  })
+})

package/src/__tests__/node-refs.test.ts

@@ -0,0 +1,187 @@
+import {
+  NODE_REF_PATTERN,
+  resolveNodeRefs,
+  parseNodeRef,
+  REFERENCE_HANDLE_MAP,
+  referenceModalityForHandle,
+} from "../node-refs.js"
+
+// ---------------------------------------------------------------------------
+// NODE_REF_PATTERN
+// ---------------------------------------------------------------------------
+describe("NODE_REF_PATTERN", () => {
+  it("matches {text} references", () => {
+    const matches = Array.from("hello {World} foo".matchAll(NODE_REF_PATTERN))
+    expect(matches).toHaveLength(1)
+    expect(matches[0][1]).toBe("World")
+  })
+
+  it("matches multiple refs in one string", () => {
+    const matches = Array.from("{A} and {B}".matchAll(NODE_REF_PATTERN))
+    expect(matches).toHaveLength(2)
+    expect(matches[0][1]).toBe("A")
+    expect(matches[1][1]).toBe("B")
+  })
+
+  it("does not match empty braces {}", () => {
+    const matches = Array.from("{}".matchAll(NODE_REF_PATTERN))
+    expect(matches).toHaveLength(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// resolveNodeRefs
+// ---------------------------------------------------------------------------
+describe("resolveNodeRefs", () => {
+  it("resolves a simple ref", () => {
+    const map = new Map([["My Node", "hello"]])
+    expect(resolveNodeRefs("{My Node}", map)).toBe("hello")
+  })
+
+  it("resolves multiple refs", () => {
+    const map = new Map([
+      ["A", "alpha"],
+      ["B", "beta"],
+    ])
+    expect(resolveNodeRefs("{A} and {B}", map)).toBe("alpha and beta")
+  })
+
+  it("does not replace reserved variables", () => {
+    const reserved = ["name", "description", "userPrompt", "assetDescriptions", "outputCount"]
+    const map = new Map(reserved.map((v) => [v, "REPLACED"]))
+    for (const v of reserved) {
+      expect(resolveNodeRefs(`{${v}}`, map)).toBe(`{${v}}`)
+    }
+  })
+
+  it("leaves missing refs unchanged", () => {
+    const map = new Map([["Known", "yes"]])
+    expect(resolveNodeRefs("{Unknown}", map)).toBe("{Unknown}")
+  })
+
+  it("resolves nested refs across passes", () => {
+    const map = new Map([
+      ["A", "{B}"],
+      ["B", "final"],
+    ])
+    expect(resolveNodeRefs("{A}", map)).toBe("final")
+  })
+
+  it("stops after max 10 passes on circular refs", () => {
+    const map = new Map([
+      ["A", "{B}"],
+      ["B", "{A}"],
+    ])
+    // Circular: A -> B -> A -> B -> ... stops after 10 iterations
+    const result = resolveNodeRefs("{A}", map)
+    // After 10 passes the result will alternate between {A} and {B}.
+    // The important thing is it terminates and returns one of those.
+    expect(["{A}", "{B}"]).toContain(result)
+  })
+
+  it("trims whitespace in labels", () => {
+    const map = new Map([["My Node", "trimmed"]])
+    expect(resolveNodeRefs("{ My Node }", map)).toBe("trimmed")
+  })
+
+  it("returns text unchanged with an empty map", () => {
+    const map = new Map<string, string>()
+    expect(resolveNodeRefs("{Anything}", map)).toBe("{Anything}")
+  })
+
+  it("returns text unchanged when there are no refs", () => {
+    const map = new Map([["A", "alpha"]])
+    expect(resolveNodeRefs("no refs here", map)).toBe("no refs here")
+  })
+})
+
+// ---------------------------------------------------------------------------
+// parseNodeRef
+// ---------------------------------------------------------------------------
+describe("parseNodeRef", () => {
+  it("splits on the first || and trims both sides", () => {
+    expect(parseNodeRef("person || man")).toEqual({ name: "person", fallback: "man" })
+    expect(parseNodeRef("person||man")).toEqual({ name: "person", fallback: "man" })
+    expect(parseNodeRef("person     || ")).toEqual({ name: "person", fallback: "" })
+    expect(parseNodeRef("p || a || b")).toEqual({ name: "p", fallback: "a || b" })
+  })
+  it("returns null fallback when there is no ||", () => {
+    expect(parseNodeRef("person")).toEqual({ name: "person", fallback: null })
+    expect(parseNodeRef("p|man")).toEqual({ name: "p|man", fallback: null }) // single pipe is literal
+  })
+  it("handles a degenerate empty name", () => {
+    expect(parseNodeRef("|| man")).toEqual({ name: "", fallback: "man" })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// resolveNodeRefs — {name || default} fallback
+// ---------------------------------------------------------------------------
+describe("resolveNodeRefs with fallback", () => {
+  it("uses the connected node output over the fallback", () => {
+    expect(resolveNodeRefs("a {person || man} b", new Map([["person", "dog"]]))).toBe("a dog b")
+  })
+  it("uses the fallback when the node is absent", () => {
+    expect(resolveNodeRefs("a {person || man} b", new Map())).toBe("a man b")
+  })
+  it("falls back to empty for {person || } when absent (fallback !== null, not truthiness)", () => {
+    expect(resolveNodeRefs("a {person || } b", new Map())).toBe("a  b")
+  })
+  it("falls back when the connected node output is empty (maps drop empty → absent)", () => {
+    // Empty outputs are never inserted into the label→output map, so an empty-but-connected
+    // node is indistinguishable from absent and the fallback fires.
+    expect(resolveNodeRefs("a {person || man} b", new Map())).toBe("a man b")
+  })
+  it("leaves {name} literal when absent and there is no ||", () => {
+    expect(resolveNodeRefs("a {person} b", new Map())).toBe("a {person} b")
+  })
+  it("leaves a reserved var with a fallback untouched", () => {
+    expect(resolveNodeRefs("{name || x}", new Map())).toBe("{name || x}")
+  })
+})
+
+// ---------------------------------------------------------------------------
+// REFERENCE_HANDLE_MAP / referenceModalityForHandle
+//
+// SINGLE SOURCE OF TRUTH for reference-handle aliases. Both the legacy single-
+// name ids and the canonical Generate Video ids must resolve to the same
+// modality so positional `{image:N}` / `{video:N}` / `{audio:N}` token counts
+// cover every handle the editor can produce.
+// ---------------------------------------------------------------------------
+describe("REFERENCE_HANDLE_MAP", () => {
+  it("maps both legacy and canonical handle families to the same resolved-input keys", () => {
+    expect(REFERENCE_HANDLE_MAP).toEqual({
+      references: "referenceImageUrls",
+      "reference-videos": "referenceVideoUrls",
+      "reference-audio": "referenceAudioUrls",
+      imageReferences: "referenceImageUrls",
+      videoReferences: "referenceVideoUrls",
+      audioReferences: "referenceAudioUrls",
+    })
+  })
+})
+
+describe("referenceModalityForHandle", () => {
+  it("resolves all 6 reference handles to their modality (legacy + canonical aliases)", () => {
+    // Legacy / i2v single-name ids
+    expect(referenceModalityForHandle("references")).toBe("image")
+    expect(referenceModalityForHandle("reference-videos")).toBe("video")
+    expect(referenceModalityForHandle("reference-audio")).toBe("audio")
+    // Canonical Generate Video ids — the alias that was silently uncounted
+    expect(referenceModalityForHandle("imageReferences")).toBe("image")
+    expect(referenceModalityForHandle("videoReferences")).toBe("video")
+    expect(referenceModalityForHandle("audioReferences")).toBe("audio")
+  })
+
+  it("returns null for a non-reference handle", () => {
+    expect(referenceModalityForHandle("prompt")).toBeNull()
+    expect(referenceModalityForHandle("startFrame")).toBeNull()
+    expect(referenceModalityForHandle("audio")).toBeNull() // single-image-frame audio handle, NOT a ref array
+    expect(referenceModalityForHandle("")).toBeNull()
+  })
+
+  it("returns null for null / undefined", () => {
+    expect(referenceModalityForHandle(null)).toBeNull()
+    expect(referenceModalityForHandle(undefined)).toBeNull()
+  })
+})

package/src/__tests__/node-runtime-keys.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect } from "vitest"
+import {
+  EXECUTION_DATA_KEYS,
+  TRANSIENT_RUNTIME_KEYS,
+  stripTransientRuntimeData,
+} from "../index.js"
+
+/**
+ * TRANSIENT_RUNTIME_KEYS = run-state that must neither mark the workflow
+ * dirty nor be persisted in the save payload (the phantom-dirty →
+ * spurious-save → false "changed in another tab" → frozen-autosave chain).
+ * Results (generatedResults, URLs, lora outputs, errorMessage) stay
+ * persisted — users expect them after reload.
+ */
+describe("TRANSIENT_RUNTIME_KEYS", () => {
+  it("is a strict subset of EXECUTION_DATA_KEYS (undo skip ⊇ dirty skip)", () => {
+    for (const key of TRANSIENT_RUNTIME_KEYS) {
+      expect(EXECUTION_DATA_KEYS.has(key), `${key} missing from EXECUTION_DATA_KEYS`).toBe(true)
+    }
+    expect(TRANSIENT_RUNTIME_KEYS.size).toBeLessThan(EXECUTION_DATA_KEYS.size)
+  })
+
+  it("covers the per-tick run-state keys", () => {
+    for (const key of [
+      "executionStatus",
+      "currentJobId",
+      "currentJobProgress",
+      "isStreaming",
+      "subWorkflowProgress",
+      "__listTotal",
+      "__listCompleted",
+      "__listRunning",
+      "_upstreamRefresh",
+      "__upstreamCount",
+    ]) {
+      expect(TRANSIENT_RUNTIME_KEYS.has(key), `${key} should be transient`).toBe(true)
+    }
+  })
+
+  it("NEVER includes persisted results or user-visible outcomes", () => {
+    for (const key of [
+      "generatedResults",
+      "generatedImageUrl",
+      "generatedVideoUrl",
+      "generatedText",
+      "activeResultIndex",
+      "errorMessage",
+      "loraTriggerWord",
+      "loraReplicateVersion",
+      "loraTrainingStatus",
+      "lastInputs",
+      "shots",
+      "result",
+      "zoom",
+    ]) {
+      expect(TRANSIENT_RUNTIME_KEYS.has(key), `${key} must stay persisted`).toBe(false)
+    }
+  })
+})
+
+describe("stripTransientRuntimeData", () => {
+  it("removes transient keys, keeps results, does not mutate input", () => {
+    const nodes = [
+      {
+        id: "n1",
+        type: "generate-image",
+        data: {
+          label: "Img",
+          prompt: "a cat",
+          executionStatus: "running",
+          currentJobId: "job-1",
+          currentJobProgress: 42,
+          generatedResults: [{ url: "https://r2/x.png" }],
+          errorMessage: "boom",
+        },
+      },
+    ]
+    const out = stripTransientRuntimeData(nodes)
+    expect(out[0]!.data).toEqual({
+      label: "Img",
+      prompt: "a cat",
+      generatedResults: [{ url: "https://r2/x.png" }],
+      errorMessage: "boom",
+    })
+    // input untouched (pure)
+    expect((nodes[0]!.data as Record<string, unknown>).executionStatus).toBe("running")
+    // node identity fields preserved
+    expect(out[0]!.id).toBe("n1")
+    expect(out[0]!.type).toBe("generate-image")
+  })
+
+  it("passes through nodes without data and avoids copying when nothing is transient", () => {
+    const bare = { id: "n2" } as { id: string; data?: Record<string, unknown> }
+    const clean = { id: "n3", data: { label: "T", prompt: "p" } }
+    const out = stripTransientRuntimeData([bare, clean])
+    expect(out[0]).toBe(bare)
+    expect(out[1]).toBe(clean) // no transient keys → same reference is fine
+  })
+})

package/src/__tests__/object-aspect-defaults.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest"
+import {
+  OBJECT_ASPECT_OPTIONS,
+  OBJECT_ASPECT_DEFAULTS,
+  isObjectAspectRatio,
+  resolveObjectAspectRatio,
+} from "../object-aspect-defaults.js"
+
+describe("object-aspect-defaults", () => {
+  describe("OBJECT_ASPECT_DEFAULTS", () => {
+    it("defaults every asset type to 1:1", () => {
+      for (const ratio of Object.values(OBJECT_ASPECT_DEFAULTS)) {
+        expect(ratio).toBe("1:1")
+      }
+    })
+
+    it("covers all 5 asset types", () => {
+      const keys = Object.keys(OBJECT_ASPECT_DEFAULTS).sort()
+      expect(keys).toEqual(["angles", "custom", "materials", "motion", "variations"])
+    })
+  })
+
+  describe("isObjectAspectRatio", () => {
+    it.each(OBJECT_ASPECT_OPTIONS)("accepts %s", (ratio) => {
+      expect(isObjectAspectRatio(ratio)).toBe(true)
+    })
+
+    it("rejects unknown strings", () => {
+      expect(isObjectAspectRatio("garbage")).toBe(false)
+      expect(isObjectAspectRatio("")).toBe(false)
+    })
+  })
+
+  describe("resolveObjectAspectRatio", () => {
+    it("explicit wins over everything else", () => {
+      expect(
+        resolveObjectAspectRatio({ explicit: "16:9", nodeOverride: "9:16", assetType: "angles" }),
+      ).toBe("16:9")
+    })
+
+    it("nodeOverride beats per-asset-type default", () => {
+      expect(
+        resolveObjectAspectRatio({ explicit: null, nodeOverride: "3:4", assetType: "motion" }),
+      ).toBe("3:4")
+    })
+
+    it("falls through to per-asset-type default when both soft inputs are null/garbage", () => {
+      expect(
+        resolveObjectAspectRatio({ explicit: "garbage", nodeOverride: null, assetType: "materials" }),
+      ).toBe("1:1")
+    })
+
+    it("ignores a stale nodeOverride that's not in the options enum", () => {
+      expect(
+        resolveObjectAspectRatio({ explicit: null, nodeOverride: "21:9", assetType: "angles" }),
+      ).toBe("1:1")
+    })
+  })
+})

package/src/__tests__/parameter-node-value.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect } from "vitest"
+import {
+  PARAMETER_NODE_TYPES,
+  getParameterValue,
+} from "../parameter-node-value.js"
+
+describe("PARAMETER_NODE_TYPES", () => {
+  it("includes the existing parameter node types", () => {
+    expect(PARAMETER_NODE_TYPES.has("framing")).toBe(true)
+    expect(PARAMETER_NODE_TYPES.has("camera-motion")).toBe(true)
+    expect(PARAMETER_NODE_TYPES.has("motion")).toBe(true)
+    expect(PARAMETER_NODE_TYPES.has("tone")).toBe(true)
+    expect(PARAMETER_NODE_TYPES.has("aspect-ratio")).toBe(true)
+    expect(PARAMETER_NODE_TYPES.has("scene-count")).toBe(true)
+    expect(PARAMETER_NODE_TYPES.has("duration")).toBe(true)
+    expect(PARAMETER_NODE_TYPES.has("style-guide")).toBe(true)
+  })
+  it("does not include executable node types", () => {
+    expect(PARAMETER_NODE_TYPES.has("image-to-video")).toBe(false)
+    expect(PARAMETER_NODE_TYPES.has("generate-image")).toBe(false)
+  })
+})
+
+describe("getParameterValue", () => {
+  it("returns first set per-category framing id for framing nodes (multi-category)", () => {
+    expect(getParameterValue({ shotSize: "close-up" }, "framing")).toBe("close-up")
+    // Falls through to next category when shotSize is unset
+    expect(getParameterValue({ angle: "low-angle" }, "framing")).toBe("low-angle")
+    expect(getParameterValue({ vantage: "front-on" }, "framing")).toBe("front-on")
+  })
+  it("returns cameraMotion id for camera-motion nodes", () => {
+    expect(getParameterValue({ cameraMotion: "orbit-right" }, "camera-motion")).toBe("orbit-right")
+  })
+  it("returns motion for motion nodes", () => {
+    expect(getParameterValue({ motion: "moderate" }, "motion")).toBe("moderate")
+  })
+  it("returns tone for tone nodes", () => {
+    expect(getParameterValue({ tone: "dramatic" }, "tone")).toBe("dramatic")
+  })
+  it("returns ratio for aspect-ratio nodes", () => {
+    expect(getParameterValue({ ratio: "16:9" }, "aspect-ratio")).toBe("16:9")
+  })
+  it("returns count-as-string for scene-count nodes", () => {
+    expect(getParameterValue({ count: 5 }, "scene-count")).toBe("5")
+  })
+  it("returns seconds-as-string for duration nodes", () => {
+    expect(getParameterValue({ seconds: 8 }, "duration")).toBe("8")
+  })
+  it("returns text for text-prompt nodes", () => {
+    expect(getParameterValue({ text: "a dog" }, "text-prompt")).toBe("a dog")
+  })
+  it("returns text for style-guide nodes", () => {
+    expect(getParameterValue({ text: "photographic" }, "style-guide")).toBe("photographic")
+  })
+  it("returns undefined for unknown types", () => {
+    expect(getParameterValue({ foo: "bar" }, "image-to-video")).toBeUndefined()
+  })
+  it("returns undefined for missing field", () => {
+    expect(getParameterValue({}, "framing")).toBeUndefined()
+  })
+  it("trims string values", () => {
+    expect(getParameterValue({ shotSize: "  close-up  " }, "framing")).toBe("close-up")
+  })
+})
+
+describe("parameter-node-value — action-fx", () => {
+  it("includes action-fx in PARAMETER_NODE_TYPES", () => {
+    expect(PARAMETER_NODE_TYPES.has("action-fx")).toBe(true)
+  })
+
+  it("returns the single id for a single-string value", () => {
+    expect(getParameterValue({ actionFx: "lightning-bolt" }, "action-fx")).toBe("lightning-bolt")
+  })
+
+  it("returns the first id for an array value", () => {
+    expect(getParameterValue({ actionFx: ["explosion-large", "shockwave-ground"] }, "action-fx")).toBe("explosion-large")
+  })
+
+  it("returns undefined when actionFx is empty string", () => {
+    expect(getParameterValue({ actionFx: "" }, "action-fx")).toBeUndefined()
+  })
+
+  it("returns undefined when actionFx is missing", () => {
+    expect(getParameterValue({}, "action-fx")).toBeUndefined()
+  })
+})
+
+describe("getParameterValue — transition", () => {
+  it("returns the id for a single string value", () => {
+    expect(getParameterValue({ transition: "cross-dissolve" }, "transition")).toBe("cross-dissolve")
+  })
+
+  it("returns the first id for an array value (multi-pick)", () => {
+    expect(getParameterValue({ transition: ["smash-cut", "white-flash"] }, "transition"))
+      .toBe("smash-cut")
+  })
+
+  it("returns undefined for empty string / empty array", () => {
+    expect(getParameterValue({ transition: "" }, "transition")).toBeUndefined()
+    expect(getParameterValue({ transition: [] }, "transition")).toBeUndefined()
+  })
+
+  it("transition is in PARAMETER_NODE_TYPES set", () => {
+    expect(PARAMETER_NODE_TYPES.has("transition")).toBe(true)
+  })
+})
+
+describe("getParameterValue — character-fx", () => {
+  it("returns the id for a single string value", () => {
+    expect(getParameterValue({ characterFx: "werewolf" }, "character-fx")).toBe("werewolf")
+  })
+  it("returns first id for an array value (multi-pick)", () => {
+    expect(getParameterValue({ characterFx: ["werewolf", "fire-breathe"] }, "character-fx"))
+      .toBe("werewolf")
+  })
+  it("returns undefined for empty string / empty array", () => {
+    expect(getParameterValue({ characterFx: "" }, "character-fx")).toBeUndefined()
+    expect(getParameterValue({ characterFx: [] }, "character-fx")).toBeUndefined()
+  })
+  it("character-fx is in PARAMETER_NODE_TYPES set", () => {
+    expect(PARAMETER_NODE_TYPES.has("character-fx")).toBe(true)
+  })
+})
+
+describe("parameter-node-value — furniture", () => {
+  it("includes furniture in PARAMETER_NODE_TYPES set", () => {
+    expect(PARAMETER_NODE_TYPES.has("furniture")).toBe(true)
+  })
+
+  it("getParameterValue returns the trimmed furniture id from data", () => {
+    expect(getParameterValue({ furniture: "  sofa  " }, "furniture")).toBe("sofa")
+  })
+
+  it("getParameterValue returns undefined when furniture field is missing", () => {
+    expect(getParameterValue({}, "furniture")).toBeUndefined()
+  })
+})

package/src/__tests__/pinterest-url.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest"
+import { normalizePinterestUrl } from "../pinterest-url.js"
+
+describe("normalizePinterestUrl", () => {
+  it.each([
+    ["/236x/", "https://i.pinimg.com/236x/ab/cd/ef/abcdef1234.jpg"],
+    ["/474x/", "https://i.pinimg.com/474x/ab/cd/ef/abcdef1234.jpg"],
+    ["/564x/", "https://i.pinimg.com/564x/ab/cd/ef/abcdef1234.jpg"],
+    ["/736x/", "https://i.pinimg.com/736x/ab/cd/ef/abcdef1234.jpg"],
+    ["/1200x/", "https://i.pinimg.com/1200x/ab/cd/ef/abcdef1234.jpg"],
+  ])("rewrites %s to /originals/", (_, input) => {
+    const out = normalizePinterestUrl(input)
+    expect(out).toBe("https://i.pinimg.com/originals/ab/cd/ef/abcdef1234.jpg")
+  })
+
+  it("is a no-op when the URL is already /originals/", () => {
+    const url = "https://i.pinimg.com/originals/ab/cd/ef/abcdef1234.jpg"
+    expect(normalizePinterestUrl(url)).toBe(url)
+  })
+
+  it("preserves query string and fragment", () => {
+    const out = normalizePinterestUrl("https://i.pinimg.com/236x/ab/cd/ef/x.jpg?v=1#hash")
+    expect(out).toBe("https://i.pinimg.com/originals/ab/cd/ef/x.jpg?v=1#hash")
+  })
+
+  it.each([
+    "https://example.com/foo.jpg",
+    "https://www.pinterest.com/pin/123456/",
+    "https://i.pinimg.com/avatars/some-user/abc.jpg",
+    "not-a-url",
+    "",
+  ])("passes through %s unchanged", (input) => {
+    expect(normalizePinterestUrl(input)).toBe(input)
+  })
+})