@norskvideo/ctl-sdk 0.1.0

package/manifest-seed.js

@@ -0,0 +1,40 @@
+// Machine-writable source of truth for a product's pinned {media, studio} image
+// pair (RFC 0001 Workstream C, slice 1). Each product ships a
+// `products/<p>/manifest.seed.json` whose `version.ts` derives its existing tag
+// exports from this shape. This module owns the schema, the inferred types, and
+// a Result-returning parse helper — the conformance gate validates every seed
+// against it in CI, so version.ts consumes the JSON as typed data without
+// re-validating at import time.
+//
+// Zero runtime dependencies beyond zod (already an sdk dep) and foundation's
+// Result, so it lives on its own `./manifest-seed` subpath rather than the `.`
+// barrel (which drags express) — a zero-dep consumer (the gate bot, the
+// conformance test) imports it without the express surface.
+import { err, ok } from "@norskvideo/ctl-foundation";
+import { z } from "zod";
+// A repo-qualified image ref: an `owner/name:tag` string. The repo must be
+// slash-qualified so a bare tag (no repo) is rejected — the seed carries FULL
+// refs uniformly (studio strips the repo back off in its version.ts).
+const RepoQualifiedRef = z
+    .string()
+    .regex(/^[^\s:]+\/[^\s:]+:[^\s:]+$/, "must be a repo-qualified ref (owner/name:tag)");
+// Why an enum: `inherited` (studio takes its pair from the channel manifest) vs
+// `nightly-baseline` (probe et al. pin their own nightly). The distinction
+// mirrors RFC §3.4 without pre-committing slice-3 catalog semantics.
+export const SourceSchema = z.enum(["inherited", "nightly-baseline"]);
+export const ChannelEntrySchema = z
+    .object({
+    media: RepoQualifiedRef,
+    studio: RepoQualifiedRef,
+    source: SourceSchema,
+    ratifiedAt: z.string().optional(),
+})
+    .strict();
+// A seed is `{ [channel]: entry }` with at least a `latest` key.
+export const SeedSchema = z
+    .record(z.string(), ChannelEntrySchema)
+    .refine((s) => "latest" in s, "seed must have a 'latest' entry");
+export function parseManifestSeed(raw) {
+    const parsed = SeedSchema.safeParse(raw);
+    return parsed.success ? ok(parsed.data) : err(z.prettifyError(parsed.error));
+}

package/openapi-router.d.ts

@@ -0,0 +1,12 @@
+import { Router } from "express";
+/**
+ * Serves a product's OpenAPI document at `GET /openapi.yaml`, relative to
+ * wherever the router is mounted.
+ *
+ * `build` is called lazily on the first request and its result cached for the
+ * life of the router — the document is derived from schemas that are fixed at
+ * startup, so rebuilding per request only costs latency. The cache is
+ * per-router rather than per-module so two products sharing a process cannot
+ * serve each other's document.
+ */
+export declare function createOpenapiRouter(build: () => string): Router;

package/openapi-router.js

