@norskvideo/ctl-dev-kit 0.2.39 → 0.2.41

package/doc-guide/engine-verdict.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env bun
+export interface EngineVerdict {
+    ok: boolean;
+    reason: string;
+}
+export declare function engineVerdict(output: string): EngineVerdict;

package/doc-guide/engine-verdict.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env bun
+/**
+ * Whether a doc-guide engine tier that exited non-zero failed for real, or only
+ * a teardown hook ran out of time after every guide's test had passed. Each
+ * product's scripts/doc-guide/regen-manual.sh asks this, from the tier's own
+ * output, instead of "are the capture files on disk": that rule passed a
+ * composition guide that hung after two captures (2026-10-03) and passed any
+ * guide whose assertions failed after its captures were written. The engine
+ * tier is also half of the publish gate (dev-kit conventions/build-image.yml),
+ * so what it forgives, the gate forgives.
+ *
+ * Forgiven: every result line a test passed, apart from unnamed hook failures
+ * in guides that also passed a test. Anything else -- a named test failing, a
+ * guide whose only result is a failed hook (its setup never finished), or no
+ * results at all -- is a real failure.
+ *
+ * Reads both runners' list output: bun test (`(pass) guide > test [ms]`,
+ * `(fail) guide > (unnamed)` for a hook) and Playwright (`✓ n [project] ›
+ * file:line › guide › test (t)`; an afterAll failing after every test passed
+ * belongs to no test, so it leaves only ✓ lines).
+ *
+ *   bun engine-verdict.ts <captured engine-tier output>
+ *   exit 0 = teardown only (continue), 1 = real failure (abort)
+ *
+ * Imports only node: it runs inside product repos (see publish/product-channel.ts).
+ */
+import { readFileSync } from "node:fs";
+/** Colour escapes (ESC [ ... m), built from a string: lint refuses a control
+ *  character in a regex literal. */
+const ANSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+const BUN = /\((pass|fail)\) (.+?) > (.+?) \[[\d.]+m?s\]\s*$/;
+const PLAYWRIGHT = /([✓✘])\s+\d+ \[[^\]]*\] › [^›]+ › (.+?) › (.+?) \([\d.]+m?s\)\s*$/;
+function results(output) {
+    const out = [];
+    for (const raw of output.split("\n")) {
+        const line = raw.replace(ANSI, "");
+        const b = line.match(BUN);
+        if (b) {
+            out.push({ guide: b[2], test: b[3], passed: b[1] === "pass" });
+            continue;
+        }
+        const p = line.match(PLAYWRIGHT);
+        if (p)
+            out.push({ guide: p[2], test: p[3], passed: p[1] === "✓" });
+    }
+    return out;
+}
+export function engineVerdict(output) {
+    const all = results(output);
+    if (all.length === 0)
+        return { ok: false, reason: "no test results in the engine tier's output" };
+    const failedTests = all.filter((r) => !r.passed && r.test !== "(unnamed)");
+    const passedGuides = new Set(all.filter((r) => r.passed).map((r) => r.guide));
+    const hookOnlyGuides = [
+        ...new Set(all.filter((r) => !r.passed && r.test === "(unnamed)" && !passedGuides.has(r.guide)).map((r) => r.guide)),
+    ];
+    const problems = [
+        ...failedTests.map((r) => `failed: ${r.guide} > ${r.test}`),
+        ...hookOnlyGuides.map((g) => `never ran (only a hook result): ${g}`),
+    ];
+    return problems.length ? { ok: false, reason: problems.join("; ") } : { ok: true, reason: "teardown only" };
+}
+if (import.meta.main) {
+    const path = process.argv[2];
+    if (!path) {
+        console.error("usage: engine-verdict.ts <captured engine-tier output>");
+        process.exit(2);
+    }
+    const verdict = engineVerdict(readFileSync(path, "utf8"));
+    console.log(verdict.ok ? `engine tier: ${verdict.reason}` : `engine tier failed: ${verdict.reason}`);
+    process.exit(verdict.ok ? 0 : 1);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@norskvideo/ctl-dev-kit",
-  "version": "0.2.39",
+  "version": "0.2.41",
   "type": "module",
   "exports": {
     "./create-product": "./create-product/create-product.ts",
@@ -8,6 +8,7 @@
     "./doc-guide/build-manual": "./doc-guide/build-manual.js",
     "./doc-guide/bundle": "./doc-guide/bundle.js",
     "./doc-guide/docs-release": "./doc-guide/docs-release.js",
+    "./doc-guide/engine-verdict": "./doc-guide/engine-verdict.js",
     "./doc-guide/guides-config": "./doc-guide/guides-config.js",
     "./doc-guide/instance-proxy": "./doc-guide/instance-proxy.js",
     "./doc-guide/live-browser": "./doc-guide/live-browser.js",

package/publish/product-channel.ts

@@ -16,16 +16,72 @@
  * are not reliable yet: it skips only the guide half of the gate, must give a
  * reason, and the reason travels into the published row, so nobody reads
  * "passed" off an image whose guides never ran.
+ *
+ * Self-contained on purpose: it imports nothing outside node and this package.
+ * Products resolve the dev-kit's siblings from their OWN lockfiles, so a sibling
+ * import here bound the writer to whatever schema version a product happened to
+ * lock -- the first gated publish in every product died on a missing export.
+ * The object's contract is @norskvideo/ctl-product-template-schema's
+ * product-channels; product-channel.test.ts parses this module's output with it.
  */
 import { existsSync, readFileSync } from "node:fs";
-import {
-  type ProductChannelRow,
-  ProductChannelSchema,
-  parseProductChannels,
-  withChannelRow,
-} from "@norskvideo/ctl-product-template-schema/product-channels";
 import { builtImageName } from "../licence/check-template.ts";
 
+const CHANNELS = ["nightly", "rc", "latest"] as const;
+type Channel = (typeof CHANNELS)[number];
+
+export interface ProductChannelRow {
+  image: string;
+  sha: string;
+  publishedAt: string;
+  runtimeImages: string[];
+  gate: { checks: "passed"; guides: "passed" | { skipped: string }; run?: string };
+}
+
+interface ProductChannels {
+  schemaVersion: 1;
+  product: string;
+  imageRef: string;
+  updated: string;
+  channels: Partial<Record<Channel, unknown>>;
+}
+
+/** The current object, checked only as far as the merge needs: other channels'
+ *  rows are carried through untouched, so a newer writer's fields survive. */
+function parseCurrent(text: string): ProductChannels {
+  const raw = JSON.parse(text) as Partial<ProductChannels>;
+  if (raw.schemaVersion !== 1) throw new Error(`channels object has schemaVersion ${raw.schemaVersion}, not 1`);
+  if (typeof raw.product !== "string" || typeof raw.imageRef !== "string") {
+    throw new Error("channels object has no product/imageRef");
+  }
+  if (typeof raw.channels !== "object" || raw.channels === null) throw new Error("channels object has no channels");
+  return raw as ProductChannels;
+}
+
+/** `current` with `channel` set to `row`; every other channel is kept. */
+export function withChannelRow(
+  current: ProductChannels | null,
+  opts: { product: string; imageRef: string; channel: Channel; row: ProductChannelRow; updated: string },
+): ProductChannels {
+  if (current && (current.product !== opts.product || current.imageRef !== opts.imageRef)) {
+    throw new Error(
+      `channels object belongs to ${current.product} (${current.imageRef}), not ${opts.product} (${opts.imageRef})`,
+    );
+  }
+  return {
+    schemaVersion: 1,
+    product: opts.product,
+    imageRef: opts.imageRef,
+    updated: opts.updated,
+    channels: { ...(current?.channels ?? {}), [opts.channel]: opts.row },
+  };
+}
+
+function parseChannel(value: string): Channel {
+  if (!(CHANNELS as readonly string[]).includes(value)) throw new Error(`not a channel: ${value}`);
+  return value as Channel;
+}
+
 export type GuideGate = { run: true } | { run: false; reason: string };
 
 /** Whether the guides gate this product's publish, from its opt-out file. */
@@ -106,20 +162,12 @@ if (import.meta.main) {
     console.log(productForImage(readFileSync(need("template"), "utf8"), need("image")));
   } else if (cmd === "row") {
     const currentText = readIfPresent(flag("current"));
-    let current = null;
-    if (currentText !== undefined) {
-      const parsed = parseProductChannels(JSON.parse(currentText));
-      if (!parsed.ok) {
-        console.error(`product-channel row: the current object does not parse:\n${parsed.error}`);
-        process.exit(1);
-      }
-      current = parsed.value;
-    }
+    const current = currentText === undefined ? null : parseCurrent(currentText);
     const skipped = flag("skipped");
     const merged = withChannelRow(current, {
       product: need("product"),
       imageRef: need("image-ref"),
-      channel: ProductChannelSchema.parse(need("channel")),
+      channel: parseChannel(need("channel")),
       updated: need("published-at"),
       row: gateRow({
         image: need("image"),