@nodaro/prompts 1.30.0 → 1.33.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodaro/prompts",
-  "version": "1.30.0",
+  "version": "1.33.0",
   "description": "Nodaro's prompt-engineering layer — person/picker catalogs with prompt hints, identity-lock clauses, entity prompt builders, brand presets, and prompt/reference assembly shared by the Nodaro platform and SDK.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",
@@ -20,7 +20,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@nodaro/shared": "^3.19.0"
+    "@nodaro/shared": "^3.24.0"
   },
   "devDependencies": {
     "tsup": "^8.5.0",

package/src/__tests__/i18n-entry-completeness.test.ts

@@ -270,3 +270,35 @@ describe("targeted gap coverage: facial-geometry + brand camera/render entries",
     }
   })
 })
+
+// ---------------------------------------------------------------------------
+// Test 4 — the Camera Motion and Transition pickers carry a LABEL for every
+// option in Japanese and Brazilian Portuguese. Fourteen camera motions (Dolly
+// In, Zoom In, POV, …) had a translated description but no label in pt-BR, so
+// the editor and the docs gallery (which syncs these sidecars) showed the
+// English name. A rig or brand name keeps its canonical form as an explicit
+// label (Steadicam, Snorricam) — a present label is the decision; a missing one
+// is the bug. Scoped to the two locales whose docs pages are held to "no English
+// apart from model names"; extend the list when another locale is held to it.
+// ---------------------------------------------------------------------------
+
+const FULL_LABEL_CATALOGS = ["camera-motions", "transitions"] as const
+const FULL_LABEL_LOCALES: readonly LocaleId[] = ["ja", "pt-BR"]
+
+describe("Camera Motion and Transition labels are complete in ja and pt-BR", () => {
+  const cases: Array<[string, LocaleId]> = []
+  for (const catalogId of FULL_LABEL_CATALOGS) {
+    for (const locale of FULL_LABEL_LOCALES) cases.push([catalogId, locale])
+  }
+
+  it.each(cases)("%s [%s] labels every entry", (catalogId, locale) => {
+    const catalog = CATALOGS.find((c) => c.catalogId === catalogId)
+    expect(catalog, `${catalogId} is not a registered picker catalog`).toBeDefined()
+    const map = mapFor(catalogId, locale)
+    const unlabelled = (catalog?.options ?? []).filter((o) => !has(map[o.id]?.label)).map((o) => o.id)
+    expect(
+      unlabelled,
+      `packages/shared/src/i18n/${catalogId}.${locale}.ts has no label for these ids, so the picker shows the English name`,
+    ).toEqual([])
+  })
+})

