@nodaro/shared 1.4.1

package/src/__tests__/character-voice.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect } from "vitest"
+import {
+  parseAttributedDialogue,
+  resolveDialogueVoices,
+  type CharacterVoiceSpec,
+} from "../character-voice.js"
+
+// Curly quotes / guillemets via code points: keeps this file ASCII and avoids
+// the \uXXXX-decoding pitfall in some editors/toolchains.
+const LDQUO = String.fromCharCode(0x201c)
+const RDQUO = String.fromCharCode(0x201d)
+const LAQUO = String.fromCharCode(0x00ab)
+const RAQUO = String.fromCharCode(0x00bb)
+
+describe("parseAttributedDialogue", () => {
+  it("extracts a single straight-quoted attributed line", () => {
+    expect(parseAttributedDialogue('Anna: "good morning"')).toEqual([
+      { speaker: "Anna", line: "good morning" },
+    ])
+  })
+
+  it("extracts multiple speakers inline, in order", () => {
+    expect(
+      parseAttributedDialogue('Anna: "good morning" Gordon: "good morning to you too"'),
+    ).toEqual([
+      { speaker: "Anna", line: "good morning" },
+      { speaker: "Gordon", line: "good morning to you too" },
+    ])
+  })
+
+  it("handles curly double quotes", () => {
+    expect(parseAttributedDialogue(`Anna: ${LDQUO}hi there${RDQUO}`)).toEqual([
+      { speaker: "Anna", line: "hi there" },
+    ])
+  })
+
+  it("handles guillemets", () => {
+    expect(parseAttributedDialogue(`Gordon: ${LAQUO}bonjour${RAQUO}`)).toEqual([
+      { speaker: "Gordon", line: "bonjour" },
+    ])
+  })
+
+  it("handles dialogue split across newlines", () => {
+    expect(parseAttributedDialogue('Anna: "line one"\nGordon: "line two"')).toEqual([
+      { speaker: "Anna", line: "line one" },
+      { speaker: "Gordon", line: "line two" },
+    ])
+  })
+
+  it("does not treat non-dialogue colon labels as speech", () => {
+    expect(parseAttributedDialogue("Setting: a forest at dawn. Camera: slow dolly in.")).toEqual([])
+  })
+
+  it("extracts dialogue embedded in cinematic direction without bridging the sentence", () => {
+    expect(
+      parseAttributedDialogue('Wide shot of a kitchen. Anna: "where are you?" She turns.'),
+    ).toEqual([{ speaker: "Anna", line: "where are you?" }])
+  })
+
+  it("supports a two-word speaker label", () => {
+    expect(parseAttributedDialogue('Captain Riley: "hold the line"')).toEqual([
+      { speaker: "Captain Riley", line: "hold the line" },
+    ])
+  })
+
+  it("returns [] for empty input and prompts with no quoted speech", () => {
+    expect(parseAttributedDialogue("")).toEqual([])
+    expect(parseAttributedDialogue("a plain prompt with no dialogue at all")).toEqual([])
+  })
+})
+
+describe("resolveDialogueVoices", () => {
+  const anna: CharacterVoiceSpec = { voiceId: "anna-id", voiceType: "custom", speaker: "Anna" }
+  const gordon: CharacterVoiceSpec = { voiceId: "gordon-id", voiceType: "premade", speaker: "Gordon" }
+
+  it("joins each line to its speaker's voice, preserving order and voiceType", () => {
+    const dialogue = [
+      { speaker: "Anna", line: "good morning" },
+      { speaker: "Gordon", line: "good morning to you too" },
+    ]
+    expect(resolveDialogueVoices(dialogue, [anna, gordon])).toEqual([
+      { text: "good morning", voice: "anna-id", voiceType: "custom" },
+      { text: "good morning to you too", voice: "gordon-id", voiceType: "premade" },
+    ])
+  })
+
+  it("matches speaker labels case-insensitively and trimmed", () => {
+    expect(resolveDialogueVoices([{ speaker: "  aNNa ", line: "hi" }], [anna])).toEqual([
+      { text: "hi", voice: "anna-id", voiceType: "custom" },
+    ])
+  })
+
+  it("falls back to defaultVoiceId for an unmatched speaker", () => {
+    expect(
+      resolveDialogueVoices(
+        [{ speaker: "Stranger", line: "who are you?" }],
+        [anna, gordon],
+        "default-id",
+      ),
+    ).toEqual([{ text: "who are you?", voice: "default-id" }])
+  })
+
+  it("uses the sole voice when there is exactly one spec and no speaker match or default", () => {
+    const solo: CharacterVoiceSpec = { voiceId: "solo-id", voiceType: "library" }
+    expect(
+      resolveDialogueVoices([{ speaker: "Narrator", line: "once upon a time" }], [solo]),
+    ).toEqual([{ text: "once upon a time", voice: "solo-id", voiceType: "library" }])
+  })
+
+  it("falls back to the first voice for an unmatched speaker when several specs and no default", () => {
+    expect(resolveDialogueVoices([{ speaker: "Stranger", line: "hello" }], [anna, gordon])).toEqual([
+      { text: "hello", voice: "anna-id", voiceType: "custom" },
+    ])
+  })
+
+  it("drops lines when there are no voices and no default", () => {
+    expect(resolveDialogueVoices([{ speaker: "Anna", line: "hi" }], [])).toEqual([])
+  })
+
+  it("skips blank lines", () => {
+    expect(resolveDialogueVoices([{ speaker: "Anna", line: "   " }], [anna])).toEqual([])
+  })
+
+  it("omits voiceType when the matched spec has none", () => {
+    const noType: CharacterVoiceSpec = { voiceId: "x-id", speaker: "X" }
+    expect(resolveDialogueVoices([{ speaker: "X", line: "yo" }], [noType])).toEqual([
+      { text: "yo", voice: "x-id" },
+    ])
+  })
+})