@@ -0,0 +1,21 @@
+import { Router } from "express";
+/**
+ * Serves a product's OpenAPI document at `GET /openapi.yaml`, relative to
+ * wherever the router is mounted.
+ *
+ * `build` is called lazily on the first request and its result cached for the
+ * life of the router — the document is derived from schemas that are fixed at
+ * startup, so rebuilding per request only costs latency. The cache is
+ * per-router rather than per-module so two products sharing a process cannot
+ * serve each other's document.
+ */
+export function createOpenapiRouter(build) {
+    const router = Router();
+    let cached;
+    router.get("/openapi.yaml", (_req, res) => {
+        if (!cached)
+            cached = build();
+        res.type("text/yaml").send(cached);
+    });
+    return router;
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@norskvideo/ctl-sdk",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./browser": {
+      "types": "./browser.d.ts",
+      "default": "./browser.js"
+    },
+    "./components": {
+      "types": "./components/index.d.ts",
+      "default": "./components/index.js"
+    },
+    "./manifest-seed": {
+      "types": "./manifest-seed.d.ts",
+      "default": "./manifest-seed.js"
+    },
+    "./runtime": {
+      "types": "./runtime.d.ts",
+      "default": "./runtime.js"
+    },
+    "./workflow": {
+      "types": "./workflow.d.ts",
+      "default": "./workflow.js"
+    },
+    "./base.css": "./base.css"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "dependencies": {
+    "@norskvideo/ctl-foundation": "^0.1.0",
+    "@norskvideo/ctl-product-template-schema": "^0.1.0",
+    "express": "5",
+    "lucide-react": "^0.483.0",
+    "react": "^19.0.0",
+    "react-hot-toast": "^2.4.1",
+    "zod": "^4.3.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/parsing.d.ts

@@ -0,0 +1,9 @@
+import type { ProductRegistration, ProductSpec } from "./product-types.js";
+export declare class ProductsParseError extends Error {
+    constructor(path: string, reason: string);
+}
+export declare function parseSpec(raw: unknown, where: string, path: string): ProductSpec;
+export interface ProductsFile {
+    products: ProductRegistration[];
+}
+export declare function parseProductsFile(raw: unknown, path: string): ProductsFile;

package/parsing.js

@@ -0,0 +1,83 @@
+import { ManifestSchema } from "./manifest-schema.js";
+export class ProductsParseError extends Error {
+    constructor(path, reason) {
+        super(`Failed to parse ${path}: ${reason}`);
+        this.name = "ProductsParseError";
+    }
+}
+function isRecord(v) {
+    return typeof v === "object" && v !== null;
+}
+export function parseSpec(raw, where, path) {
+    if (!isRecord(raw))
+        throw new ProductsParseError(path, `${where}.spec must be an object`);
+    if (raw.kind === "container") {
+        if (typeof raw.image !== "string") {
+            throw new ProductsParseError(path, `${where}.spec.image must be a string`);
+        }
+        return { kind: "container", image: raw.image };
+    }
+    if (raw.kind === "dev") {
+        if (typeof raw.url !== "string") {
+            throw new ProductsParseError(path, `${where}.spec.url must be a string`);
+        }
+        return { kind: "dev", url: raw.url };
+    }
+    throw new ProductsParseError(path, `${where}.spec.kind must be 'container' or 'dev'`);
+}
+function parseLicense(raw, where, path) {
+    if (!isRecord(raw))
+        throw new ProductsParseError(path, `${where}.license must be an object`);
+    if (raw.mode === "byol") {
+        if (typeof raw.file !== "string") {
+            throw new ProductsParseError(path, `${where}.license.file must be a string`);
+        }
+        return { mode: "byol", file: raw.file };
+    }
+    if (raw.mode === "marketplace") {
+        if (typeof raw.provider !== "string") {
+            throw new ProductsParseError(path, `${where}.license.provider must be a string`);
+        }
+        return { mode: "marketplace", provider: raw.provider };
+    }
+    throw new ProductsParseError(path, `${where}.license.mode must be 'byol' or 'marketplace'`);
+}
+export function parseProductsFile(raw, path) {
+    if (!isRecord(raw))
+        throw new ProductsParseError(path, "file is not a YAML object");
+    const products = raw.products;
+    if (products === undefined)
+        return { products: [] };
+    if (!Array.isArray(products))
+        throw new ProductsParseError(path, "'products' must be an array");
+    const validated = [];
+    for (let i = 0; i < products.length; i++) {
+        const where = `products[${i}]`;
+        const entry = products[i];
+        if (!isRecord(entry))
+            throw new ProductsParseError(path, `${where} is not an object`);
+        if (typeof entry.name !== "string")
+            throw new ProductsParseError(path, `${where}.name must be a string`);
+        if (typeof entry.addedAt !== "string")
+            throw new ProductsParseError(path, `${where}.addedAt must be a string`);
+        const spec = parseSpec(entry.spec, where, path);
+        const manifestParse = ManifestSchema.safeParse(entry.manifest);
+        if (!manifestParse.success) {
+            throw new ProductsParseError(path, `${where}.manifest is invalid: ${manifestParse.error.message}`);
+        }
+        const reg = {
+            name: entry.name,
+            spec,
+            addedAt: entry.addedAt,
+            manifest: manifestParse.data,
+        };
+        if (typeof entry.port === "number")
+            reg.port = entry.port;
+        if (typeof entry.containerId === "string")
+            reg.containerId = entry.containerId;
+        if (entry.license !== undefined)
+            reg.license = parseLicense(entry.license, where, path);
+        validated.push(reg);
+    }
+    return { products: validated };
+}

package/product-error.d.ts

@@ -0,0 +1,4 @@
+export declare class ProductError extends Error {
+    code: "DEV_URL_INVALID" | "DEV_URL_NOT_LOCALHOST" | "PORT_EXHAUSTED" | "DOCKER_RUN_FAILED" | "READINESS_TIMEOUT" | "MANIFEST_FETCH_FAILED" | "MANIFEST_INVALID" | "CONFIG_SCREEN_UNREACHABLE" | "CONFIG_SCREEN_DEV_SERVER" | "LICENSE_INVALID" | "NAME_CONFLICT" | "NOT_FOUND" | "NOT_RESTARTABLE" | "PRODUCT_TEMPLATE_FETCH_FAILED";
+    constructor(code: "DEV_URL_INVALID" | "DEV_URL_NOT_LOCALHOST" | "PORT_EXHAUSTED" | "DOCKER_RUN_FAILED" | "READINESS_TIMEOUT" | "MANIFEST_FETCH_FAILED" | "MANIFEST_INVALID" | "CONFIG_SCREEN_UNREACHABLE" | "CONFIG_SCREEN_DEV_SERVER" | "LICENSE_INVALID" | "NAME_CONFLICT" | "NOT_FOUND" | "NOT_RESTARTABLE" | "PRODUCT_TEMPLATE_FETCH_FAILED", message: string);
+}

package/product-error.js

@@ -0,0 +1,8 @@
+export class ProductError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ProductError";
+    }
+}

