@nodaro/shared 3.10.0 → 3.12.0

package/src/__tests__/trigger-feeds.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "vitest"
+import { buildFeedMaps, nodeFeedsAnything } from "../trigger-feeds.js"
+
+const node = (id: string, extra: Record<string, unknown> = {}) => ({ id, ...extra })
+const edge = (source: string, target: string) => ({ source, target })
+
+describe("buildFeedMaps — every way one node feeds another", () => {
+  it("a drawn edge feeds; an edge whose end left the graph feeds nothing; a self-loop feeds nothing", () => {
+    const { children, parents } = buildFeedMaps([node("a"), node("b")], [edge("a", "b"), edge("a", "gone"), edge("gone", "b"), edge("b", "b")])
+    expect(children.get("a")).toEqual(["b"])
+    expect(children.get("b")).toBeUndefined()
+    expect(parents.get("b")).toEqual(["a"])
+    expect(children.has("gone")).toBe(false)
+  })
+
+  it("a node inside a Group feeds the group", () => {
+    const { children } = buildFeedMaps([node("img", { parentId: "G" }), node("G")], [])
+    expect(children.get("img")).toEqual(["G"])
+  })
+
+  it("a field mapping feeds its node by sourceNodeId, even with no edge", () => {
+    const { children, parents } = buildFeedMaps(
+      [node("style"), node("img", { data: { fieldMappings: { prompt: { sourceNodeId: "style" }, seed: { sourceNodeId: "gone" } } } })],
+      [],
+    )
+    expect(children.get("style")).toEqual(["img"])
+    expect(parents.get("img")).toEqual(["style"])
+  })
+})
+
+describe("nodeFeedsAnything — the editor's 'is this trigger wired?'", () => {
+  it("agrees with the maps in both directions", () => {
+    const nodes = [node("sched"), node("img"), node("G"), node("member", { parentId: "G" })]
+    expect(nodeFeedsAnything(nodes, [edge("sched", "img")], "sched")).toBe(true)
+    expect(nodeFeedsAnything(nodes, [edge("sched", "gone")], "sched")).toBe(false)
+    expect(nodeFeedsAnything(nodes, [], "member")).toBe(true)
+    expect(nodeFeedsAnything(nodes, [], "sched")).toBe(false)
+  })
+})

package/src/__tests__/video-analysis.test.ts

@@ -62,6 +62,21 @@ const dreamVariation = {
   refImageUrl: "https://cdn.example/frames/hero-dream.jpg",
 }
 