package/src/__tests__/cinematic-avatar-pricing.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "vitest"
+import {
+  CINEMATIC_MIN_DURATION_SEC,
+  CINEMATIC_MAX_DURATION_SEC,
+  CINEMATIC_DEFAULT_DURATION_SEC,
+  CINEMATIC_RESERVE_IDS,
+  clampCinematicDuration,
+  cinematicCreditId,
+  resolveCinematicCreditId,
+} from "../cinematic-avatar-pricing.js"
+
+// The provider-$ rate table and USD/credit cost formulas (cinematicUsdCost,
+// cinematicHoldCredits) moved to
+// backend/src/lib/pricing/cinematic-avatar-cost.ts (S5) — their tests live in
+// backend/src/lib/pricing/__tests__/cinematic-avatar-cost.test.ts. This file
+// covers only the NON-monetary duration-clamping + credit-id-construction
+// logic that stays in the published package.
+
+describe("clampCinematicDuration", () => {
+  it("passes through legal values (rounded to whole seconds)", () => {
+    expect(clampCinematicDuration(4)).toBe(4)
+    expect(clampCinematicDuration(10)).toBe(10)
+    expect(clampCinematicDuration(15)).toBe(15)
+    expect(clampCinematicDuration(7.4)).toBe(7)
+    expect(clampCinematicDuration(7.6)).toBe(8)
+  })
+
+  it("clamps below-min and above-max to the legal range", () => {
+    expect(clampCinematicDuration(0)).toBe(CINEMATIC_MIN_DURATION_SEC)
+    expect(clampCinematicDuration(3)).toBe(CINEMATIC_MIN_DURATION_SEC)
+    expect(clampCinematicDuration(100)).toBe(CINEMATIC_MAX_DURATION_SEC)
+  })
+
+  it("falls back to the default for non-finite input", () => {
+    expect(clampCinematicDuration(undefined)).toBe(CINEMATIC_DEFAULT_DURATION_SEC)
+    expect(clampCinematicDuration(NaN)).toBe(CINEMATIC_DEFAULT_DURATION_SEC)
+  })
+})
+
+describe("cinematicCreditId", () => {
+  it("formats as cinematic-avatar:<res>:<dur>s", () => {
+    expect(cinematicCreditId("720p", 10)).toBe("cinematic-avatar:720p:10s")
+    expect(cinematicCreditId("1080p", 4)).toBe("cinematic-avatar:1080p:4s")
+  })
+})
+
+describe("resolveCinematicCreditId", () => {
+  it("reads resolution + duration off the raw body", () => {
+    expect(resolveCinematicCreditId({ resolution: "1080p", duration: 12 })).toBe(
+      "cinematic-avatar:1080p:12s",
+    )
+  })
+
+  it("defaults resolution to 720p and duration to 10s when missing", () => {
+    expect(resolveCinematicCreditId({})).toBe("cinematic-avatar:720p:10s")
+    expect(resolveCinematicCreditId(undefined)).toBe("cinematic-avatar:720p:10s")
+  })
+
+  it("clamps an out-of-range duration to the legal range", () => {
+    expect(resolveCinematicCreditId({ duration: 2 })).toBe("cinematic-avatar:720p:4s")
+    expect(resolveCinematicCreditId({ duration: 99 })).toBe("cinematic-avatar:720p:15s")
+  })
+
+  it("falls back to 720p for an unknown resolution", () => {
+    expect(resolveCinematicCreditId({ resolution: "4k", duration: 5 })).toBe(
+      "cinematic-avatar:720p:5s",
+    )
+  })
+
+  it("always resolves to a member of CINEMATIC_RESERVE_IDS (no 503 trap)", () => {
+    for (const resolution of ["720p", "1080p", "bogus"]) {
+      for (let d = -5; d <= 30; d++) {
+        const id = resolveCinematicCreditId({ resolution, duration: d })
+        expect(CINEMATIC_RESERVE_IDS).toContain(id)
+      }
+    }
+  })
+
+  it("reserves at the 15s MAX-duration ceiling when autoDuration is true", () => {
+    // autoDuration → HeyGen picks the length (unknown at submit). Reserve at the
+    // ceiling so the metered true-up can only refund, never undercharge.
+    expect(resolveCinematicCreditId({ autoDuration: true })).toBe(
+      `cinematic-avatar:720p:${CINEMATIC_MAX_DURATION_SEC}s`,
+    )
+    expect(
+      resolveCinematicCreditId({ resolution: "1080p", autoDuration: true }),
+    ).toBe(`cinematic-avatar:1080p:${CINEMATIC_MAX_DURATION_SEC}s`)
+  })
+
+  it("ignores a stale `duration` when autoDuration is true (still reserves at max)", () => {
+    // The provider drops `duration` under autoDuration, so a left-over short
+    // duration must NOT shrink the hold below the ceiling.
+    expect(
+      resolveCinematicCreditId({ duration: 4, autoDuration: true }),
+    ).toBe(`cinematic-avatar:720p:${CINEMATIC_MAX_DURATION_SEC}s`)
+  })
+
+  it("uses the exact duration when autoDuration is false/absent", () => {
+    expect(resolveCinematicCreditId({ duration: 6, autoDuration: false })).toBe(
+      "cinematic-avatar:720p:6s",
+    )
+    expect(resolveCinematicCreditId({ duration: 6 })).toBe("cinematic-avatar:720p:6s")
+  })
+})
+
+describe("CINEMATIC_RESERVE_IDS", () => {
+  it("contains exactly 24 ids (2 resolutions × 12 durations 4..15)", () => {
+    expect(CINEMATIC_RESERVE_IDS).toHaveLength(24)
+    // Spot-check both ends of each resolution band.
+    expect(CINEMATIC_RESERVE_IDS).toContain("cinematic-avatar:720p:4s")
+    expect(CINEMATIC_RESERVE_IDS).toContain("cinematic-avatar:720p:15s")
+    expect(CINEMATIC_RESERVE_IDS).toContain("cinematic-avatar:1080p:4s")
+    expect(CINEMATIC_RESERVE_IDS).toContain("cinematic-avatar:1080p:15s")
+  })
+
+  it("has no duplicate ids", () => {
+    expect(new Set(CINEMATIC_RESERVE_IDS).size).toBe(CINEMATIC_RESERVE_IDS.length)
+  })
+})

