@norskvideo/ctl-test-harness 0.1.3 → 0.1.5

package/daemon.d.ts

@@ -1,6 +1,7 @@
 import { pollUntil } from "./poll.js";
 import { makeStoreDir, makeTempDir, TEST_TMP_BASE } from "./temp-dir.js";
 export declare const HEALTH_TIMEOUT_MS = 120000;
+export declare const DAEMON_READY_TIMEOUT_MS = 60000;
 export { makeStoreDir, makeTempDir, pollUntil, TEST_TMP_BASE };
 export declare function requireLicenseFile(): string;
 export declare function runCli(storeDir: string, ...args: string[]): Promise<{

package/daemon.js

@@ -11,6 +11,15 @@ import { pollUntil } from "./poll.js";
 import { makeStoreDir, makeTempDir, TEST_TMP_BASE } from "./temp-dir.js";
 process.env.NORSK_CTL_NO_MEDIA_DOWNLOAD = "1";
 export const HEALTH_TIMEOUT_MS = 120_000;
+// The daemon's readiness probe (/api/ready) cannot answer until `serve` has
+// brought up its oauth2-proxy + nginx sidecar CONTAINERS — /api/* redirects
+// through the proxy. On a cold or contended CI runner that bring-up finishes
+// just past 10s (observed ~10.5s on the GPU box under nightly load), so a 10s
+// window lost the photo-finish and failed every test at setup with "Daemon did
+// not become ready ... Unable to connect". A healthy daemon still answers in
+// under a second, so the wider window only costs wall-clock when startup is
+// genuinely slow.
+export const DAEMON_READY_TIMEOUT_MS = 60_000;
 export { makeStoreDir, makeTempDir, pollUntil, TEST_TMP_BASE };
 function splitLines(text) {
     return text
@@ -89,7 +98,7 @@ export function startDaemon(storeDir, options) {
     const ready = pollUntil(async () => {
         const res = await fetch(`http://localhost:${port}/api/ready`, { signal: AbortSignal.timeout(1000) });
         return res.ok;
-    }, { timeoutMs: 10_000, intervalMs: 500, label: "Daemon did not become ready" });
+    }, { timeoutMs: DAEMON_READY_TIMEOUT_MS, intervalMs: 500, label: "Daemon did not become ready" });
     return { daemon, ready };
 }
 function runningContainers(names) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@norskvideo/ctl-test-harness",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "exports": {
     "./daemon": {
@@ -18,6 +18,25 @@
     "./harness-config": {
       "types": "./harness-config.d.ts",
       "default": "./harness-config.js"
+    },
+    "./studio-load": {
+      "types": "./studio-load.d.ts",
+      "default": "./studio-load.js"
+    }
+  },
+  "dependencies": {
+    "@norskvideo/ctl-sdk": "^0.1.0"
+  },
+  "peerDependencies": {
+    "@norskvideo/norsk-studio": "*",
+    "@norskvideo/norsk-studio-built-ins": "*"
+  },
+  "peerDependenciesMeta": {
+    "@norskvideo/norsk-studio": {
+      "optional": true
+    },
+    "@norskvideo/norsk-studio-built-ins": {
+      "optional": true
     }
   },
   "publishConfig": {

package/studio-load.d.ts

@@ -0,0 +1,11 @@
+import { load } from "@norskvideo/norsk-studio/lib/runtime/document";
+import { RuntimeSystem } from "@norskvideo/norsk-studio/lib/runtime/system";
+export type CompiledDocument = ReturnType<typeof load>;
+export interface StudioLoadOptions {
+    stubs?: string[];
+    register?: (runtime: RuntimeSystem) => void | Promise<void>;
+    filename?: string;
+    loadOptions?: Parameters<typeof load>[3];
+}
+export declare function loadsInStudio(yamlText: string, opts?: StudioLoadOptions): Promise<CompiledDocument>;
+export declare function assertLoadsInStudio(yamlText: string, opts?: StudioLoadOptions): Promise<CompiledDocument>;

package/studio-load.js

@@ -0,0 +1,70 @@
+// The cheap Layer 4 tier, packaged: run an emitted workflow YAML through
+// Studio's REAL document.load() so every built-ins component's zod schema
+// validates what the composer actually emits — not just the local factory
+// typing. Synchronous validation path only; no Norsk media engine, no Docker.
+//
+// This generalises probe's _util/studio-load.ts (11 scenarios) so no product
+// has to re-derive the fiddly parts:
+//   - built-ins registerAll sits at .default.default when bundled and .default
+//     when externalised; callableDefault tolerates both.
+//   - document.load() records "Unknown node type" and STOPS at the first
+//     component it can't resolve, so one custom component would mask every
+//     error after it. Out-of-library components (a product's own, or alpha
+//     ones absent from @norskvideo/norsk-studio-built-ins) are stub-registered
+//     via `stubs` — permissive, config not validated (there is no schema to
+//     validate against), passing input streams through so downstream built-ins
+//     still resolve subscriptions.
+//
+// Lives in ctl-test-harness (not dev-kit: it needs the norsk-studio packages,
+// which are optional peers here — the products that use it already pin them;
+// dev-kit stays dependency-lean).
+import { callableDefault } from "@norskvideo/ctl-sdk";
+import { load } from "@norskvideo/norsk-studio/lib/runtime/document";
+import { RuntimeSystem } from "@norskvideo/norsk-studio/lib/runtime/system";
+import * as builtInsModule from "@norskvideo/norsk-studio-built-ins";
+const registerAll = callableDefault(builtInsModule, "@norskvideo/norsk-studio-built-ins");
+function registerStub(runtime, identifier) {
+    const info = {
+        identifier,
+        name: identifier,
+        category: "Output",
+        // load() reads info.configForm.global (global-config map) and iterates
+        // info.configForm.form (per-field config patching); an empty non-global
+        // form is all a stub needs.
+        configForm: { global: false, form: {} },
+        subscription: {
+            accepts: {
+                type: "simple-stream",
+                video: true,
+                audio: true,
+                subtitle: true,
+                ancillary: true,
+                playlist: true,
+                acceptsTransient: true,
+            },
+            produces: { type: "dynamic-streams", streams: (_cfg, inputs) => inputs },
+        },
+    };
+    const definition = {
+        create: async () => { },
+        schemas: async () => ({ config: { type: "object", additionalProperties: true } }),
+    };
+    runtime.registerComponent(definition, info, "", undefined, "studio-load-stubs");
+}
+export async function loadsInStudio(yamlText, opts = {}) {
+    const runtime = new RuntimeSystem();
+    await registerAll(runtime);
+    for (const id of opts.stubs ?? [])
+        registerStub(runtime, id);
+    await opts.register?.(runtime);
+    return load(opts.filename ?? "workflow.yml", runtime, yamlText, { resolveConfig: true, ...opts.loadOptions });
+}
+// Throwing form for tests: one assertion per scenario, every load error listed.
+export async function assertLoadsInStudio(yamlText, opts = {}) {
+    const compiled = await loadsInStudio(yamlText, opts);
+    if (compiled.errors.length > 0) {
+        const listed = compiled.errors.map((e, i) => `  [${i}] ${e.message}`).join("\n");
+        throw new Error(`${opts.filename ?? "workflow.yml"} failed Studio document.load():\n${listed}`);
+    }
+    return compiled;
+}