@nodaro/shared 3.11.0 → 3.12.1

package/src/__tests__/fan-out-rows.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect } from "vitest"
+import {
+  NON_PROMPT_TEXT_LANES,
+  fanOutTextFeedsPrompt,
+  compactWithRows,
+  resolveListFanOut,
+  planFanOut,
+  alignedFieldList,
+  liveRowColumn,
+  type FanOutCandidate,
+} from "../fan-out-rows.js"
+import { REPEAT_PLACEHOLDER, encodeProviderItem } from "../repeat-types.js"
+
+describe("fanOutTextFeedsPrompt", () => {
+  it("a list wired to the prompt (or to a node's single generic input) feeds the prompt", () => {
+    expect(fanOutTextFeedsPrompt("generate-image", "prompt")).toBe(true)
+    expect(fanOutTextFeedsPrompt("text-to-speech", "in")).toBe(true)
+    expect(fanOutTextFeedsPrompt("generate-image", undefined)).toBe(true)
+    expect(fanOutTextFeedsPrompt(undefined, null)).toBe(true)
+  })
+
+  it("a list wired to a lane the routers divert does NOT feed the prompt", () => {
+    expect(fanOutTextFeedsPrompt("generate-image", "negative")).toBe(false)
+    expect(fanOutTextFeedsPrompt("llm-chat", "system-prompt")).toBe(false)
+    expect(fanOutTextFeedsPrompt("ai-avatar", "script")).toBe(false)
+  })
+
+  it("is scoped by node type: the same handle can be the prompt elsewhere", () => {
+    expect(fanOutTextFeedsPrompt("add-captions", "transcript")).toBe(false)
+    expect(fanOutTextFeedsPrompt("forced-alignment", "transcript")).toBe(true)
+  })
+
+  it("a '*' lane covers every node type, including ones that do not exist yet", () => {
+    expect(NON_PROMPT_TEXT_LANES.negative).toBe("*")
+    expect(fanOutTextFeedsPrompt("some-future-node", "negative")).toBe(false)
+  })
+
+  it("a handle named like an Object.prototype member is just an unlisted handle", () => {
+    expect(fanOutTextFeedsPrompt("generate-image", "constructor")).toBe(true)
+    expect(fanOutTextFeedsPrompt("generate-image", "toString")).toBe(true)
+  })
+})
+
+describe("compactWithRows", () => {
+  it("drops empty cells but remembers the row each kept value came from", () => {
+    expect(compactWithRows(["a", "", "  ", "d"])).toEqual({ items: ["a", "d"], rowIndices: [0, 3] })
+  })
+
+  it("is the identity (with 0..n-1 rows) for a list with no holes", () => {
+    expect(compactWithRows(["a", "b"])).toEqual({ items: ["a", "b"], rowIndices: [0, 1] })
+  })
+
+  it("keeps the ORIGINAL text of a kept value (no trimming of content)", () => {
+    expect(compactWithRows([" a ", "b\nc"]).items).toEqual([" a ", "b\nc"])
+  })
+})
+
+describe("liveRowColumn", () => {
+  it("drops a row only when EVERY cell of it is blank, and keeps an empty cell of a live row in place", () => {
+    const rows = [["a", "x"], ["b", ""], ["", ""], ["", "z"]]
+    expect(liveRowColumn(rows, 0)).toEqual(["a", "b", ""])
+    expect(liveRowColumn(rows, 1)).toEqual(["x", "", "z"])
+  })
+
+  it("a single-column list with a trailing blank row does not grow", () => {
+    expect(liveRowColumn([["a"], ["b"], [""]], 0)).toEqual(["a", "b"])
+  })
+
+  it("trims cells and tolerates ragged rows", () => {
+    expect(liveRowColumn([[" a "], ["b", "y"]], 1)).toEqual(["", "y"])
+  })
+})
+
+describe("resolveListFanOut", () => {
+  const cand = (targetHandle: string, aligned: string[]): FanOutCandidate => ({ targetHandle, aligned })
+
+  it("a single list: its values drive, on the rows they sit in", () => {
+    const only = cand("prompt", ["p1", "", "p3"])
+    expect(resolveListFanOut([only], "generate-image")).toEqual({ items: ["p1", "p3"], rowIndices: [0, 2], targetHandle: "prompt" })
+  })
+
+  it("the list that feeds the prompt drives — whichever wire the engine met first", () => {
+    const negative = cand("negative", ["n1", "n2", "n3"])
+    const prompt = cand("prompt", ["p1", "p2", "p3"])
+    const expected = { items: ["p1", "p2", "p3"], rowIndices: [0, 1, 2], targetHandle: "prompt" }
+    expect(resolveListFanOut([negative, prompt], "generate-image")).toEqual(expected)
+    expect(resolveListFanOut([prompt, negative], "generate-image")).toEqual(expected)
+  })
+
+  it("a list wired to negative ALONE drives through negative (so nothing writes it into the prompt)", () => {
+    const negative = cand("negative", ["n1", "n2"])
+    expect(resolveListFanOut([negative], "generate-image")?.targetHandle).toBe("negative")
+  })
+
+  it("a row runs when ANY column has a value in it; an empty driver cell overrides nothing", () => {
+    const negative = cand("negative", ["n1", "n2", "n3"])
+    const prompt = cand("prompt", ["p1", "", "p3"])
+    const expected = { items: ["p1", "", "p3"], rowIndices: [0, 1, 2], targetHandle: "prompt" }
+    expect(resolveListFanOut([negative, prompt], "generate-image")).toEqual(expected)
+    expect(resolveListFanOut([prompt, negative], "generate-image")).toEqual(expected)
+  })
+
+  it("a row that is empty in EVERY column does not run", () => {
+    const negative = cand("negative", ["n1", "", "n3"])
+    const prompt = cand("prompt", ["p1", "", "p3"])
+    expect(resolveListFanOut([prompt, negative], "generate-image")?.rowIndices).toEqual([0, 2])
+  })
+
+  it("the list holding the MOST values sets the rows — in either wire order — and one of another length stays out of it", () => {
+    const negative = cand("negative", ["n1", "n2", "n3"])
+    const prompt = cand("prompt", ["p1", "p2"])
+    const expected = { items: ["n1", "n2", "n3"], rowIndices: [0, 1, 2], targetHandle: "negative" }
+    expect(resolveListFanOut([negative, prompt], "generate-image")).toEqual(expected)
+    expect(resolveListFanOut([prompt, negative], "generate-image")).toEqual(expected)
+  })
+
+  it("values held decide the primary, not the row count (a long column that is mostly empty does not win)", () => {
+    const sparse = cand("negative", ["n1", "", "", "", "n5"])
+    const prompts = cand("prompt", ["p1", "p2", "p3"])
+    expect(resolveListFanOut([sparse, prompts], "generate-image")).toEqual({
+      items: ["p1", "p2", "p3"],
+      rowIndices: [0, 1, 2],
+      targetHandle: "prompt",
+    })
+  })
+
+  it("no candidates, no fan-out", () => {
+    expect(resolveListFanOut([], "generate-image")).toBeUndefined()
+  })
+
+  it("a media list never supplies the prompt: beside images, the prompts drive and every image row still runs", () => {
+    const images = cand("image", ["https://cdn/a.png", "https://cdn/b.png", "https://cdn/c.png"])
+    const prompts = cand("prompt", ["p1", "", "p3"])
+    const expected = { items: ["p1", "", "p3"], rowIndices: [0, 1, 2], targetHandle: "prompt" }
+    expect(resolveListFanOut([images, prompts], "image-to-video")).toEqual(expected)
+    expect(resolveListFanOut([prompts, images], "image-to-video")).toEqual(expected)
+  })
+})
+
+describe("planFanOut", () => {
+  const fanOut = { items: ["a", "c"], rowIndices: [0, 2], targetHandle: "prompt" }
+
+  it("maps every iteration to the row its item came from", () => {
+    expect(planFanOut(fanOut, "generate-image", {})).toEqual({
+      items: ["a", "c"],
+      rows: [0, 2],
+      targetHandle: "prompt",
+    })
+  })
+
+  it("repeat xN keeps each repeated iteration on ITS OWN row (the sibling columns stay paired)", () => {
+    expect(planFanOut(fanOut, "generate-image", { repeatCount: 2 })).toEqual({
+      items: ["a", "a", "c", "c"],
+      rows: [0, 0, 2, 2],
+      targetHandle: "prompt",
+    })
+  })
+
+  it("repeat-only and provider-only runs have no rows (nothing is list-driven)", () => {
+    expect(planFanOut(undefined, "generate-image", { repeatCount: 3 })).toEqual({
+      items: [REPEAT_PLACEHOLDER, REPEAT_PLACEHOLDER, REPEAT_PLACEHOLDER],
+      rows: [undefined, undefined, undefined],
+      targetHandle: undefined,
+    })
+    expect(planFanOut(undefined, "generate-image", { providers: ["a", "b"] })?.items).toEqual([
+      encodeProviderItem("a"),
+      encodeProviderItem("b"),
+    ])
+  })
+
+  it("returns null when there is nothing to fan out (single run)", () => {
+    expect(planFanOut(undefined, "generate-image", {})).toBeNull()
+    expect(planFanOut({ items: ["only"], rowIndices: [0], targetHandle: "prompt" }, "generate-image", {})).toBeNull()
+  })
+})
+
+describe("alignedFieldList", () => {
+  const concepts = [
+    { prompt: "p1", negative: "n1" },
+    { prompt: "p2", negative: "" },
+    { prompt: "p3", negative: "n3" },
+    { prompt: "p4" },
+    { prompt: "p5", negative: null },
+  ]
+
+  it("emits one entry per element of a root array, empty where the element has no value", () => {
+    expect(alignedFieldList(concepts, "negative")).toEqual(["n1", "", "n3", "", ""])
+    expect(alignedFieldList(concepts, "prompt")).toEqual(["p1", "p2", "p3", "p4", "p5"])
+  })
+
+  it("stringifies like Extract Field does (numbers, booleans, objects)", () => {
+    expect(alignedFieldList([{ v: 1 }, { v: false }, { v: { a: 1 } }], "v")).toEqual(["1", "false", '{"a":1}'])
+  })
+
+  it("supports nested dot paths and whole-item mode", () => {
+    expect(alignedFieldList([{ a: { b: "x" } }, { a: {} }], "a.b")).toEqual(["x", ""])
+    expect(alignedFieldList(["a", "b"], "")).toEqual(["a", "b"])
+  })
+
+  it("has no answer when rows cannot be defined — not a root array, or an element fans into several values", () => {
+    expect(alignedFieldList({ prompt: "p" }, "prompt")).toBeUndefined()
+    expect(alignedFieldList([{ pages: [{ url: "u1" }, { url: "u2" }] }], "pages.url")).toBeUndefined()
+  })
+
+  it("has no answer when NO element carries the field (an all-blank list is not a list)", () => {
+    expect(alignedFieldList([{ a: 1 }, { b: 2 }], "missing")).toBeUndefined()
+  })
+})