package/src/__tests__/combine-transitions.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect } from "vitest"
+import {
+  COMBINE_TRANSITIONS,
+  COMBINE_TRANSITION_IDS,
+  COMBINE_TRANSITION_GROUP_ORDER,
+  COMBINE_TRANSITION_GROUP_LABELS,
+  getCombineTransition,
+  resolveXfadeName,
+} from "../combine-transitions.js"
+
+describe("COMBINE_TRANSITIONS catalog", () => {
+  it("has unique transition ids", () => {
+    const ids = COMBINE_TRANSITIONS.map((t) => t.id)
+    expect(new Set(ids).size).toBe(ids.length)
+  })
+
+  it("preserves the 5 legacy ids for workflow back-compat", () => {
+    const legacy = ["cut", "fade", "dissolve", "dip-to-black", "dip-to-white"]
+    for (const id of legacy) {
+      expect(COMBINE_TRANSITION_IDS).toContain(id)
+    }
+  })
+
+  it("snapshot: catalog ids (sorted) — any add/remove/rename must update this", () => {
+    // Locks the full id surface so a silent rename can't break saved workflows.
+    expect([...COMBINE_TRANSITION_IDS].sort()).toMatchInlineSnapshot(`
+      [
+        "circle-close",
+        "circle-crop",
+        "circle-open",
+        "cover-down",
+        "cover-left",
+        "cover-right",
+        "cover-up",
+        "cut",
+        "diag-bl",
+        "diag-br",
+        "diag-tl",
+        "diag-tr",
+        "dip-to-black",
+        "dip-to-white",
+        "dissolve",
+        "distance",
+        "fade",
+        "fadegrays",
+        "hblur",
+        "hl-slice",
+        "horz-close",
+        "horz-open",
+        "hr-slice",
+        "pixelize",
+        "radial",
+        "rect-crop",
+        "reveal-down",
+        "reveal-left",
+        "reveal-right",
+        "reveal-up",
+        "slide-down",
+        "slide-left",
+        "slide-right",
+        "slide-up",
+        "smooth-down",
+        "smooth-left",
+        "smooth-right",
+        "smooth-up",
+        "squeeze-h",
+        "squeeze-v",
+        "vd-slice",
+        "vert-close",
+        "vert-open",
+        "vu-slice",
+        "wipe-bl",
+        "wipe-br",
+        "wipe-down",
+        "wipe-left",
+        "wipe-right",
+        "wipe-tl",
+        "wipe-tr",
+        "wipe-up",
+        "zoom-in",
+      ]
+    `)
+  })
+
+  it("flags the right set as `common` (the Common tab)", () => {
+    const commonIds = COMBINE_TRANSITIONS.filter((t) => t.common).map((t) => t.id)
+    expect(commonIds).toEqual(
+      expect.arrayContaining([
+        "cut",
+        "fade",
+        "dissolve",
+        "dip-to-black",
+        "dip-to-white",
+        "wipe-left",
+        "wipe-right",
+        "slide-left",
+        "slide-right",
+        "circle-open",
+      ]),
+    )
+  })
+
+  it("assigns every entry to a known group", () => {
+    for (const t of COMBINE_TRANSITIONS) {
+      expect(COMBINE_TRANSITION_GROUP_ORDER).toContain(t.group)
+      expect(COMBINE_TRANSITION_GROUP_LABELS[t.group]).toBeTruthy()
+    }
+  })
+
+  it("gives every entry a non-empty label and description", () => {
+    for (const t of COMBINE_TRANSITIONS) {
+      expect(t.label).toBeTruthy()
+      expect(t.description.length).toBeGreaterThan(10)
+    }
+  })
+
+  it("resolveXfadeName returns null for `cut` and the catalog's xfade name otherwise", () => {
+    expect(resolveXfadeName("cut")).toBeNull()
+    expect(resolveXfadeName("fade")).toBe("fade")
+    expect(resolveXfadeName("dissolve")).toBe("dissolve") // not aliased to "fade" anymore
+    expect(resolveXfadeName("dip-to-black")).toBe("fadeblack")
+    expect(resolveXfadeName("dip-to-white")).toBe("fadewhite")
+    expect(resolveXfadeName("wipe-left")).toBe("wipeleft")
+    expect(resolveXfadeName("circle-open")).toBe("circleopen")
+    expect(resolveXfadeName("squeeze-h")).toBe("squeezeh")
+    expect(resolveXfadeName("zoom-in")).toBe("zoomin")
+  })
+
+  it("resolveXfadeName throws for unknown ids", () => {
+    expect(() => resolveXfadeName("totally-not-a-transition")).toThrow()
+  })
+
+  it("getCombineTransition returns undefined for unknown ids", () => {
+    expect(getCombineTransition("nope")).toBeUndefined()
+    expect(getCombineTransition("fade")?.label).toBe("Fade")
+  })
+})