+describe("owned objects (2026-09-17)", () => {
+  it("entitySlotSchema round-trips owner { slotId, relation }", () => {
+    const owner = { slotId: "man-blue", relation: "worn by" }
+    const parsed = entitySlotSchema.parse({ ...slot, owner })
+    expect(parsed.owner).toEqual(owner)
+  })
+  it("absent owner stays absent", () => {
+    expect("owner" in entitySlotSchema.parse(slot)).toBe(false)
+  })
+  it("rejects an owner without a relation or with a malformed slot id", () => {
+    expect(entitySlotSchema.safeParse({ ...slot, owner: { slotId: "man-blue" } }).success).toBe(false)
+    expect(entitySlotSchema.safeParse({ ...slot, owner: { slotId: "Man Blue", relation: "worn by" } }).success).toBe(false)
+  })
+})
+
 describe("appearance variations (cast-variations spec §4)", () => {
   it("entitySlotSchema round-trips variations[] including refImageUrl", () => {
     const parsed = entitySlotSchema.parse({ ...slot, variations: [dreamVariation] })

package/src/__tests__/video-duration-auto.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from "vitest"
+import {
+  VIDEO_DURATION_AUTO,
+  isAutoVideoDuration,
+  supportsAutoVideoDuration,
+  maxVideoDurationSec,
+  pricedOutputDurationSec,
+  buildVideoCreditModelIdentifier,
+  normalizeModelInput,
+  validateModelInput,
+  MODEL_CATALOG,
+  SEEDANCE_2_PROVIDERS,
+} from "../index.js"
+
+/**
+ * Auto duration (`duration: -1`) — the model picks the clip length. The risk is
+ * entirely on the billing side: `commit_credits` refunds a surplus but never
+ * collects a deficit, so an Auto run must be PRICED at the longest clip the
+ * model can render, on every lane, by default.
+ */
+describe("auto video duration", () => {
+  it("is KIE's own sentinel, from a number or a string", () => {
+    expect(VIDEO_DURATION_AUTO).toBe(-1)
+    expect(isAutoVideoDuration(-1)).toBe(true)
+    expect(isAutoVideoDuration("-1")).toBe(true)
+    for (const v of [undefined, null, 0, 1, 8, "8", "auto", NaN]) expect(isAutoVideoDuration(v), String(v)).toBe(false)
+  })
+
+  it("is a catalog capability of exactly the Seedance 2 family", () => {
+    const declared = Object.keys(MODEL_CATALOG).filter((id) => MODEL_CATALOG[id]!.autoDuration === true).sort()
+    expect(declared).toEqual([...SEEDANCE_2_PROVIDERS].sort())
+    for (const id of declared) expect(supportsAutoVideoDuration(id)).toBe(true)
+    expect(supportsAutoVideoDuration("kling-3.0")).toBe(false)
+    expect(supportsAutoVideoDuration(undefined)).toBe(false)
+  })
+
+  it("prices at the model's LONGEST clip — the top tier is also the catalog's longest duration", () => {
+    for (const id of SEEDANCE_2_PROVIDERS) {
+      const ceiling = maxVideoDurationSec(id)!
+      expect(ceiling, id).toBe(Math.max(...MODEL_CATALOG[id]!.durations!))
+      expect(pricedOutputDurationSec(id, VIDEO_DURATION_AUTO), id).toBe(ceiling)
+      expect(pricedOutputDurationSec(id, "-1"), id).toBe(ceiling)
+    }
+    expect(pricedOutputDurationSec("seedance-2-5", -1)).toBe(30)
+    expect(pricedOutputDurationSec("seedance-2", -1)).toBe(15)
+  })
+
+  it("never prices the cheapest tier for Auto (the under-reserve this guards)", () => {
+    expect(buildVideoCreditModelIdentifier("seedance-2-5", -1, undefined, undefined, undefined, "480p")).toBe("seedance-2-5:30s:480p")
+    expect(buildVideoCreditModelIdentifier("seedance-2", -1, undefined, undefined, undefined, "720p", true)).toBe("seedance-2:15s:720p-ref")
+  })
+
+  it("a model without the capability prices its render default, not a ceiling it will not render", () => {
+    expect(pricedOutputDurationSec("minimax-h3", -1)).toBe(pricedOutputDurationSec("minimax-h3", undefined))
+    expect(pricedOutputDurationSec("seedance-2-5", 0)).toBe(pricedOutputDurationSec("seedance-2-5", undefined))
+  })
+
+  it("passes the catalog normalizer and validator only where declared", () => {
+    expect(normalizeModelInput("seedance-2-5", { duration: -1 }).duration).toBe(-1)
+    expect(validateModelInput("seedance-2-5", { duration: -1 })).toBeNull()
+    const other = Object.keys(MODEL_CATALOG).find((id) => MODEL_CATALOG[id]!.durations && !MODEL_CATALOG[id]!.autoDuration)!
+    expect(normalizeModelInput(other, { duration: -1 }).duration).toBe(MODEL_CATALOG[other]!.durations![0])
+    expect(validateModelInput(other, { duration: -1 })?.field).toBe("duration")
+  })
+})

package/src/__tests__/video-duration.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from "vitest"
+import { editPlanSourceDurationSec, extractVideoDurationFromNode } from "../video-duration.js"
+
+describe("editPlanSourceDurationSec", () => {
+  it("reads a video node's own length first", () => {
+    expect(editPlanSourceDurationSec({ duration: 90 })).toBe(90)
+    expect(editPlanSourceDurationSec({ activeResultIndex: 0, generatedResults: [{ duration: 42 }] })).toBe(42)
+    expect(extractVideoDurationFromNode({ duration: 90 })).toBe(90)
+  })
+
+  it("reads the audio lane's metadata.durationSeconds (upload-audio: unstamped, trusted as ever)", () => {
+    expect(editPlanSourceDurationSec({ url: "https://cdn/a.mp3", metadata: { durationSeconds: 2700 } })).toBe(2700)
+  })
+
+  it("rejects nonsense lengths", () => {
+    for (const bad of [0, -1, Number.NaN, Number.POSITIVE_INFINITY, "2700", null]) {
+      expect(editPlanSourceDurationSec({ metadata: { durationSeconds: bad } })).toBeUndefined()
+    }
+    expect(editPlanSourceDurationSec(undefined)).toBeUndefined()
+    expect(editPlanSourceDurationSec({})).toBeUndefined()
+  })
+})
+
+// The read-side invariant. A length stamped with the media it was measured from
+// is trusted only while that media is still the node's — so NO writer can make
+// it stale: not a copilot patch, an MCP workflow-JSON write, an import, a
+// run-time override, nor code that has not been written yet. A mismatch reads as
+// "unknown", and every caller then falls to its safe side instead of
+// under-bucketing a longer file.
+describe("editPlanSourceDurationSec — a stamped length is bound to its media", () => {
+  const stamped = (mediaUrl: string) => ({ durationSeconds: 720, mediaUrl })
+
+  it("trusts the length while the stamp matches the node's extracted audio", () => {
+    expect(
+      editPlanSourceDurationSec({ extractedAudioUrl: "https://cdn/ep41.mp3", metadata: stamped("https://cdn/ep41.mp3") }),
+    ).toBe(720)
+  })
+
+  it("ignores it once the media was swapped underneath — whoever swapped it", () => {
+    // e.g. copilot `patchNodes { extractedAudioUrl }` / MCP update_workflow_json:
+    // a shallow merge that replaces the url and carries `metadata` along.
+    expect(
+      editPlanSourceDurationSec({ extractedAudioUrl: "https://host/ep42-3h.mp3", metadata: stamped("https://cdn/ep41.mp3") }),
+    ).toBeUndefined()
+  })
+
+  it("ignores it when the media was cleared", () => {
+    expect(editPlanSourceDurationSec({ extractedAudioUrl: "", metadata: stamped("https://cdn/ep41.mp3") })).toBeUndefined()
+    expect(editPlanSourceDurationSec({ metadata: stamped("https://cdn/ep41.mp3") })).toBeUndefined()
+  })
+
+  it("accepts a stamp matching the node's `url` field too (upload-style nodes)", () => {
+    expect(editPlanSourceDurationSec({ url: "https://cdn/a.mp3", metadata: stamped("https://cdn/a.mp3") })).toBe(720)
+    expect(editPlanSourceDurationSec({ url: "https://cdn/b.mp3", metadata: stamped("https://cdn/a.mp3") })).toBeUndefined()
+  })
+})

package/src/__tests__/video-frame-fit.test.ts

@@ -0,0 +1,189 @@
+import { describe, it, expect } from "vitest"
+import {
+  computeFrameFitPlan,
+  resolveFrameFitAspect,
+  resolveFrameDelivery,
+  minimalRatioDimensions,
+  centreCropToAspect,
+  parseAspectToken,
+  FRAME_FIT_STRETCH_TOLERANCE,
+} from "../video-frame-fit.js"
+import { resolveOutputCanvas, measuredCanvasCombinations } from "../video-output-canvas.js"
+
+/** The image behind every number in this file: a 1K 9:16 GPT image. */
+const GPT_1K = { sourceWidth: 940, sourceHeight: 1672 }
+
+describe("measured output canvases", () => {
+  it("answers the combinations we measured, case-insensitively on resolution", () => {
+    expect(resolveOutputCanvas("seedance-2-5", "720p", "9:16")).toEqual([720, 1280])
+    expect(resolveOutputCanvas("minimax-h3", "768P", "9:16")).toEqual([768, 1344])
+    expect(resolveOutputCanvas("minimax-h3", "2K", "16:9")).toEqual([2560, 1440])
+  })
+
+  it("keeps the 2.0 family apart from 2.5 at 480p — they really do differ", () => {
+    expect(resolveOutputCanvas("seedance-2-5", "480p", "16:9")).toEqual([854, 480])
+    expect(resolveOutputCanvas("seedance-2-fast", "480p", "16:9")).toEqual([864, 496])
+  })
+
+  it("answers undefined for anything never measured", () => {
+    expect(resolveOutputCanvas("seedance-2-5", "4k", "9:16")).toBeUndefined()
+    expect(resolveOutputCanvas("kling-3.0", "720p", "16:9")).toBeUndefined()
+    expect(resolveOutputCanvas(undefined, "720p", "9:16")).toBeUndefined()
+  })
+
+  it("stores only even, positive dimensions", () => {
+    for (const { provider, resolution, aspect, canvas } of measuredCanvasCombinations()) {
+      const where = `${provider} ${resolution} ${aspect}`
+      expect(canvas[0] % 2, where).toBe(0)
+      expect(canvas[1] % 2, where).toBe(0)
+      expect(canvas[0] > 0 && canvas[1] > 0, where).toBe(true)
+    }
+  })
+
+  it("does not claim a canvas whose ratio is wildly off the label", () => {
+    // H3's 768P 9:16 really is 0.5714 — a 1.6% lie we keep on purpose. Anything
+    // further out is a typo, not a provider quirk.
+    for (const { provider, resolution, aspect, canvas } of measuredCanvasCombinations()) {
+      const label = parseAspectToken(aspect)
+      if (label === undefined) continue
+      const actual = canvas[0] / canvas[1]
+      expect(Math.abs(actual - label) / label, `${provider} ${resolution} ${aspect}`).toBeLessThan(0.06)
+    }
+  })
+})
+
+describe("aspect resolution", () => {
+  it("uses an explicit ratio as-is", () => {
+    expect(resolveFrameFitAspect({ provider: "seedance-2-5", requestedAspect: "16:9", ...GPT_1K })).toBe("16:9")
+  })
+
+  it("snaps adaptive and Auto to the model's nearest listed ratio", () => {
+    // 940x1672 = 0.5622, which is 9:16 to within 0.05%.
+    expect(resolveFrameFitAspect({ provider: "seedance-2-5", requestedAspect: "adaptive", ...GPT_1K })).toBe("9:16")
+    expect(resolveFrameFitAspect({ provider: "seedance-2-5", requestedAspect: "Auto", ...GPT_1K })).toBe("9:16")
+    expect(resolveFrameFitAspect({ provider: "seedance-2-5", requestedAspect: undefined, sourceWidth: 1920, sourceHeight: 1080 })).toBe("16:9")
+  })
+
+  it("gives up when the model declares no ratios", () => {
+    expect(resolveFrameFitAspect({ provider: "not-a-model", requestedAspect: "adaptive", ...GPT_1K })).toBeUndefined()
+  })
+})
+
+describe("computeFrameFitPlan", () => {
+  it("resizes the 1K image to the measured canvas — the case that fixed the snap", () => {
+    const plan = computeFrameFitPlan({
+      fit: "resolution", provider: "seedance-2-5", resolution: "720p", aspect: "9:16", ...GPT_1K,
+    })
+    expect(plan).toEqual({ width: 720, height: 1280, reason: "resolution" })
+  })
+
+  it("targets H3's real 768x1344 canvas rather than a true 9:16", () => {
+    const plan = computeFrameFitPlan({
+      fit: "resolution", provider: "minimax-h3", resolution: "768P", aspect: "9:16", ...GPT_1K,
+    })
+    expect(plan?.width).toBe(768)
+    expect(plan?.height).toBe(1344)
+    expect(plan?.crop).toBeUndefined()   // 1.6% gap is inside the tolerance → stretch
+  })
+
+  it("does nothing when the frame is already the canvas", () => {
+    expect(computeFrameFitPlan({
+      fit: "resolution", provider: "seedance-2-5", resolution: "720p", aspect: "9:16",
+      sourceWidth: 720, sourceHeight: 1280,
+    })).toBeNull()
+  })
+
+  it("does nothing in original mode, whatever the size", () => {
+    expect(computeFrameFitPlan({
+      fit: "original", provider: "seedance-2-5", resolution: "720p", aspect: "9:16", ...GPT_1K,
+    })).toBeNull()
+  })
+
+  it("degrades resolution → ratio when the combination was never measured", () => {
+    const plan = computeFrameFitPlan({
+      fit: "resolution", provider: "seedance-2-5", resolution: "4k", aspect: "16:9",
+      sourceWidth: 1000, sourceHeight: 1000,
+    })
+    // No 4k canvas on file, so it falls back to the minimal change that makes 16:9.
+    expect(plan?.reason).toBe("ratio")
+    expect(plan!.width / plan!.height).toBeCloseTo(16 / 9, 2)
+  })
+
+  it("degrades to nothing when neither a canvas nor an aspect can be resolved", () => {
+    expect(computeFrameFitPlan({
+      fit: "resolution", provider: "not-a-model", resolution: "720p", aspect: undefined, ...GPT_1K,
+    })).toBeNull()
+  })
+
+  it("stretches inside the tolerance and crops outside it", () => {
+    // 4% off 9:16 — inside 5%, so a plain stretch, no crop.
+    const inside = computeFrameFitPlan({
+      fit: "ratio", provider: "seedance-2-5", resolution: "720p", aspect: "9:16",
+      sourceWidth: 1000, sourceHeight: 1710,
+    })
+    expect(Math.abs(1000 / 1710 - 9 / 16) / (9 / 16)).toBeLessThan(FRAME_FIT_STRETCH_TOLERANCE)
+    expect(inside?.crop).toBeUndefined()
+
+    // A square photo into 9:16 is a 78% gap — crop first, never squash.
+    const outside = computeFrameFitPlan({
+      fit: "resolution", provider: "seedance-2-5", resolution: "720p", aspect: "9:16",
+      sourceWidth: 1024, sourceHeight: 1024,
+    })
+    expect(outside).toMatchObject({ width: 720, height: 1280, reason: "resolution" })
+    expect(outside?.crop).toEqual({ left: 224, top: 0, width: 576, height: 1024 })
+    expect(outside!.crop!.width / outside!.crop!.height).toBeCloseTo(9 / 16, 3)
+  })
+
+  it("produces even dimensions (yuv420p rejects odd ones)", () => {
+    const plan = computeFrameFitPlan({
+      fit: "ratio", provider: "seedance-2-5", resolution: "720p", aspect: "16:9",
+      sourceWidth: 1001, sourceHeight: 667,
+    })
+    expect(plan!.width % 2).toBe(0)
+    expect(plan!.height % 2).toBe(0)
+  })
+})
+
+describe("geometry helpers", () => {
+  it("minimalRatioDimensions keeps the long side and moves the short one", () => {
+    // 940 wide is 9:16 at 1671.1 tall, which rounds back to the image's own
+    // 1672 — the 1K GPT image really is 9:16 to the nearest even pixel, so
+    // "match ratio" alone would leave it untouched (and the snap would stay).
+    expect(minimalRatioDimensions(940, 1672, 9 / 16)).toEqual({ width: 940, height: 1672 })
+    expect(minimalRatioDimensions(1920, 1000, 16 / 9)).toEqual({ width: 1920, height: 1080 })
+  })
+
+  it("centreCropToAspect drops the overhang evenly", () => {
+    expect(centreCropToAspect(1024, 1024, 9 / 16)).toEqual({ left: 224, top: 0, width: 576, height: 1024 })
+    expect(centreCropToAspect(1000, 1000, 16 / 9)).toEqual({ left: 0, top: 219, width: 1000, height: 562 })
+  })
+
+  it("parseAspectToken reads the tokens the catalog uses", () => {
+    expect(parseAspectToken("16:9")).toBeCloseTo(16 / 9, 6)
+    expect(parseAspectToken("9:16")).toBeCloseTo(9 / 16, 6)
+    expect(parseAspectToken("adaptive")).toBeUndefined()
+    expect(parseAspectToken(undefined)).toBeUndefined()
+  })
+})
+
+describe("frame delivery", () => {
+  it("sends the Seedance 2.0 family as references and everything else as frames", () => {
+    const ref = { requested: "auto" as const, supportsReferenceImages: true }
+    expect(resolveFrameDelivery({ provider: "seedance-2-fast", ...ref })).toBe("reference")
+    expect(resolveFrameDelivery({ provider: "seedance-2", ...ref })).toBe("reference")
+    expect(resolveFrameDelivery({ provider: "seedance-2-mini", ...ref })).toBe("reference")
+    expect(resolveFrameDelivery({ provider: "seedance-2-5", ...ref })).toBe("frame")
+    expect(resolveFrameDelivery({ provider: "wan-3", ...ref })).toBe("frame")
+    expect(resolveFrameDelivery({ provider: "veo3.1", ...ref })).toBe("frame")
+  })
+
+  it("honours an explicit choice", () => {
+    expect(resolveFrameDelivery({ provider: "seedance-2-fast", requested: "frame", supportsReferenceImages: true })).toBe("frame")
+    expect(resolveFrameDelivery({ provider: "veo3.1", requested: "reference", supportsReferenceImages: true })).toBe("reference")
+  })
+
+  it("never asks for reference delivery on a model that takes no references", () => {
+    expect(resolveFrameDelivery({ provider: "seedance-2-fast", requested: "auto", supportsReferenceImages: false })).toBe("frame")
+    expect(resolveFrameDelivery({ provider: "wan-i2v", requested: "reference", supportsReferenceImages: false })).toBe("frame")
+  })
+})

package/src/__tests__/video-link.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect } from "vitest"
+import {
+  SOCIAL_VIDEO_HOSTS,
+  YOUTUBE_HOSTS,
+  INSTAGRAM_HOSTS,
+  VIDEO_LINK_TOLERANT_CONSUMER_TYPES,
+  hasUrlParserHazard,
+  hostnameMatchesAllowlist,
+  isSocialVideoUrl,
+  detectVideoLinkPlatform,
+  videoLinkDownloadedFile,
+  resolveVideoLinkOutput,
+  videoLinkNeedsDownload,
+} from "../video-link.js"
+
+describe("social video host allowlist", () => {
+  it("admits the domain itself and true subdomains only", () => {
+    expect(hostnameMatchesAllowlist("youtube.com", YOUTUBE_HOSTS)).toBe(true)
+    expect(hostnameMatchesAllowlist("www.youtube.com", YOUTUBE_HOSTS)).toBe(true)
+    expect(hostnameMatchesAllowlist("m.youtu.be", YOUTUBE_HOSTS)).toBe(true)
+    expect(hostnameMatchesAllowlist("YOUTUBE.COM.", YOUTUBE_HOSTS)).toBe(true)
+  })
+
+  it("rejects a lookalike host that merely CONTAINS an allowlisted name", () => {
+    expect(hostnameMatchesAllowlist("evilyoutube.com", YOUTUBE_HOSTS)).toBe(false)
+    expect(hostnameMatchesAllowlist("youtube.com.attacker.example", YOUTUBE_HOSTS)).toBe(false)
+    // "x.com" is a substring of "netflix.com" — the old loose regex called this X.
+    expect(isSocialVideoUrl("https://www.netflix.com/watch/1")).toBe(false)
+  })
+
+  it("keeps the YouTube and Instagram subsets inside the full list", () => {
+    for (const h of [...YOUTUBE_HOSTS, ...INSTAGRAM_HOSTS]) {
+      expect(SOCIAL_VIDEO_HOSTS).toContain(h)
+    }
+  })
+
+  it("isSocialVideoUrl never throws on junk", () => {
+    expect(isSocialVideoUrl("")).toBe(false)
+    expect(isSocialVideoUrl("not a url")).toBe(false)
+    expect(isSocialVideoUrl("ftp://youtube.com/x")).toBe(false)
+    expect(isSocialVideoUrl("https://www.tiktok.com/@a/video/1")).toBe(true)
+    expect(isSocialVideoUrl("https://www.tiktok.com/@a/video/1", YOUTUBE_HOSTS)).toBe(false)
+  })
+})
+
+describe("links that URL parsers read differently", () => {
+  const BACKSLASH = "https://tiktok.com\\@169.254.169.254/latest/meta-data"
+
+  it("flags a backslash and every ASCII control character, and nothing else", () => {
+    expect(hasUrlParserHazard(BACKSLASH)).toBe(true)
+    for (const ch of ["\t", "\n", "\r", "\u0000", "\u001f", "\u007f"]) {
+      expect(hasUrlParserHazard(`https://youtu.be/aqz${ch}-KE-bpKQ`)).toBe(true)
+    }
+    expect(hasUrlParserHazard("https://www.youtube.com/watch?v=aqz-KE-bpKQ&t=30s#x")).toBe(false)
+    expect(hasUrlParserHazard("https://pub-x.r2.dev/avideo%20preview/98.mp4")).toBe(false)
+    expect(hasUrlParserHazard("https://example.com/שלום עולם.mp4")).toBe(false)
+    expect(hasUrlParserHazard("")).toBe(false)
+  })
+
+  it("is refused as a social link even though its WHATWG host is allowlisted", () => {
+    // The reading THIS file would make: host tiktok.com. The download tool is
+    // handed the raw string and may read 169.254.169.254.
+    expect(new URL(BACKSLASH).hostname).toBe("tiktok.com")
+    expect(isSocialVideoUrl(BACKSLASH)).toBe(false)
+    expect(detectVideoLinkPlatform(BACKSLASH)).toBe("unknown")
+    expect(videoLinkNeedsDownload({ youtubeUrl: BACKSLASH })).toBe(false)
+  })
+})
+
+describe("consumers that do not need the video file", () => {
+  it("names exactly the three readers that take the audio track or the page link", () => {
+    expect([...VIDEO_LINK_TOLERANT_CONSUMER_TYPES].sort()).toEqual(["dubbing", "suno-cover", "transcribe"])
+  })
+})
+
+describe("detectVideoLinkPlatform", () => {
+  it.each([
+    ["https://www.youtube.com/watch?v=aqz-KE-bpKQ", "youtube"],
+    ["https://youtu.be/aqz-KE-bpKQ?si=x", "youtube"],
+    ["https://music.youtube.com/watch?v=aqz-KE-bpKQ", "youtube"],
+    ["https://www.instagram.com/reels/DaK89TnRB5m/", "instagram"],
+    ["https://vm.tiktok.com/ZS99nqdaG/", "tiktok"],
+    ["https://x.com/someone/status/123", "twitter"],
+    ["https://twitter.com/someone/status/123", "twitter"],
+    ["https://fb.watch/abc/", "facebook"],
+    ["https://www.facebook.com/reel/123", "facebook"],
+    ["https://cdn.nodaro.ai/videos/yt-1.mp4", "unknown"],
+    ["https://www.netflix.com/watch/1", "unknown"],
+    ["garbage", "unknown"],
+  ])("%s → %s", (url, platform) => {
+    expect(detectVideoLinkPlatform(url)).toBe(platform)
+  })
+})
+
+describe("Video URL node output", () => {
+  const YT = "https://www.youtube.com/watch?v=aqz-KE-bpKQ"
+  const FILE = "https://cdn.nodaro.ai/videos/yt-1.mp4"
+
+  it("emits the downloaded file when there is one", () => {
+    expect(resolveVideoLinkOutput({ youtubeUrl: YT, downloadedVideoUrl: FILE, downloadedFromUrl: YT })).toBe(FILE)
+  })
+
+  it("trusts a downloaded file with no recorded source — every node saved before the field existed", () => {
+    expect(resolveVideoLinkOutput({ youtubeUrl: YT, downloadedVideoUrl: FILE })).toBe(FILE)
+  })
+
+  it("does NOT emit a file that was downloaded from a different link", () => {
+    const data = { youtubeUrl: "https://youtu.be/otherVideo01", downloadedVideoUrl: FILE, downloadedFromUrl: YT }
+    expect(videoLinkDownloadedFile(data)).toBeUndefined()
+    // Falls back to the link itself, never to the wrong video.
+    expect(resolveVideoLinkOutput(data)).toBe("https://youtu.be/otherVideo01")
+  })
+
+  it("passes a direct file link through untouched (the Welcome Demo / saved-template shape)", () => {
+    expect(resolveVideoLinkOutput({ youtubeUrl: ` ${FILE} ` })).toBe(FILE)
+    expect(videoLinkNeedsDownload({ youtubeUrl: FILE })).toBe(false)
+  })
+
+  it("is undefined for an empty node", () => {
+    expect(resolveVideoLinkOutput({})).toBeUndefined()
+    expect(resolveVideoLinkOutput({ youtubeUrl: "   " })).toBeUndefined()
+  })
+
+  it("needs a download exactly when the link is social and no file matches it", () => {
+    expect(videoLinkNeedsDownload({ youtubeUrl: YT })).toBe(true)
+    expect(videoLinkNeedsDownload({ youtubeUrl: YT, downloadedVideoUrl: FILE, downloadedFromUrl: YT })).toBe(false)
+    expect(videoLinkNeedsDownload({ youtubeUrl: YT, downloadedVideoUrl: FILE })).toBe(false)
+    expect(videoLinkNeedsDownload({ youtubeUrl: "https://youtu.be/otherVideo01", downloadedVideoUrl: FILE, downloadedFromUrl: YT })).toBe(true)
+    expect(videoLinkNeedsDownload({ youtubeUrl: "https://example.com/page" })).toBe(false)
+    expect(videoLinkNeedsDownload({})).toBe(false)
+  })
+
+  it("ignores non-string junk in the fields", () => {
+    expect(resolveVideoLinkOutput({ youtubeUrl: 5, downloadedVideoUrl: null })).toBeUndefined()
+    expect(videoLinkNeedsDownload({ youtubeUrl: { a: 1 } })).toBe(false)
+  })
+})

package/src/__tests__/workflow-export-strip.test.ts

@@ -1,8 +1,30 @@
 import { describe, it, expect } from "vitest"
-import { stripExportContent } from "../workflow-export.js"
+import { stripExportContent, stripUnownedRefs } from "../workflow-export.js"
 import { EXECUTION_DATA_KEYS } from "../node-runtime-keys.js"
 import type { GenericNode } from "../types.js"
 
+describe("stripExportContent — a Schedule Trigger never exports armed", () => {
+  it("drops `active` and keeps the schedule itself", () => {
+    const node: GenericNode = {
+      id: "s1",
+      type: "schedule-trigger",
+      data: { label: "Daily", rules: [{ id: "rule-1", kind: "days", every: 1, hour: 9, minute: 0 }], timezone: "Asia/Jerusalem", maxExecutions: 3, active: true },
+    }
+    const [out] = stripExportContent([node])
+    const data = out.data as Record<string, unknown>
+    expect(data.active).toBeUndefined()
+    expect(data.rules).toEqual([{ id: "rule-1", kind: "days", every: 1, hour: 9, minute: 0 }])
+    expect(data.timezone).toBe("Asia/Jerusalem")
+    expect(data.maxExecutions).toBe(3)
+  })
+
+  it("a schedule that was never armed is exported unchanged", () => {
+    const node: GenericNode = { id: "s1", type: "schedule-trigger", data: { label: "Daily", rules: [{ id: "rule-1", kind: "days", every: 1, hour: 9, minute: 0 }] } }
+    const [out] = stripExportContent([node])
+    expect(out.data).toEqual(node.data)
+  })
+})
+
 /**
  * Invariant guard for the template-export leak class (audit R2-H4): a
  * "shareable" template export must never carry runtime/result fields —
@@ -36,6 +58,42 @@ describe("stripExportContent — template export hygiene", () => {
     expect(outData.shots, "shots (Kling-3 config) must NOT be stripped").toBe("SENSITIVE_RUNTIME_VALUE")
   })
 
+  it("clears a Webhook Output's credentialId and a publisher's connectionId — pointers at rows the importer does not own", () => {
+    const hook: GenericNode = {
+      id: "h1",
+      type: "webhook-output",
+      data: { url: "https://mine.example/hook", credentialId: "11111111-1111-4111-8111-111111111111", params: [] },
+    }
+    const post: GenericNode = { id: "p1", type: "telegram-post", data: { connectionId: "conn-1", text: "hello" } }
+    const [outHook, outPost] = stripExportContent([hook, post])
+    expect((outHook.data as Record<string, unknown>).credentialId).toBeUndefined()
+    expect((outHook.data as Record<string, unknown>).url).toBe("https://mine.example/hook")
+    expect((outPost.data as Record<string, unknown>).connectionId).toBeUndefined()
+    expect((outPost.data as Record<string, unknown>).text).toBe("hello")
+  })
+
+  it("stripUnownedRefs alone covers the asset-bundle export, which keeps every other field", () => {
+    const hook: GenericNode = {
+      id: "h1",
+      type: "webhook-output",
+      data: { url: "https://mine.example/hook", credentialId: "11111111-1111-4111-8111-111111111111", webhookResponseBody: "kept by this pass" },
+    }
+    const other: GenericNode = { id: "g1", type: "generate-image", data: { credentialId: "not-a-webhook", prompt: "a cat" } }
+    const [outHook, outOther] = stripUnownedRefs([hook, other])
+    expect((outHook.data as Record<string, unknown>).credentialId).toBeUndefined()
+    // Only the owner-bound pointer goes; the bundle's verbatim-data contract holds for the rest.
+    expect((outHook.data as Record<string, unknown>).webhookResponseBody).toBe("kept by this pass")
+    // A node type that has no owner-bound field is returned as-is.
+    expect(outOther).toBe(other)
+    expect(hook.data.credentialId, "input not mutated").toBe("11111111-1111-4111-8111-111111111111")
+  })
+
+  it("the webhook delivery receipt is a runtime key — a reflected secret never rides a template", () => {
+    for (const key of ["webhookSuccess", "webhookStatusCode", "webhookResponseBody"]) {
+      expect(EXECUTION_DATA_KEYS.has(key), key).toBe(true)
+    }
+  })
+
   it("clears faceDbId / referencedWorkflowId on face + sub-workflow template nodes", () => {
     const face: GenericNode = { id: "f1", type: "face", data: { faceDbId: "exporter-face-id", name: "Hero" } }
     const sub: GenericNode = { id: "s1", type: "sub-workflow", data: { referencedWorkflowId: "exporter-wf-id" } }