package/src/__tests__/node-send-text.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from "vitest"
+import { TEXT_REQUIRED_NODE_TYPES, computeAiWriterInput, computeNodeSendText } from "../node-send-text.js"
+
+/**
+ * "What text would this node send?" — answered by the executor's own prompt
+ * rule per type, so the orchestrator's empty-input skip can never disagree
+ * with the request the node would make.
+ */
+const none = new Map<string, string>()
+
+describe("computeNodeSendText", () => {
+  it("answers for every text-requiring type and for no other (totality)", () => {
+    for (const type of TEXT_REQUIRED_NODE_TYPES) {
+      expect(typeof computeNodeSendText(type, {}, { refMap: none }), type).toBe("string")
+    }
+    // Video nodes and social posts stay out: an empty prompt on an image-to-video is a legal request, an empty caption the author's choice.
+    expect(computeNodeSendText("image-to-video", {}, { refMap: none })).toBeUndefined()
+    expect(computeNodeSendText("combine-text", { text: "x" }, { refMap: none })).toBeUndefined()
+    expect(computeNodeSendText("telegram-post", {}, { refMap: none })).toBeUndefined()
+  })
+
+  it("llm-chat: the wired text when the node typed none; nothing when both are empty; a typed prompt runs on its own", () => {
+    expect(computeNodeSendText("llm-chat", {}, { wired: "the posts", refMap: none })).toBe("the posts")
+    expect(computeNodeSendText("llm-chat", {}, { wired: "", refMap: none })).toBe("")
+    expect(computeNodeSendText("llm-chat", {}, { refMap: none })).toBe("")
+    expect(computeNodeSendText("llm-chat", { userInput: "Write a poem" }, { wired: "", refMap: none })).toContain("Write a poem")
+  })
+
+  it("llm-chat: a fan-out item outranks the wire", () => {
+    expect(computeNodeSendText("llm-chat", {}, { override: "item 1", wired: "all", refMap: none })).toBe("item 1")
+  })
+
+  it("llm-chat: a typed template whose {Ref} resolves to nothing is still a non-empty request (the stated residual)", () => {
+    const refMap = new Map([["Feed", ""]])
+    const text = computeNodeSendText("llm-chat", { userInput: "Summarize: {Feed}" }, { wired: "", refMap })
+    expect(text?.trim().length).toBeGreaterThan(0)
+  })
+
+  it("ai-writer: a fan-out item, else the wire, else the typed userInput, else the legacy prompt", () => {
+    expect(computeAiWriterInput({ userInput: "typed", prompt: "legacy" }, { override: "item", wired: "wire" })).toBe("item")
+    expect(computeAiWriterInput({ userInput: "typed", prompt: "legacy" }, { wired: "wire" })).toBe("wire")
+    expect(computeAiWriterInput({ userInput: "typed", prompt: "legacy" }, { wired: "  " })).toBe("typed")
+    expect(computeAiWriterInput({ prompt: "legacy" }, {})).toBe("legacy")
+    expect(computeAiWriterInput({}, { wired: "" })).toBe("")
+    expect(computeNodeSendText("ai-writer", {}, { wired: "", refMap: none })).toBe("")
+  })
+
+  it("generate-script: the topic is the wire or the typed prompt", () => {
+    expect(computeNodeSendText("generate-script", { prompt: "a cat" }, { refMap: none })).toContain("a cat")
+    expect(computeNodeSendText("generate-script", {}, { wired: "", refMap: none })).toBe("")
+  })
+
+  it("generate-music: typed lyrics count as something to send when the prompt is empty", () => {
+    expect(computeNodeSendText("generate-music", { lyrics: "la la" }, { wired: "", refMap: none })).toBe("la la")
+    expect(computeNodeSendText("generate-music", {}, { wired: "", refMap: none })).toBe("")
+  })
+
+  it("collection-write: the item (a fan-out row, else the wire), else a typed title / text / link; nothing of those is nothing to save", () => {
+    const refMap = new Map<string, string>()
+    expect(computeNodeSendText("collection-write", {}, { wired: "", refMap })).toBe("")
+    expect(computeNodeSendText("collection-write", { title: " " }, { wired: "", refMap })).toBe("")
+    expect(computeNodeSendText("collection-write", { link: "https://news.example.test/daily" }, { wired: "", refMap })).toBe("https://news.example.test/daily")
+    expect(computeNodeSendText("collection-write", { title: "Daily" }, { wired: "the wire", refMap })).toBe("the wire")
+    expect(computeNodeSendText("collection-write", {}, { override: "row 3", wired: "the wire", refMap })).toBe("row 3")
+  })
+
+  it("collection-write: a typed field counts with its {Node} references resolved, as the engines send it (#1890)", () => {
+    const empty = new Map<string, string>()
+    // A feed with nothing new: an empty fallback is nothing to save, so the node skips.
+    expect(computeNodeSendText("collection-write", { title: "{Feed || }" }, { wired: "", refMap: empty })).toBe("")
+    expect(computeNodeSendText("collection-write", { title: "{Feed || untitled}" }, { wired: "", refMap: empty })).toBe("untitled")
+    expect(computeNodeSendText("collection-write", { title: "Breaking: {Feed}" }, { wired: "", refMap: new Map([["feed", "Telegram turns ten"]]) }))
+      .toBe("Breaking: Telegram turns ten")
+  })
+
+  it("prompt pre/post text never counts as something to send: an empty core with a prefix is nothing", () => {
+    const refMap = new Map<string, string>()
+    const affixed = { userInput: "", promptPrefix: "Write a news item about:", promptSuffix: "Keep it short." }
+    expect(computeNodeSendText("llm-chat", affixed, { wired: "", refMap })).toBe("")
+    expect(computeNodeSendText("generate-script", { prompt: "", promptPrefix: "Topic:" }, { wired: "", refMap })).toBe("")
+    expect(computeNodeSendText("text-to-speech", { promptPrefix: "Say:" }, { wired: "", refMap })).toBe("")
+    // With a core, the decision is on the core — non-empty either way.
+    expect(computeNodeSendText("llm-chat", affixed, { wired: "the posts", refMap })).not.toBe("")
+  })
+
+  it("generate-image: the prompt it would send (a fan-out row, else the wire, else the typed prompt); nothing of those is nothing", () => {
+    const refMap = new Map<string, string>()
+    expect(computeNodeSendText("generate-image", { prompt: "" }, { wired: "", refMap })).toBe("")
+    expect(computeNodeSendText("generate-image", { prompt: "a city at dusk" }, { wired: "", refMap })).toBe("a city at dusk")
+    expect(computeNodeSendText("generate-image", { prompt: "" }, { wired: "a cover for the story", refMap })).toBe("a cover for the story")
+    expect(computeNodeSendText("generate-image", { prompt: "", promptPrefix: "Photo of" }, { wired: "", refMap })).toBe("")
+  })
+
+  it("text-to-speech / text-to-audio: the wired text passes through; nothing wired and nothing typed is nothing", () => {
+    expect(computeNodeSendText("text-to-speech", {}, { wired: "read this", refMap: none })).toContain("read this")
+    expect(computeNodeSendText("text-to-speech", {}, { wired: "", refMap: none })).toBe("")
+    expect(computeNodeSendText("text-to-audio", {}, { wired: "rain", refMap: none })).toContain("rain")
+    expect(computeNodeSendText("text-to-audio", {}, { refMap: none })).toBe("")
+  })
+})