package/product-health-monitor.d.ts

@@ -0,0 +1,72 @@
+import type { ProductRegistration } from "./product-types.js";
+export type ProductHealthStatus = "healthy" | "unhealthy" | "restarting" | "unknown";
+export interface ProductHealthState {
+    status: ProductHealthStatus;
+    /** Failed probes since the last success or restart attempt. */
+    consecutiveFailures: number;
+    /** Restart attempts since the last successful probe. Caps at maxRestarts. */
+    restartAttempts: number;
+    /** Clock value of the most recent restart attempt; gates backoff. */
+    lastRestartAt?: number;
+}
+export interface ProductHealthMonitorOptions {
+    /** Products to consider. Non-container products are ignored (externally
+     *  owned), so this can safely be the unfiltered `productService.list`. */
+    listProducts: () => ProductRegistration[];
+    /** Liveness probe — true means healthy. Injected so tests don't hit the
+     *  network; the daemon wires `probeProductHealth`. */
+    probe: (reg: ProductRegistration) => Promise<boolean>;
+    /** Recovery action for a product over threshold. Typically
+     *  `productService.restart`. Rejection counts as a failed attempt. */
+    restart: (name: string) => Promise<void>;
+    /** Consecutive failed probes before a restart is attempted. Default 3. */
+    failureThreshold?: number;
+    /** Restart attempts before giving up (until a healthy probe resets). Default 3. */
+    maxRestarts?: number;
+    /** Minimum ms between restart attempts for one product. Default 30_000. */
+    restartBackoffMs?: number;
+    /** Poll cadence used by start(). Default 15_000. */
+    intervalMs?: number;
+    /** Clock seam for backoff. Default Date.now. */
+    now?: () => number;
+    /** Fired when a product's status changes — for SSE / log surfacing. */
+    onChange?: (name: string, state: ProductHealthState) => void;
+}
+/**
+ * Periodically probes each container product's health endpoint and, after
+ * repeated failures, auto-restarts it (model B: the daemon owns container
+ * lifecycle). Reporting and recovery in one loop: status is exposed via
+ * `health()`/`snapshot()` and pushed through `onChange`; recovery is bounded
+ * by a consecutive-failure threshold, a per-product restart cap, and a
+ * backoff window so a genuinely-broken product can't be thrashed.
+ */
+export declare class ProductHealthMonitor {
+    private readonly listProducts;
+    private readonly probe;
+    private readonly restart;
+    private readonly failureThreshold;
+    private readonly maxRestarts;
+    private readonly restartBackoffMs;
+    private readonly intervalMs;
+    private readonly now;
+    private readonly onChange?;
+    private readonly states;
+    private timer;
+    private inFlight;
+    constructor(opts: ProductHealthMonitorOptions);
+    health(name: string): ProductHealthState;
+    snapshot(): Record<string, ProductHealthStatus>;
+    start(): void;
+    stop(): void;
+    /** One probe sweep across all container products. Overlapping calls coalesce
+     *  onto the in-flight sweep so a slow restart can't stack ticks. */
+    poll(): Promise<void>;
+    private pollInner;
+    private checkOne;
+    private set;
+}
+/** Default liveness probe: GET the product's manifest-declared health path
+ *  (default /healthz) with a short timeout. Any non-2xx, network error, or
+ *  timeout reads as unhealthy. Container-only — dev products are externally
+ *  owned and never reach here. */
+export declare function probeProductHealth(reg: ProductRegistration, timeoutMs?: number): Promise<boolean>;