package/src/__tests__/instagram-scrape.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest"
+import {
+  INSTAGRAM_SCRAPE_CREDIT_COSTS,
+  INSTAGRAM_SCRAPE_FALLBACK_CREDIT_ID,
+  INSTAGRAM_SCRAPE_MAX_SOURCES,
+  INSTAGRAM_SCRAPE_TIERS,
+  buildInstagramScrapeCreditId,
+  clampInstagramFeaturedIndex,
+  featuredInstagramOutputs,
+  instagramScrapeCreditIdFromNode,
+  instagramScrapeSources,
+  resolveInstagramScrapeCreditId,
+  splitInstagramTargets,
+} from "../instagram-scrape.js"
+import { resolveEffectiveSourceType } from "../entity-image-handle.js"
+
+describe("instagram-scrape vocabulary", () => {
+  it("splitInstagramTargets: one per line / comma, strips @ and #, dedupes, caps at MAX_SOURCES", () => {
+    expect(splitInstagramTargets("@nike\n#running, adidas")).toEqual(["nike", "running", "adidas"])
+    expect(splitInstagramTargets("nike\nNIKE")).toEqual(["nike"])
+    expect(splitInstagramTargets(["  puma ", "", "@vans"])).toEqual(["puma", "vans"])
+    expect(splitInstagramTargets(Array.from({ length: 9 }, (_, i) => `b${i}`))).toHaveLength(INSTAGRAM_SCRAPE_MAX_SOURCES)
+    expect(splitInstagramTargets(undefined)).toEqual([])
+  })
+
+  it("credit ids: 1 credit per requested post, tiered on count × sources, analysis folds in", () => {
+    expect(buildInstagramScrapeCreditId({ count: 20, sources: 1 })).toBe("instagram-scrape:20")
+    expect(buildInstagramScrapeCreditId({ count: 30, sources: 2 })).toBe("instagram-scrape:100")
+    expect(buildInstagramScrapeCreditId({ count: 20, sources: 1, analysis: "economy" })).toBe("instagram-scrape:20:analysis:economy")
+    expect(buildInstagramScrapeCreditId({ count: 50, sources: 1, analysis: "standard" })).toBe("instagram-scrape:50:analysis")
+    for (const tier of INSTAGRAM_SCRAPE_TIERS) {
+      expect(INSTAGRAM_SCRAPE_CREDIT_COSTS[`instagram-scrape:${tier}`]).toBe(tier)
+      expect(INSTAGRAM_SCRAPE_CREDIT_COSTS[`instagram-scrape:${tier}:analysis:economy`]).toBe(tier * 2)
+    }
+    expect(INSTAGRAM_SCRAPE_CREDIT_COSTS[INSTAGRAM_SCRAPE_FALLBACK_CREDIT_ID]).toBeDefined()
+  })
+
+  it("the node quote and the pre-Zod guard land on the SAME identifier", () => {
+    const data = { mode: "profile", targets: "nike\nadidas", count: 30, analyze: true }
+    expect(instagramScrapeSources(data)).toBe(2)
+    expect(instagramScrapeCreditIdFromNode(data)).toBe("instagram-scrape:100:analysis:economy")
+    // The wire body the node sends (targets already split to an array).
+    expect(resolveInstagramScrapeCreditId({ targets: ["nike", "adidas"], count: 30, analyze: true })).toBe("instagram-scrape:100:analysis:economy")
+    expect(resolveInstagramScrapeCreditId({})).toBe("instagram-scrape:20") // omitted count = default, 1 source
+  })
+
+  it("featured outputs: caption / first image / first video, clamped", () => {
+    const posts = [
+      { caption: "hi", images: ["https://i/1.jpg"], videos: [], videoPreviews: [] },
+      { caption: "vid", images: [], videos: ["https://v/2.mp4"], videoPreviews: ["https://v/2.jpg"] },
+    ]
+    expect(featuredInstagramOutputs(posts, 0)).toEqual({ text: "hi", imageUrl: "https://i/1.jpg" })
+    expect(featuredInstagramOutputs(posts, 1)).toEqual({ text: "vid", imageUrl: "https://v/2.jpg", videoUrl: "https://v/2.mp4" })
+    expect(featuredInstagramOutputs(posts, 9)).toEqual(featuredInstagramOutputs(posts, 1))
+    expect(featuredInstagramOutputs([], 0)).toEqual({})
+    expect(clampInstagramFeaturedIndex(-3, 2)).toBe(0)
+  })
+
+  it("typed handles resolve as the canonical single-media producers on canvas; json keeps the raw type", () => {
+    expect(resolveEffectiveSourceType("instagram-scrape", "text")).toBe("combine-text")
+    expect(resolveEffectiveSourceType("instagram-scrape", "image")).toBe("upload-image")
+    expect(resolveEffectiveSourceType("instagram-scrape", "video")).toBe("upload-video")
+    expect(resolveEffectiveSourceType("instagram-scrape", "json")).toBe("instagram-scrape")
+    expect(resolveEffectiveSourceType("instagram-scrape", "audio")).toBe("instagram-scrape")
+  })
+})