package/src/__tests__/transitions-blended-cut.test.ts

@@ -321,5 +321,7 @@ describe("blended cut — the rule holds for every row and lever (self-consisten
         check([a, b], levers(position, duration, "natural"), "clip")
       }
     }
-  })
+    // An exhaustive sweep: under a second locally, but past vitest's 5 s default
+    // on a loaded 2-vCPU CI runner (it timed out there three times on 2026-10-05).
+  }, 60_000)
 })

package/src/audio-tags.ts

@@ -0,0 +1,36 @@
+/**
+ * Remove inline `[audio tags]` from speech text, for a model that does not
+ * perform them (it would read them aloud). Pure, dependency-free: the
+ * backend's credit counter (lib/speech-credits.ts), its payload builder and
+ * the editor's estimate (frontend/src/lib/speech-estimate.ts) all read it, so
+ * the two engines count exactly the same characters.
+ *
+ * A tag is `[`, one or more characters that are not `]`, then `]` — what
+ * `/\[[^\]]+\]/g` matches. That pattern is quadratic on an unclosed run of `[`
+ * (every `[` rescans to the end of the text), and the credit counter runs this
+ * on raw request text on the API and orchestrator event loops, so the scan is
+ * written by hand: one `indexOf` per `[`, and when no `]` is left no later `[`
+ * can match either, so the rest of the text is kept in one slice.
+ */
+function removeBracketTags(text: string): string {
+  let out = ""
+  let from = 0
+  let open = text.indexOf("[")
+  while (open !== -1) {
+    const close = text.indexOf("]", open + 1)
+    if (close === -1) break
+    if (close === open + 1) {
+      // "[]" is not a tag (needs 1+ characters); the "[" stays and the scan moves on.
+      open = text.indexOf("[", open + 1)
+      continue
+    }
+    out += text.slice(from, open)
+    from = close + 1
+    open = text.indexOf("[", from)
+  }
+  return out + text.slice(from)
+}
+
+export function stripAudioTags(text: string): string {
+  return removeBracketTags(text).replace(/\s{2,}/g, " ").trim()
+}

package/src/index.ts

@@ -86,6 +86,7 @@ export * from "./image-reference-doctrine.js"
 export * from "./scene3d-reference-doctrine.js"
 export * from "./prompt-wizard-categories.js"
 export * from "./resolve-prompt.js"
+export { stripAudioTags } from "./audio-tags.js"
 export * from "./node-prompt-fields.js"
 export * from "./factory-presets.js"
 export * from "./caption-treatments.js"
@@ -104,3 +105,6 @@ export * from "./ad-creative-analysis.js"
 
 // --- Picker art: option pictures + topic icons (editor and API) ---
 export * from "./picker-art/index.js"
+
+// --- What a text-requiring node would send (the orchestrator's empty-input skip reads it) ---
+export * from "./node-send-text.js"

package/src/node-send-text.ts