package/src/__tests__/component-types.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect } from "vitest"
+import {
+  parseHandleId,
+  HANDLE_PORT_SEPARATOR,
+  applyHandleInputOverride,
+  isHandleInputWired,
+} from "../component-types.js"
+
+describe("parseHandleId", () => {
+  it("returns plain nodeId when no separator is present", () => {
+    expect(parseHandleId("node_42")).toEqual({ nodeId: "node_42" })
+  })
+
+  it("splits compound id into nodeId + portId", () => {
+    expect(parseHandleId(`node_3${HANDLE_PORT_SEPARATOR}port_input_1`))
+      .toEqual({ nodeId: "node_3", portId: "port_input_1" })
+  })
+
+  it("treats trailing separator as no portId", () => {
+    expect(parseHandleId(`node_5${HANDLE_PORT_SEPARATOR}`))
+      .toEqual({ nodeId: "node_5", portId: undefined })
+  })
+
+  it("preserves further separators inside the portId", () => {
+    // portIds are opaque — if a port id itself contains '::', everything after
+    // the FIRST separator belongs to the portId.
+    expect(parseHandleId(`a${HANDLE_PORT_SEPARATOR}b${HANDLE_PORT_SEPARATOR}c`))
+      .toEqual({ nodeId: "a", portId: `b${HANDLE_PORT_SEPARATOR}c` })
+  })
+
+  it("returns empty nodeId when the input starts with the separator", () => {
+    expect(parseHandleId(`${HANDLE_PORT_SEPARATOR}port_x`))
+      .toEqual({ nodeId: "", portId: "port_x" })
+  })
+})
+
+describe("applyHandleInputOverride", () => {
+  it("plain handle writes to inputOverrides[nodeId][fieldKey]", () => {
+    const o: Record<string, Record<string, unknown>> = {}
+    applyHandleInputOverride(o, { id: "node_5", fieldKey: "prompt" }, "hello")
+    expect(o).toEqual({ node_5: { prompt: "hello" } })
+  })
+
+  it("compound handle writes to __injectedPortValues[portId]", () => {
+    const o: Record<string, Record<string, unknown>> = {}
+    applyHandleInputOverride(o, { id: "in1::pA", fieldKey: "pA" }, "value-A")
+    expect(o).toEqual({ in1: { __injectedPortValues: { pA: "value-A" } } })
+  })
+
+  it("accumulates multiple port values for the same sub-workflow-input node", () => {
+    const o: Record<string, Record<string, unknown>> = {}
+    applyHandleInputOverride(o, { id: "in1::pA", fieldKey: "pA" }, "value-A")
+    applyHandleInputOverride(o, { id: "in1::pB", fieldKey: "pB" }, "value-B")
+    expect(o.in1.__injectedPortValues).toEqual({ pA: "value-A", pB: "value-B" })
+  })
+
+  it("preserves existing non-port fields on the same node", () => {
+    const o: Record<string, Record<string, unknown>> = { in1: { existingField: "keep" } }
+    applyHandleInputOverride(o, { id: "in1::pA", fieldKey: "pA" }, "value-A")
+    expect(o.in1.existingField).toBe("keep")
+    expect(o.in1.__injectedPortValues).toEqual({ pA: "value-A" })
+  })
+})
+
+describe("isHandleInputWired", () => {
+  it("plain handle: true when the field is set", () => {
+    expect(isHandleInputWired({ node_5: { prompt: "x" } }, { id: "node_5", fieldKey: "prompt" })).toBe(true)
+  })
+
+  it("plain handle: false when the field is missing", () => {
+    expect(isHandleInputWired({ node_5: {} }, { id: "node_5", fieldKey: "prompt" })).toBe(false)
+  })
+
+  it("compound handle: true when the port value is set", () => {
+    expect(isHandleInputWired(
+      { in1: { __injectedPortValues: { pA: "v" } } },
+      { id: "in1::pA", fieldKey: "pA" },
+    )).toBe(true)
+  })
+
+  it("compound handle: false when the port is missing", () => {
+    expect(isHandleInputWired(
+      { in1: { __injectedPortValues: { pB: "v" } } },
+      { id: "in1::pA", fieldKey: "pA" },
+    )).toBe(false)
+  })
+})