package/product-health-monitor.js

@@ -0,0 +1,136 @@
+import { logger } from "@norskvideo/ctl-foundation";
+import { specBaseUrl } from "./manifest-fetch.js";
+const UNKNOWN = { status: "unknown", consecutiveFailures: 0, restartAttempts: 0 };
+/**
+ * Periodically probes each container product's health endpoint and, after
+ * repeated failures, auto-restarts it (model B: the daemon owns container
+ * lifecycle). Reporting and recovery in one loop: status is exposed via
+ * `health()`/`snapshot()` and pushed through `onChange`; recovery is bounded
+ * by a consecutive-failure threshold, a per-product restart cap, and a
+ * backoff window so a genuinely-broken product can't be thrashed.
+ */
+export class ProductHealthMonitor {
+    listProducts;
+    probe;
+    restart;
+    failureThreshold;
+    maxRestarts;
+    restartBackoffMs;
+    intervalMs;
+    now;
+    onChange;
+    states = new Map();
+    timer = null;
+    inFlight = null;
+    constructor(opts) {
+        this.listProducts = opts.listProducts;
+        this.probe = opts.probe;
+        this.restart = opts.restart;
+        this.failureThreshold = opts.failureThreshold ?? 3;
+        this.maxRestarts = opts.maxRestarts ?? 3;
+        this.restartBackoffMs = opts.restartBackoffMs ?? 30_000;
+        this.intervalMs = opts.intervalMs ?? 15_000;
+        this.now = opts.now ?? Date.now;
+        this.onChange = opts.onChange;
+    }
+    health(name) {
+        return this.states.get(name) ?? UNKNOWN;
+    }
+    snapshot() {
+        const out = {};
+        for (const [name, state] of this.states)
+            out[name] = state.status;
+        return out;
+    }
+    start() {
+        if (this.timer)
+            return;
+        void this.poll();
+        this.timer = setInterval(() => void this.poll(), this.intervalMs);
+        logger.debug(`Product health monitor started (${this.intervalMs}ms interval)`);
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    /** One probe sweep across all container products. Overlapping calls coalesce
+     *  onto the in-flight sweep so a slow restart can't stack ticks. */
+    async poll() {
+        if (this.inFlight)
+            return this.inFlight;
+        this.inFlight = this.pollInner().finally(() => {
+            this.inFlight = null;
+        });
+        return this.inFlight;
+    }
+    async pollInner() {
+        const products = this.listProducts().filter((p) => p.spec.kind === "container");
+        const live = new Set(products.map((p) => p.name));
+        for (const name of [...this.states.keys()])
+            if (!live.has(name))
+                this.states.delete(name);
+        await Promise.all(products.map((reg) => this.checkOne(reg)));
+    }
+    async checkOne(reg) {
+        const prev = this.states.get(reg.name) ?? UNKNOWN;
+        let healthy;
+        try {
+            healthy = await this.probe(reg);
+        }
+        catch {
+            healthy = false;
+        }
+        if (healthy) {
+            this.set(reg.name, { status: "healthy", consecutiveFailures: 0, restartAttempts: 0 }, prev);
+            return;
+        }
+        const consecutiveFailures = prev.consecutiveFailures + 1;
+        const belowThreshold = consecutiveFailures < this.failureThreshold;
+        const gaveUp = prev.restartAttempts >= this.maxRestarts;
+        const backoffElapsed = prev.lastRestartAt === undefined || this.now() - prev.lastRestartAt >= this.restartBackoffMs;
+        if (belowThreshold || gaveUp || !backoffElapsed) {
+            this.set(reg.name, { ...prev, status: "unhealthy", consecutiveFailures }, prev);
+            return;
+        }
+        // Threshold reached, attempts left, backoff elapsed: attempt recovery.
+        const at = this.now();
+        const restartAttempts = prev.restartAttempts + 1;
+        this.set(reg.name, { status: "restarting", consecutiveFailures: 0, restartAttempts, lastRestartAt: at }, prev);
+        try {
+            await this.restart(reg.name);
+            // Stay "restarting"; the next sweep re-probes to confirm recovery.
+        }
+        catch (e) {
+            logger.warn(`Product '${reg.name}': restart failed — ${e instanceof Error ? e.message : String(e)}`);
+            this.set(reg.name, { status: "unhealthy", consecutiveFailures: 0, restartAttempts, lastRestartAt: at }, prev);
+        }
+    }
+    set(name, next, prev) {
+        this.states.set(name, next);
+        if (next.status !== prev.status) {
+            logger.info(`Product '${name}' health: ${prev.status} -> ${next.status}`);
+            this.onChange?.(name, next);
+        }
+    }
+}
+/** Default liveness probe: GET the product's manifest-declared health path
+ *  (default /healthz) with a short timeout. Any non-2xx, network error, or
+ *  timeout reads as unhealthy. Container-only — dev products are externally
+ *  owned and never reach here. */
+export async function probeProductHealth(reg, timeoutMs = 3_000) {
+    if (reg.spec.kind !== "container" || reg.port === undefined)
+        return false;
+    const path = reg.manifest.api?.healthCheckPath ?? "/healthz";
+    const base = specBaseUrl(reg.spec, reg.port);
+    try {
+        const r = await fetch(`${base}${path.startsWith("/") ? path : `/${path}`}`, {
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        return r.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/product-service.d.ts

@@ -0,0 +1,118 @@
+import { type LicenseStager } from "./license-registration.js";
+import type { ProductTemplateSource } from "./product-template-record.js";
+import type { ProductLicense, ProductRegistration, ProductSpec } from "./product-types.js";
+/**
+ * Result of registering a new product. `warnings` reserved for future
+ * non-fatal advisories surfaced alongside the success message; currently
+ * always empty because the only earlier soft warning (vite-dev URL)
+ * graduated into a hard rejection.
+ */
+export interface AddProductResult {
+    registration: ProductRegistration;
+    warnings: string[];
+}
+export interface AddProductOpts {
+    /** Per-product license stored on the registration record (#313). Callers
+     *  typically seed this from their global license setting when the operator
+     *  doesn't supply one at add time. */
+    license?: ProductLicense;
+}
+/**
+ * Storage backend for the registered-product list. Each consumer (norsk-ctl,
+ * norsk-mgr, …) supplies its own — typically a YAML file under the app's
+ * store directory, but the abstraction means anything addressable works.
+ */
+export interface ProductStore {
+    read(): ProductRegistration[];
+    update(fn: (current: ProductRegistration[]) => ProductRegistration[]): Promise<ProductRegistration[]>;
+}
+/**
+ * Allocates a port from a per-app range for container-kind products. ctl and
+ * mgr each have their own port range; supplying the allocator as a
+ * dependency keeps the SDK out of that business.
+ *
+ * Returns null when no free port is available; ProductService.add() turns
+ * that into a PORT_EXHAUSTED ProductError.
+ */
+export type AllocatePortFn = (used: Record<string, {
+    port: number;
+}>) => number | null;
+/** Callback consumers inject so the SDK can hand each manifest-declared
+ *  default product template to the host's product-template store. The signature
+ *  is intentionally narrow — `{ name, bytes, source }` is the common shape
+ *  norsk-ctl's `ProductTemplateService.importFromBytes` and norsk-mgr's
+ *  `saveProductTemplate` both already implement. */
+export type ImportProductTemplateBytesFn = (opts: {
+    name: string;
+    bytes: Uint8Array;
+    source: Extract<ProductTemplateSource, {
+        kind: "product-default";
+    }>;
+}) => Promise<void>;
+/** The container operations stopAll/restoreAll depend on, behind an interface
+ *  so tests can drive them without shelling out to Docker. Defaults wire
+ *  straight to docker-runner + the readiness probe. */
+export interface ProductContainerOps {
+    run(image: string, hostPort: number): Promise<string>;
+    remove(containerId: string): Promise<void>;
+    rename(containerId: string, name: string): Promise<void>;
+    waitForReady(baseUrl: string): Promise<void>;
+}
+export interface ProductServiceOptions {
+    store: ProductStore;
+    allocatePort: AllocatePortFn;
+    /** Optional: called once per `manifest.defaultProductTemplates` entry at
+     *  registration time. Omit on hosts that don't store product templates
+     *  (defaultProductTemplates is then silently skipped). */
+    importProductTemplateBytes?: ImportProductTemplateBytesFn;
+    /** Optional: copy a byol licence somewhere the host owns, so the path
+     *  recorded in the registry outlives whatever the operator passed in.
+     *  Omit on hosts that don't stage (the operator's path is then recorded). */
+    stageLicense?: LicenseStager;
+    /** Liveness probe for dev-mode products. Injectable for tests; defaults to a
+     *  fast timeout-bounded GET of the dev URL's `/manifest.json`. */
+    isDevUrlAlive?: (baseUrl: string) => Promise<boolean>;
+    /** Container lifecycle ops used by stopAll/restoreAll. Injectable for tests;
+     *  defaults to the real docker-runner functions. */
+    containerOps?: ProductContainerOps;
+}
+export declare class ProductService {
+    private readonly store;
+    private readonly allocatePort;
+    private readonly importProductTemplateBytes?;
+    private readonly stageLicense?;
+    private readonly isDevUrlAlive;
+    private readonly containerOps;
+    constructor(opts: ProductServiceOptions);
+    list(): ProductRegistration[];
+    /** Whether the product is actually up. Container-mode: we started it, so a
+     *  tracked containerId means running. Dev-mode: externally owned, so probe
+     *  the dev URL — registered no longer implies running. */
+    isRunning(reg: ProductRegistration): Promise<boolean>;
+    add(spec: ProductSpec, opts?: AddProductOpts): Promise<AddProductResult>;
+    remove(name: string): Promise<void>;
+    reload(name: string): Promise<ProductRegistration>;
+    /** Stop every running container-kind product and clear its tracked
+     *  containerId (model B: the daemon owns container lifecycle, so it reaps
+     *  the control planes it started). Dev-kind products are externally owned —
+     *  left alone. Clearing the id keeps the persisted store honest: a stale id
+     *  left behind would make isRunning() point at a container `--rm` reaped.
+     *  Best-effort per product — a failing `docker rm` is logged, never thrown,
+     *  so one stubborn container can't block a clean shutdown. */
+    stopAll(): Promise<void>;
+    /** Relaunch every container-kind product recorded in the store, refreshing
+     *  its containerId (model B: called once at daemon boot to re-create the
+     *  control planes stopped on the previous shutdown). Dev-kind products are
+     *  externally owned — skipped. Best-effort per product: one that fails to
+     *  come up is logged and left with its containerId cleared, so isRunning()
+     *  reports it down rather than pointing at a container that never started. */
+    restoreAll(): Promise<void>;
+    /** Stop (if still present) and relaunch a single container-kind product,
+     *  recording the fresh containerId. Used by the health monitor to recover a
+     *  product that has failed its liveness probe. Unlike restoreAll this is not
+     *  best-effort: a relaunch that never comes ready rejects, so the monitor
+     *  can count the failed attempt and eventually give up. The new id is
+     *  persisted before the readiness wait, so even a timed-out restart leaves a
+     *  tracked container the next restart can reap rather than orphan. */
+    restart(name: string): Promise<void>;
+}