@norskvideo/ctl-test-harness 0.1.22 → 0.1.24

package/compose-advancing.d.ts

@@ -2,9 +2,24 @@ export type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;
 export declare const DEFAULT_COMPOSE_NODE = "video_compose";
 /** The highest mediaIn across every node of that name; 0 when none. */
 export declare function maxNodeMediaIn(summary: unknown, node: string): number;
+export interface ComposeSample {
+    frames: number;
+    /** Root workflows the visualiser listed — 0 while nothing is deployed. */
+    roots: number;
+    /** Whether any root workflow's summary carried a node of that name — a
+     *  flat 0 with the node absent is a different failure from a stalled one. */
+    nodeSeen: boolean;
+    /** Why the sample is 0 when it is: the visualiser was unreachable, and how. */
+    error?: string;
+}
 /** One sample: the highest mediaIn of `node` across every root workflow under
- *  `base` (`.../visualiser`). An unreachable visualiser reads as 0 — the
- *  caller's second sample, not a throw, decides. */
+ *  `base` (`.../visualiser`). An unreachable visualiser reads as 0 with the
+ *  reason beside it — the caller's second sample, not a throw, decides. */
+export declare function composeSample(opts: {
+    fetch: FetchLike;
+    base: string;
+    node?: string;
+}): Promise<ComposeSample>;
 export declare function composeFrames(opts: {
     fetch: FetchLike;
     base: string;
@@ -15,6 +30,11 @@ export interface ComposeAdvancingResult {
     before: number;
     after: number;
     node: string;
+    /** From the second sample: root workflows listed, and whether the node was in any. */
+    roots: number;
+    nodeSeen: boolean;
+    /** Set when a sample could not read the visualiser at all. */
+    error?: string;
 }
 /** Two samples `settleMs` apart: advancing when the second is above the first
  *  and above zero — the fallback card and a stalled feed both read flat. */

package/compose-advancing.js

@@ -24,38 +24,68 @@ export function maxNodeMediaIn(summary, node) {
     }
     return max;
 }
+function hasNode(summary, node) {
+    const nodes = summary?.nodes;
+    return Array.isArray(nodes) && nodes.some((n) => n?.name === node);
+}
 async function getJson(fetch, url) {
     const r = await fetch(url, { signal: AbortSignal.timeout(5000) });
     if (!r.ok)
         throw new Error(`GET ${url} -> ${r.status}`);
-    return r.json();
+    const text = await r.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`GET ${url} -> ${r.status}, not JSON (a sign-in page? the route needs no auth): ${text.slice(0, 80)}`);
+    }
 }
 /** One sample: the highest mediaIn of `node` across every root workflow under
- *  `base` (`.../visualiser`). An unreachable visualiser reads as 0 — the
- *  caller's second sample, not a throw, decides. */
-export async function composeFrames(opts) {
+ *  `base` (`.../visualiser`). An unreachable visualiser reads as 0 with the
+ *  reason beside it — the caller's second sample, not a throw, decides. */
+export async function composeSample(opts) {
     const node = opts.node ?? DEFAULT_COMPOSE_NODE;
     try {
         const wf = (await getJson(opts.fetch, `${opts.base}/workflow`));
         let max = 0;
+        let roots = 0;
+        let nodeSeen = false;
         for (const root of wf?.rootWorkflows ?? []) {
-            if (typeof root?.wfid !== "string")
+            // The engine numbers its workflows (`wfid: 3339`); a string-only check
+            // here skipped every root and the gate read a silent 0 -> 0 everywhere.
+            const wfid = root?.wfid;
+            if (typeof wfid !== "string" && typeof wfid !== "number")
                 continue;
-            const summary = await getJson(opts.fetch, `${opts.base}/workflow/${encodeURIComponent(root.wfid)}/summary`);
+            roots += 1;
+            const summary = await getJson(opts.fetch, `${opts.base}/workflow/${encodeURIComponent(String(wfid))}/summary`);
+            if (hasNode(summary, node))
+                nodeSeen = true;
             max = Math.max(max, maxNodeMediaIn(summary, node));
         }
-        return max;
+        return { frames: max, roots, nodeSeen };
     }
-    catch {
-        return 0;
+    catch (e) {
+        return { frames: 0, roots: 0, nodeSeen: false, error: e instanceof Error ? e.message : String(e) };
     }
 }
+export async function composeFrames(opts) {
+    return (await composeSample(opts)).frames;
+}
 /** Two samples `settleMs` apart: advancing when the second is above the first
  *  and above zero — the fallback card and a stalled feed both read flat. */
 export async function composeAdvancing(opts) {
     const node = opts.node ?? DEFAULT_COMPOSE_NODE;
-    const before = await composeFrames({ fetch: opts.fetch, base: opts.base, node });
+    const before = await composeSample({ fetch: opts.fetch, base: opts.base, node });
     await new Promise((r) => setTimeout(r, opts.settleMs ?? DEFAULT_SETTLE_MS));
-    const after = await composeFrames({ fetch: opts.fetch, base: opts.base, node });
-    return { advancing: after > before && after > 0, before, after, node };
+    const after = await composeSample({ fetch: opts.fetch, base: opts.base, node });
+    const error = after.error ?? before.error;
+    return {
+        advancing: after.frames > before.frames && after.frames > 0,
+        before: before.frames,
+        after: after.frames,
+        node,
+        roots: after.roots,
+        nodeSeen: after.nodeSeen,
+        ...(error !== undefined ? { error } : {}),
+    };
 }

package/demo/gates.js

@@ -48,8 +48,19 @@ export function composeAdvancingGate(opts = {}) {
                 node,
                 ...(opts.settleMs !== undefined ? { settleMs: opts.settleMs } : {}),
             });
-            if (!r.advancing)
-                ctx.log(`${node} not advancing yet (${r.before} -> ${r.after})`);
+            if (r.error)
+                ctx.log(`visualiser unreachable at ${base}: ${r.error}`);
+            else if (!r.advancing) {
+                // A flat 0 has three causes worth telling apart before anyone reads
+                // engine logs: nothing deployed yet, a graph without that node, or a
+                // stalled feed into a node that is there.
+                const why = r.roots === 0
+                    ? "; no root workflows deployed yet"
+                    : r.nodeSeen
+                        ? ""
+                        : `; no node named ${node} in ${r.roots} root workflow(s)`;
+                ctx.log(`${node} not advancing yet (${r.before} -> ${r.after}${why})`);
+            }
             return r.advancing;
         },
     };

package/demo/run.js

@@ -421,6 +421,12 @@ export class DemoSession {
             join(this.storeDir, "norsk-runtime"),
             "--proxy-port",
             String(this.ports.proxyPort),
+            // A throwaway daemon on a banded port has nothing to protect, and its
+            // /instance/<id>/... routes (the visualiser a gate reads, the `open`
+            // URLs) must answer without a session: with oauth on, the compose gate
+            // read the sign-in page as "0 frames" for 180s (playout CI, 2026-08-29).
+            "--proxy-auth",
+            "none",
             "--no-http-redirect",
             "--no-start-server",
             ...(this.publicHost ? ["--public-host", this.publicHost] : []),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@norskvideo/ctl-test-harness",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "type": "module",
   "exports": {
     ".": {