package/src/__tests__/condition-variables.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from "vitest"
+import { buildConditionVariables } from "../condition-variables.js"
+
+type N = { id: string; type?: string; data: Record<string, unknown> }
+type E = { source: string; target: string; sourceHandle?: string | null; targetHandle?: string | null }
+
+const node = (id: string, type: string, label: string, extra: Record<string, unknown> = {}): N => ({
+  id,
+  type,
+  data: { label, ...extra },
+})
+
+const edge = (source: string, target: string, targetHandle = "in", sourceHandle: string | null = "prompt"): E => ({
+  source,
+  target,
+  sourceHandle,
+  targetHandle,
+})
+
+// A minimal extractor that reads the node's `data.text`.
+const extract = (n: N): string | undefined =>
+  typeof n.data.text === "string" ? (n.data.text as string) : undefined
+
+describe("buildConditionVariables", () => {
+  it("includes only nodes connected to the target's `variables` handle", () => {
+    const tpVar = node("v", "text-prompt", "DateRef", { text: "2026-04-21" })
+    const tpData = node("d", "text-prompt", "DataSource", { text: "listitem" })
+    const filter = node("f", "filter-list", "Filter")
+    const edges: E[] = [
+      edge("v", "f", "variables", "prompt"),
+      edge("d", "f", "in", "prompt"),
+    ]
+    const map = buildConditionVariables("f", edges, [tpVar, tpData, filter], extract)
+    expect(map.size).toBe(1)
+    expect(map.get("DateRef")).toBe("2026-04-21")
+    expect(map.has("DataSource")).toBe(false)
+  })
+
+  it("returns an empty map when no variables-handle edges exist", () => {
+    const tp = node("d", "text-prompt", "Data", { text: "x" })
+    const filter = node("f", "filter-list", "Filter")
+    const edges: E[] = [edge("d", "f", "in", "prompt")]
+    const map = buildConditionVariables("f", edges, [tp, filter], extract)
+    expect(map.size).toBe(0)
+  })
+
+  it("keys by the source node's label", () => {
+    const n1 = node("a", "text-prompt", "My Label", { text: "v1" })
+    const filter = node("f", "filter-list", "Filter")
+    const map = buildConditionVariables("f", [edge("a", "f", "variables", "prompt")], [n1, filter], extract)
+    expect(map.get("My Label")).toBe("v1")
+  })
+
+  it("falls back to node type when label is missing", () => {
+    const n1: N = { id: "a", type: "text-prompt", data: { text: "v1" } }
+    const filter = node("f", "filter-list", "Filter")
+    const map = buildConditionVariables("f", [edge("a", "f", "variables", "prompt")], [n1, filter], extract)
+    expect(map.get("text-prompt")).toBe("v1")
+  })
+
+  it("suffixes duplicates with (2), (3), ...", () => {
+    const a = node("a", "text-prompt", "Same", { text: "first" })
+    const b = node("b", "text-prompt", "Same", { text: "second" })
+    const c = node("c", "text-prompt", "Same", { text: "third" })
+    const filter = node("f", "filter-list", "Filter")
+    const edges: E[] = [
+      edge("a", "f", "variables", "prompt"),
+      edge("b", "f", "variables", "prompt"),
+      edge("c", "f", "variables", "prompt"),
+    ]
+    const map = buildConditionVariables("f", edges, [a, b, c, filter], extract)
+    expect(map.get("Same")).toBe("first")
+    expect(map.get("Same (2)")).toBe("second")
+    expect(map.get("Same (3)")).toBe("third")
+  })
+
+  it("skips sources with no extractable output", () => {
+    const withText = node("a", "text-prompt", "Has", { text: "present" })
+    const noText = node("b", "text-prompt", "Missing") // no data.text
+    const filter = node("f", "filter-list", "Filter")
+    const edges: E[] = [
+      edge("a", "f", "variables", "prompt"),
+      edge("b", "f", "variables", "prompt"),
+    ]
+    const map = buildConditionVariables("f", edges, [withText, noText, filter], extract)
+    expect(map.get("Has")).toBe("present")
+    expect(map.has("Missing")).toBe(false)
+  })
+
+  it("ignores edges targeting other nodes", () => {
+    const tp = node("a", "text-prompt", "Ref", { text: "x" })
+    const other = node("o", "filter-list", "Other")
+    const filter = node("f", "filter-list", "Filter")
+    const edges: E[] = [edge("a", "o", "variables", "prompt")]
+    const map = buildConditionVariables("f", edges, [tp, other, filter], extract)
+    expect(map.size).toBe(0)
+  })
+})