package/src/__tests__/llm-models.test.ts

@@ -18,6 +18,8 @@ import {
   LLM_VENDOR_LABELS,
   groupLlmModelsByVendor,
   orderedLlmModels,
+  REASONING_OUTPUT_FLOOR,
+  reasoningOutputFloor,
 } from "../llm-models.js"
 import type { LlmModelDef, LlmTier, LlmFeature } from "../llm-models.js"
 import { PIPELINE_PINNABLE_SCRIPT_LLMS } from "../pipeline-types.js"
@@ -388,6 +390,7 @@ describe("LLM_FEATURE_DEFAULTS", () => {
     "lottie-overlay",
     "3d-title",
     "image-to-text",
+    "meta-ads-analysis",
     "describe-to-picker",
     "qa-check",
     "generate-script",
@@ -399,8 +402,8 @@ describe("LLM_FEATURE_DEFAULTS", () => {
     "3d-scene",
   ]
 
-  it("has entries for all 18 features", () => {
-    expect(Object.keys(LLM_FEATURE_DEFAULTS)).toHaveLength(18)
+  it("has entries for all 19 features", () => {
+    expect(Object.keys(LLM_FEATURE_DEFAULTS)).toHaveLength(19)
     for (const feature of ALL_FEATURES) {
       expect(LLM_FEATURE_DEFAULTS).toHaveProperty(feature)
     }
@@ -577,6 +580,38 @@ describe("reasoning effort registry", () => {
     }
   })
 
+  it("every Gemini 3 model reasons by default and is floored within what its lanes take (#1588)", () => {
+    // Measured on 3.6 (#1588): with no thinking param sent, the direct lane
+    // spent ~1,060 of a node's 1,100-token cap reasoning and returned 120
+    // characters. Unflagged, the node's small cap reaches the wire untouched.
+    // The floor is the model's own, never the 32768 default: it rides the KIE
+    // endpoint too, and the flash ones are only known to take 8192.
+    const expected: Record<string, number> = {
+      "gemini-3-flash": 8192,
+      "gemini-3.6-flash": 8192,
+      "gemini-3.7-flash": 8192,
+      "gemini-3.8-flash": 16384,
+      "gemini-3.1-pro": 16384,
+    }
+    for (const [id, floor] of Object.entries(expected)) {
+      const m = getLlmModel(id)!
+      expect(m.thinkingDefaultOn, id).toBe(true)
+      expect(reasoningOutputFloor(m), id).toBe(floor)
+      expect(reasoningOutputFloor(m), `${id} floor above its KIE-safe cap`).toBeLessThanOrEqual(m.maxOutputTokens)
+    }
+  })
+
+  it("a reasoning floor never sits below the model's default cap, and is declared only below the default", () => {
+    for (const m of LLM_MODELS) {
+      // A floor under maxOutputTokens would LOWER a call's cap — not a floor.
+      expect(reasoningOutputFloor(m), m.id).toBeGreaterThanOrEqual(m.maxOutputTokens)
+      // Declaring the default is noise that hides which models are lane-limited.
+      if (m.reasoningOutputFloor !== undefined) {
+        expect(m.reasoningOutputFloor, m.id).toBeLessThan(REASONING_OUTPUT_FLOOR)
+      }
+    }
+  })
+
   it("gemini-3.6-flash exposes the KIE low/high thinking levels; claude-fable-5 the full Claude ladder", () => {
     expect(getLlmModel("gemini-3.6-flash")?.reasoningEfforts).toEqual(["low", "high"])
     expect(getLlmModel("claude-fable-5")?.reasoningEfforts).toEqual(["low", "medium", "high", "xhigh", "max"])
@@ -737,17 +772,19 @@ describe("gpt-6-astra exposure", () => {
     expect(buildLlmCreditIdentifier("llm-chat", "gpt-6-astra", "xhigh")).toBe("llm-chat:premium")
   })
 
-  it("is the ONLY model declaring kieCollapseStream — the condition is per model, not per lane", () => {
+  it("names EXACTLY the models KIE's non-stream responses lane fails for — the condition is per model, not per lane", () => {
     // KIE's non-stream responses endpoint 500s ~2 calls in 3 for astra
-    // (measured 2026-09-06: 2/6 non-stream vs 5/6 streaming) while serving
-    // gpt-5.4/5.5/5.6 fine, so llm-client collapses the streaming wire for
-    // THIS model only. If a second model ever legitimately needs it, add it
-    // here deliberately — a flag that spreads by copy-paste would quietly move
-    // every affected model's provider cost onto the rate-table estimate,
-    // because SSE does not reliably carry `credits_consumed`.
+    // (measured 2026-09-06: 2/6 non-stream vs 5/6 streaming), and on
+    // 2026-09-17 a live gpt-5.6-sol call returned the same `server_error`,
+    // retiring the 2026-07-14 "the GPT-5.6 family is fine non-stream" reading.
+    // So llm-client collapses the streaming wire for THESE models only. Adding
+    // a third is a deliberate act, never copy-paste: the flag moves a model's
+    // provider cost onto the rate-table estimate, because SSE does not reliably
+    // carry `credits_consumed`.
+    const collapsed = LLM_MODELS.filter((m) => m.kieCollapseStream !== undefined).map((m) => m.id)
+    expect(collapsed.sort()).toEqual(["gpt-5.6-sol", "gpt-6-astra"])
     expect(getLlmModel("gpt-6-astra")?.kieCollapseStream).toBe(true)
-    const others = LLM_MODELS.filter((m) => m.id !== "gpt-6-astra")
-    expect(others.filter((m) => m.kieCollapseStream !== undefined).map((m) => m.id)).toEqual([])
+    expect(getLlmModel("gpt-5.6-sol")?.kieCollapseStream).toBe(true)
   })
 })