@@ -0,0 +1,125 @@
+import { resolveNodeRefs, SOCIAL_POST_NODE_TYPES } from "@nodaro/shared"
+import { computeLlmChatFields, computeNodePrompt, computeScriptTopic } from "./resolve-prompt.js"
+
+/**
+ * Output nodes that send exactly what is WIRED into them — a webhook's
+ * parameters, a social post's caption and media. When every wire produced
+ * nothing in this run (a Filter List that kept no row, a node that was itself
+ * skipped), there is nothing to send: the node is skipped with
+ * `skipReason: "empty_input"` instead of posting an empty payload (a site that
+ * validates its input answers 400 and alerts its owner) or failing the run
+ * (a publish route refuses a post with no text and no media). A typed caption
+ * with no wire at all is the author's choice and still runs, as before. ONE
+ * list, read by the orchestrator's skip rule (`empty-input-skips.ts`).
+ */
+export const WIRED_OUTPUT_NODE_TYPES: ReadonlySet<string> = new Set(["webhook-output", ...SOCIAL_POST_NODE_TYPES])
+
+/**
+ * Node types that send TEXT to a model or a voice and fail on an empty one —
+ * `userInput: Too small` (llm-chat), "no text found" (text-to-speech) — so a
+ * run with nothing upstream can skip them instead of failing. Never an image
+ * or video node (an empty prompt is a legal request there) and never a social
+ * post (an empty caption is the author's choice). ONE list, read by the
+ * orchestrator's skip rule (`empty-input-skips.ts`); the engine never names a
+ * type on its own.
+ */
+export const TEXT_REQUIRED_NODE_TYPES: ReadonlySet<string> = new Set([
+  "llm-chat",
+  "ai-writer",
+  "generate-script",
+  "text-to-speech",
+  "generate-music",
+  "text-to-audio",
+  // Save to Collection refuses an empty record ("nothing to save"): a feed
+  // with nothing new wired straight into it must skip it, not fail the run.
+  "collection-write",
+  // Generate Image: an empty prompt is a legal request in general (references
+  // alone), but when the text it was WIRED produced nothing this run — the skip
+  // rule's precondition — an empty prompt is a paid picture of nothing.
+  "generate-image",
+])
+
+/**
+ * The node's data without its prompt pre/post text: the skip decision is about
+ * the CORE text. A prefix alone ("Write a news item about:") is not something
+ * to send — with the affixes applied, an empty core read as non-empty and an
+ * idle tick paid for a model call on the prefix.
+ */
+const withoutAffixes = (data: Record<string, unknown>): Record<string, unknown> => ({ ...data, promptPrefix: undefined, promptSuffix: undefined })
+
+export interface NodeSendTextArgs {
+  /** A list fan-out item (highest precedence). */
+  override?: string
+  /** The text wired into the node's main text input. */
+  wired?: string
+  /** llm-chat only: the text wired into `system-prompt`. */
+  wiredSystemPrompt?: string
+  refMap: ReadonlyMap<string, string>
+}
+
+const present = (s?: string): s is string => typeof s === "string" && s.trim().length > 0
+
+/**
+ * ai-writer's user input — the rule its sync-HTTP body applies: a fan-out
+ * item, else the wired text, else the typed `userInput`, else the legacy
+ * `prompt`. (ai-writer is renamed to llm-chat on load; saved graphs that
+ * never reloaded still run it.)
+ */
+export function computeAiWriterInput(
+  data: Record<string, unknown>,
+  { override, wired }: Pick<NodeSendTextArgs, "override" | "wired">,
+): string {
+  return [override, wired, data.userInput as string | undefined, data.prompt as string | undefined].find(present) ?? ""
+}
+
+/**
+ * The text a text-requiring node would send, by the SAME rule its executor
+ * uses (`computeLlmChatFields`, `computeScriptTopic`, `computeNodePrompt`,
+ * `computeAiWriterInput`) — so "would this node run on nothing?" is answered
+ * by the function that decides what it sends, not by a second reading of it.
+ * Undefined for any other node type.
+ */
+export function computeNodeSendText(
+  nodeType: string,
+  data: Record<string, unknown>,
+  args: NodeSendTextArgs,
+): string | undefined {
+  const bare = withoutAffixes(data)
+  switch (nodeType) {
+    case "llm-chat":
+      return computeLlmChatFields(bare, {
+        override: args.override,
+        wiredUserInput: args.wired,
+        wiredSystemPrompt: args.wiredSystemPrompt,
+        refMap: args.refMap,
+      }).userInput
+    case "ai-writer":
+      return computeAiWriterInput(bare, args)
+    case "generate-script":
+      return computeScriptTopic(bare, { override: args.override, wired: args.wired, refMap: args.refMap })
+    case "generate-music": {
+      // A music node sings typed lyrics with no prompt; only both empty is nothing to send.
+      const prompt = computeNodePrompt(nodeType, bare, { override: args.override, wired: args.wired, refMap: args.refMap })
+      return present(prompt) ? prompt : present(data.lyrics as string | undefined) ? (data.lyrics as string) : ""
+    }
+    case "text-to-speech":
+    case "text-to-audio":
+    case "generate-image":
+      return computeNodePrompt(nodeType, bare, { override: args.override, wired: args.wired, refMap: args.refMap })
+    case "collection-write": {
+      // The record's content: the item (a fan-out row, else what reached `in`),
+      // else a title, text or link typed on the node. A picture alone is a
+      // record too, but it never starves the node: only a wired TEXT input that
+      // produced nothing can (the skip rule's precondition).
+      // A typed field counts as the engines send it, its `{Node}` references
+      // resolved: `{Feed || }` over a feed with nothing new is empty, so the
+      // node skips instead of failing with an empty record (#1890).
+      const typed = [data.title, data.text, data.link]
+        .map((v) => (typeof v === "string" ? resolveNodeRefs(v, args.refMap) : v))
+        .find((v): v is string => present(v as string | undefined))
+      return [args.override, args.wired, typed].find(present) ?? ""
+    }
+    default:
+      return undefined
+  }
+}