@parity/product-lab 0.0.1-placeholder → 0.1.1

package/adapters/environment/engine/src/engine/node-isolation.d.ts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+export declare const forkIsolationSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    expose: z.ZodBoolean;
+    peers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    ipfsPeerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ForkIsolation = z.infer<typeof forkIsolationSchema>;
+/** Flags that bind a node's RPC or metrics to every interface. */
+export declare const EXTERNAL_FLAGS: Set<string>;
+/** How much a fork's collators log of their transaction pool (engine.json `txpoolLog`, backlog 190). */
+export declare const TXPOOL_LOG_LEVELS: readonly ["debug", "trace"];
+export type TxpoolLog = (typeof TXPOOL_LOG_LEVELS)[number];
+/**
+ * The log targets a fork's collators get on their own side (backlog 190). A transaction the pool accepted and later
+ * marks invalid reaches a client as one fixed text ("Extrinsic marked as invalid", polkadot-sdk#8497); a refusal at
+ * submission keeps its reason over RPC. `debug` (the default) logs how many transactions each revalidation found
+ * invalid and at which block, and how many the block builder reported (`fatp::report_invalid`); `trace` logs every
+ * transaction by hash with its validity (`validity=Ok(Err(Invalid(...)))`), at about 6 times debug's volume under
+ * load (docs/verification/2026-10-08-bulletin-invalid-reason.md, "Log volume"). Engine takes log targets at first
+ * boot only, so the lab adds them to the node's own `-l` list.
+ */
+export declare function nodeLogTargets(level?: TxpoolLog): readonly string[];
+/**
+ * A node's command line with the lab's pool log at `level`: a collator's own side (before `--`) drops an earlier
+ * level the lab added and gets `-l<target>=<level>` for each of nodeLogTargets(level) its `-l` lists do not set.
+ * Anything else is returned as it is: products submit to the parachains, a collator's relay side is an RPC-backed
+ * minimal node, and a relay validator's pool sees no product's transaction. Pure and idempotent; `collator` defaults
+ * to the own side saying `--collator` (zombie.json's lists do; a fork TOML's do not).
+ */
+export declare function withNodeLogTargets(args: readonly string[], level?: TxpoolLog, collator?: boolean): string[];
+/** How the fork's Bulletin collator authors (engine.json `bulletinAuthoring`, backlog 190). */
+export declare const BULLETIN_AUTHORING: readonly ["lookahead", "slot-based"];
+export type BulletinAuthoring = (typeof BULLETIN_AUTHORING)[number];
+/**
+ * A node's command line with the Bulletin collator's authoring set (backlog 190). Engine starts Asset Hub's and People's
+ * collators with `--authoring slot-based` and Bulletin's with the default lookahead collator, which on a fork builds a
+ * block again on a newer relay parent and retracts about one best block in five (862 "Collation built on a fork" in
+ * 6 h, against 0 on the slot-based chains). `slot-based` (the default since the A/B of 8 October 2026: on one light
+ * fork, 10 minutes each, forked collations 19 to 0, reorganizations 6 to 2, imports never best 20 to 3;
+ * docs/verification/2026-10-08-bulletin-invalid-reason.md) gives Bulletin's collator (its own side says `--ipfs-server`,
+ * which only Bulletin runs) `--authoring=slot-based` unless it already names an authoring; `lookahead`, Engine's
+ * choice, drops the lab's argument again. Anything else is returned as it is. Pure and idempotent.
+ */
+export declare function withBulletinAuthoring(args: readonly string[], authoring?: BulletinAuthoring, collator?: boolean): string[];
+/**
+ * A persisted node's command line, isolated. Pure and
+ * idempotent: derive it from zombie.json's original arguments every time, so
+ * `expose` can change later. `nodeKeyFile` replaces zombie-cli's name-derived
+ * `--node-key` (which also keeps the key out of argv and network.json);
+ * `peers` renames peer ids (old to new) in `--bootnodes` and `--reserved-nodes`.
+ */
+export declare function isolateNodeArgs(args: readonly string[], options: {
+    expose: boolean;
+    nodeKeyFile?: string;
+    peers?: Readonly<Record<string, string>>;
+    /** A parachain collator (its pool log, withNodeLogTargets). Default: its own side says `--collator`. */
+    collator?: boolean;
+    /** The collators' pool log (engine.json `txpoolLog`); default `debug`. */
+    txpoolLog?: TxpoolLog;
+    /** Bulletin's collator's authoring (engine.json `bulletinAuthoring`); default `slot-based`. */
+    bulletinAuthoring?: BulletinAuthoring;
+}): string[];
+/** A chain spec whose `bootNodes` name the renamed peers (old peer id to new). Nothing else changes. */
+export declare function renameBootNodes(spec: Record<string, unknown>, peers: Readonly<Record<string, string>>): Record<string, unknown>;
+/** The zombie.json fields isolation reads. */
+declare const zombieNode: z.ZodObject<{
+    name: z.ZodString;
+    multiaddr: z.ZodOptional<z.ZodString>;
+    inner: z.ZodObject<{
+        program: z.ZodString;
+        args: z.ZodArray<z.ZodString>;
+        data_dir: z.ZodString;
+        relay_data_dir: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type ZombieNode = z.infer<typeof zombieNode>;
+export declare function zombieNodes(directory: string): ZombieNode[];
+/** Every `--chain` file a node reads, both sides of `--`. */
+export declare function chainSpecFiles(args: readonly string[]): string[];
+/** The collator launcher writeIsolatedForkToml writes. */
+export declare const COLLATOR_WRAPPER = "collator.sh";
+export {};

package/adapters/environment/engine/src/engine/node-isolation.js

@@ -0,0 +1,164 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+export const forkIsolationSchema = z
+    .strictObject({
+    version: z.literal(1),
+    expose: z.boolean(),
+    peers: z.record(z.string(), z.string()).default({}),
+    ipfsPeerId: z.string().optional(),
+});
+export const EXTERNAL_FLAGS = new Set(["--unsafe-rpc-external", "--rpc-external", "--prometheus-external"]);
+function loopback(address) {
+    return address.replace(/^\/ip4\/0\.0\.0\.0\//, "/ip4/127.0.0.1/").replace(/^\/ip6\/::\//, "/ip6/::1/");
+}
+function renamePeer(address, peers) {
+    return address.replace(/\/p2p\/(\w+)$/, (_match, id) => `/p2p/${peers[id] ?? id}`);
+}
+export const TXPOOL_LOG_LEVELS = ["debug", "trace"];
+export function nodeLogTargets(level = "debug") {
+    return [`txpool=${level}`];
+}
+function logPatterns(args) {
+    const patterns = [];
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        let value;
+        if (arg === "-l" || arg === "--log")
+            value = args[index + 1];
+        else if (arg.startsWith("--log="))
+            value = arg.slice("--log=".length);
+        else if (arg.startsWith("-l"))
+            value = arg.slice(2);
+        if (value)
+            patterns.push(...value.split(","));
+    }
+    return patterns;
+}
+const LAB_TXPOOL_ARG = new RegExp(`^-ltxpool=(${TXPOOL_LOG_LEVELS.join("|")})$`);
+export function withNodeLogTargets(args, level = "debug", collator) {
+    const split = args.indexOf("--");
+    const own = split === -1 ? [...args] : args.slice(0, split);
+    if (!(collator ?? own.includes("--collator")))
+        return [...args];
+    const kept = own.filter((arg) => !LAB_TXPOOL_ARG.test(arg));
+    const targets = new Set(logPatterns(kept).map((pattern) => pattern.split("=")[0]));
+    const added = nodeLogTargets(level).filter((pattern) => !targets.has(pattern.split("=")[0])).map((pattern) => `-l${pattern}`);
+    return [...kept, ...added, ...(split === -1 ? [] : args.slice(split))];
+}
+export const BULLETIN_AUTHORING = ["lookahead", "slot-based"];
+const LAB_AUTHORING_ARG = "--authoring=slot-based";
+export function withBulletinAuthoring(args, authoring = "slot-based", collator) {
+    const split = args.indexOf("--");
+    const own = split === -1 ? [...args] : args.slice(0, split);
+    if (!(collator ?? own.includes("--collator")) || !own.includes("--ipfs-server"))
+        return [...args];
+    const kept = own.filter((arg) => arg !== LAB_AUTHORING_ARG);
+    const named = kept.some((arg) => arg === "--authoring" || arg.startsWith("--authoring="));
+    const added = authoring === "slot-based" && !named ? [LAB_AUTHORING_ARG] : [];
+    return [...kept, ...added, ...(split === -1 ? [] : args.slice(split))];
+}
+const PEER_FLAGS = ["--bootnodes", "--reserved-nodes"];
+function isolateArgList(args, expose, nodeKeyFile, relaySide, peers) {
+    const out = [];
+    let keyed = false;
+    const key = () => {
+        if (!keyed && nodeKeyFile)
+            out.push("--node-key-file", nodeKeyFile);
+        keyed = true;
+    };
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (nodeKeyFile && (arg === "--node-key" || arg === "--node-key-file")) {
+            index++;
+            key();
+            continue;
+        }
+        if (nodeKeyFile && (arg.startsWith("--node-key=") || arg.startsWith("--node-key-file="))) {
+            key();
+            continue;
+        }
+        if (!expose && EXTERNAL_FLAGS.has(arg))
+            continue;
+        if (!expose && arg === "--listen-addr" && index + 1 < args.length) {
+            out.push(arg, loopback(args[++index]));
+            continue;
+        }
+        if (!expose && arg.startsWith("--listen-addr=")) {
+            out.push(`--listen-addr=${loopback(arg.slice("--listen-addr=".length))}`);
+            continue;
+        }
+        const peerFlag = PEER_FLAGS.find((flag) => arg.startsWith(`${flag}=`));
+        if (peerFlag) {
+            out.push(`${peerFlag}=${renamePeer(arg.slice(peerFlag.length + 1), peers)}`);
+            continue;
+        }
+        if (PEER_FLAGS.includes(arg)) {
+            out.push(arg);
+            while (index + 1 < args.length && !args[index + 1].startsWith("-"))
+                out.push(renamePeer(args[++index], peers));
+            continue;
+        }
+        if (relaySide && !expose && arg === "--port" && index + 1 < args.length) {
+            out.push("--listen-addr", `/ip4/127.0.0.1/tcp/${args[++index]}`);
+            continue;
+        }
+        out.push(arg);
+    }
+    key();
+    if (!out.includes("--no-mdns"))
+        out.push("--no-mdns");
+    return out;
+}
+export function isolateNodeArgs(args, options) {
+    const peers = options.peers ?? {};
+    const split = args.indexOf("--");
+    const own = split === -1 ? args : args.slice(0, split);
+    const node = isolateArgList(own, options.expose, options.nodeKeyFile, false, peers);
+    const isolated = split === -1 ? node : [...node, "--", ...isolateArgList(args.slice(split + 1), options.expose, undefined, true, peers)];
+    const collator = options.collator ?? own.includes("--collator");
+    return withBulletinAuthoring(withNodeLogTargets(isolated, options.txpoolLog, collator), options.bulletinAuthoring, collator);
+}
+export function renameBootNodes(spec, peers) {
+    const isolated = { ...spec };
+    if (Array.isArray(spec.bootNodes))
+        isolated.bootNodes = spec.bootNodes.map((address) => (typeof address === "string" ? renamePeer(address, peers) : address));
+    return isolated;
+}
+const zombieNode = z
+    .looseObject({
+    name: z.string(),
+    multiaddr: z.string().optional(),
+    inner: z
+        .looseObject({
+        program: z.string(),
+        args: z.array(z.string()),
+        data_dir: z.string(),
+        relay_data_dir: z.string().nullish(),
+    }),
+});
+const zombieTopology = z
+    .looseObject({
+    relay: z.looseObject({ nodes: z.array(zombieNode) }),
+    parachains: z.record(z.string(), z.array(z.looseObject({ collators: z.array(zombieNode) }))),
+});
+export function zombieNodes(directory) {
+    const topology = zombieTopology.parse(JSON.parse(readFileSync(join(directory, "zombie.json"), "utf8")));
+    return [
+        ...topology.relay.nodes,
+        ...Object.values(topology.parachains).flatMap((groups) => groups.flatMap((group) => group.collators)),
+    ];
+}
+export function chainSpecFiles(args) {
+    const files = [];
+    args.forEach((arg, index) => {
+        if (arg === "--chain" && args[index + 1])
+            files.push(args[index + 1]);
+        else if (arg.startsWith("--chain="))
+            files.push(arg.slice("--chain=".length));
+    });
+    return files;
+}
+export const COLLATOR_WRAPPER = "collator.sh";

package/adapters/environment/engine/src/engine/node-temp-dir.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `sockaddr_un.sun_path` in bytes: 104 on macOS and the BSDs, 108 on Linux. The validator is Rust: its standard
+ * library's `UnixListener::bind` refuses a path of that many bytes or more ("path must be shorter than SUN_LEN"), so
+ * one byte less is the longest it binds (Node binds a 104-byte path on macOS; it is not the reference here).
+ */
+export declare const SUN_PATH_BYTES: Readonly<Record<string, number>>;
+/** The longest socket name a validator binds in its TMPDIR: polkadot's PVF host, `pvf-host-<prepare|execute>-<10>`. */
+export declare const PVF_SOCKET_NAME: string;
+/** The longest socket path a validator binds on `platform`; an unknown platform gets the smaller BSD size. */
+export declare function socketPathLimit(platform: string): number;
+/** Whether a validator's PVF sockets fit under `tmp` on `platform`. */
+export declare function pvfSocketsFit(tmp: string, platform: string): boolean;
+/** The short temp directory of the network kept in `network` (its data directory). */
+export declare function nodeTempDirPath(network: string): string;
+export interface NodeTempDir {
+    /** What the node processes' environment gains: `TMPDIR` when the inherited one is too long, else nothing. */
+    readonly env: Readonly<Record<string, string>>;
+    /** Why the nodes got a temp directory of their own (for the start's log), when they did. */
+    readonly reason?: string;
+    /** Remove the directory (when the network stops); safe to call more than once. */
+    remove(): void;
+}
+/**
+ * The temp directory the node processes of the network in `network` use. `inherited` is the TMPDIR they would
+ * inherit (unset: the system's). A stale directory of this network is removed first, whichever way it goes.
+ */
+export declare function nodeTempDir(network: string, inherited: string | undefined, platform?: string): NodeTempDir;

package/adapters/environment/engine/src/engine/node-temp-dir.js

@@ -0,0 +1,31 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { createHash } from "node:crypto";
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+export const SUN_PATH_BYTES = { darwin: 104, freebsd: 104, openbsd: 104, netbsd: 104, linux: 108 };
+export const PVF_SOCKET_NAME = `pvf-host-prepare-${"x".repeat(10)}`;
+export function socketPathLimit(platform) {
+    return (SUN_PATH_BYTES[platform] ?? 104) - 1;
+}
+export function pvfSocketsFit(tmp, platform) {
+    return Buffer.byteLength(join(tmp, PVF_SOCKET_NAME)) <= socketPathLimit(platform);
+}
+export function nodeTempDirPath(network) {
+    return join("/tmp", `pl-pvf-${createHash("sha256").update(network).digest("hex").slice(0, 12)}`);
+}
+export function nodeTempDir(network, inherited, platform = process.platform) {
+    const path = nodeTempDirPath(network);
+    rmSync(path, { recursive: true, force: true });
+    const tmp = inherited || tmpdir();
+    if (pvfSocketsFit(tmp, platform))
+        return { env: {}, remove() { } };
+    mkdirSync(path, { recursive: true, mode: 0o700 });
+    const bytes = Buffer.byteLength(join(tmp, PVF_SOCKET_NAME));
+    return {
+        env: { TMPDIR: path },
+        reason: `TMPDIR ${tmp} would give validators ${bytes}-byte PVF socket paths, over ${platform}'s ${socketPathLimit(platform)}: the nodes use ${path}`,
+        remove: () => rmSync(path, { recursive: true, force: true }),
+    };
+}

package/adapters/environment/engine/src/engine/owned-engine.d.ts

@@ -0,0 +1,312 @@
+import type { OwnedProcessStatus } from "@parity/product-lab/ports/system";
+import type { StartPhaseSink } from "@parity/product-lab/ports/environment";
+import { type EngineSession } from "../session/session.js";
+import type { RuntimeDependency } from "../session/runtime-dependency.js";
+import { EngineNodeLost, type EngineNodeSupervision, type EngineNodeSupervisionOptions } from "./engine-health.js";
+import { type PeopleLiteAllowance } from "./fork-setup.js";
+import type { EngineTopology } from "../topology/engine-topology.js";
+import { type EngineRun } from "../topology/engine-run.js";
+import { inspectIsolation } from "./fork-isolation.js";
+import { type EngineConfiguration, type EngineSystem } from "./engine-config.js";
+export { ENGINE_STOP, NODE_VERIFIER_OPTION, nodeVerifierArgs, type NodeVerifier, engineConfiguration, requireEngineSystem, type EngineConfiguration, type EngineSystem, type EngineTopologySystem } from "./engine-config.js";
+export { PREPARE_STOP, PrepareNotStopped, runEnginePrepare } from "./engine-prepare.js";
+export { engineServices } from "./engine-setup-jobs.js";
+/** Testcontainers-style lifecycle for the native Zombienet provider used by Engine.
+ * Each reset boots from an empty, owned directory (chain + DUB PostgreSQL).
+ * Downloaded binaries and the immutable fork bundle may be cached between runs.
+ */
+export declare class OwnedEngineDependency implements RuntimeDependency {
+    private readonly config;
+    private readonly reports;
+    private readonly system;
+    /**
+     * `topology`: a resolved relay-backed topology whose engineLaunchPlan is
+     * executed and whose ports are written. `persistence`: boot into this
+     * data directory and keep it (a persistent network's first start).
+     */
+    private readonly options;
+    readonly isolation: "fresh-network-per-scenario";
+    /** The running Engine tree: its registry (closed on stop when this dependency opened it), id and exit. */
+    private owned?;
+    private checkoutLock?;
+    private directory?;
+    /** Backlog 93: the nodes' own short TMPDIR when the inherited one is too long for a validator's PVF sockets. */
+    private nodeTemp?;
+    private session?;
+    private stopping?;
+    private progressAbort?;
+    private progress?;
+    /** The supervision of the running network's nodes (engine.json `nodeSupervision`), from readiness until stop. */
+    private supervision?;
+    private readonly lostListeners;
+    /** The node loss that ended the current network's supervision (cleared by the next start). */
+    lost?: EngineNodeLost;
+    /** What the current (or last) start executed: commands, ports, dashboard and the topology plan. */
+    run?: EngineRun;
+    /** Engine setup jobs and product-lab fork setup of the current start. */
+    setupReport?: {
+        jobs: {
+            name: string;
+            last: string;
+        }[];
+        forkSetup?: {
+            dotnsAttestationAllowance: {
+                finalizedBlock: number;
+                count: number;
+            };
+            /** Engine's own allowance job, checked on the chain (and granted by the lab when it had failed). */
+            peopleLiteAttestationAllowance: PeopleLiteAllowance;
+        };
+        isolation?: ReturnType<typeof inspectIsolation>;
+    };
+    private readonly persistence?;
+    constructor(config: EngineConfiguration, reports: string, system: EngineSystem, 
+    /**
+     * `topology`: a resolved relay-backed topology whose engineLaunchPlan is
+     * executed and whose ports are written. `persistence`: boot into this
+     * data directory and keep it (a persistent network's first start).
+     */
+    options?: {
+        topology?: EngineTopology;
+        persistence?: {
+            directory: string;
+        };
+        /** Where each start reports its phases (engine-start-phases.ts): bundle, binaries, network, services, setup jobs. */
+        phase?: StartPhaseSink;
+        /** Bounds of the node supervision (engine-health.ts defaults: a check every 5 s, 20 s per request, 2 misses). */
+        supervision?: Omit<EngineNodeSupervisionOptions, "signal" | "liveness">;
+    });
+    /** The Engine tree this dependency started, as its registry reports it (empty before start and after stop). */
+    processes(): OwnedProcessStatus[];
+    /**
+     * Start an owned Engine network. `signal` (the start context's) cancels a start in progress, and so does stop().
+     * The start is then joined: a preparatory command (bite, bundle fetch) is stopped through the registry, and no
+     * Engine process starts after it.
+     */
+    start(signal?: AbortSignal): Promise<EngineSession>;
+    private starting?;
+    private startAbort?;
+    /** A preparatory tree that did not stop: stop() retries it, and its data is removed only once it has stopped. */
+    private unstopped?;
+    private startOwned;
+    private releaseCheckout;
+    private provisionOwned;
+    /**
+     * The isolated TOML's ports: node ports from engine.json `nodePorts`, and Engine's eth-rpc on the port
+     * config/ports.env reserves for it (Engine's launcher passes none, so it took 8545), its cache under the data.
+     */
+    private bootstrapPorts;
+    /**
+     * Fork isolation inputs for a start into `directory`; undefined when isolation is off. The bundle counts as present only
+     * when verified complete (fork-bundle.ts); an incomplete one is said and downloaded again.
+     */
+    private isolationInput;
+    /** Take `<bundle>.lock` (waiting for another start's check or download, at most the start's bound). */
+    private lockForkBundle;
+    reset(signal?: AbortSignal): Promise<{
+        schemaVersion: 1;
+        runId: string;
+        network: "paseo-next-v2" | "previewnet";
+        namespace: "paseo" | "testnet";
+        ownership: "attached" | "owned";
+        mode: "fork" | "genesis";
+        createdAt: string;
+        identityBackend: string;
+        engine: {
+            [x: string]: unknown;
+            spawn: {
+                [x: string]: unknown;
+                spawnedAt: string;
+                network: "paseo-next-v2" | "previewnet";
+                mode: "fork" | "genesis";
+            };
+            dashboard: string;
+        };
+        chains: {
+            people: {
+                ws: string;
+                genesis: string;
+                initialFinalized: {
+                    hash: string;
+                    number: string;
+                };
+                finalized: {
+                    hash: string;
+                    number: string;
+                };
+                runtime: {
+                    [x: string]: unknown;
+                    specName: string;
+                    specVersion: number;
+                    transactionVersion: number;
+                };
+                codeHash: string;
+                observedAt: string;
+                readiness?: "answered" | "finality" | undefined;
+            };
+            "asset-hub": {
+                ws: string;
+                genesis: string;
+                initialFinalized: {
+                    hash: string;
+                    number: string;
+                };
+                finalized: {
+                    hash: string;
+                    number: string;
+                };
+                runtime: {
+                    [x: string]: unknown;
+                    specName: string;
+                    specVersion: number;
+                    transactionVersion: number;
+                };
+                codeHash: string;
+                observedAt: string;
+                readiness?: "answered" | "finality" | undefined;
+            };
+            bulletin: {
+                ws: string;
+                genesis: string;
+                initialFinalized: {
+                    hash: string;
+                    number: string;
+                };
+                finalized: {
+                    hash: string;
+                    number: string;
+                };
+                runtime: {
+                    [x: string]: unknown;
+                    specName: string;
+                    specVersion: number;
+                    transactionVersion: number;
+                };
+                codeHash: string;
+                observedAt: string;
+                readiness?: "answered" | "finality" | undefined;
+            };
+        };
+    }>;
+    /** Inputs for a relay-less fast baseline of this network's People chain.
+     * Pass them to `exportFastBaseline` from @product-lab/env-relayless. */
+    fastBaselineInputs(): {
+        source: {
+            schemaVersion: 1;
+            runId: string;
+            network: "paseo-next-v2" | "previewnet";
+            namespace: "paseo" | "testnet";
+            ownership: "attached" | "owned";
+            mode: "fork" | "genesis";
+            createdAt: string;
+            identityBackend: string;
+            engine: {
+                [x: string]: unknown;
+                spawn: {
+                    [x: string]: unknown;
+                    spawnedAt: string;
+                    network: "paseo-next-v2" | "previewnet";
+                    mode: "fork" | "genesis";
+                };
+                dashboard: string;
+            };
+            chains: {
+                people: {
+                    ws: string;
+                    genesis: string;
+                    initialFinalized: {
+                        hash: string;
+                        number: string;
+                    };
+                    finalized: {
+                        hash: string;
+                        number: string;
+                    };
+                    runtime: {
+                        [x: string]: unknown;
+                        specName: string;
+                        specVersion: number;
+                        transactionVersion: number;
+                    };
+                    codeHash: string;
+                    observedAt: string;
+                    readiness?: "answered" | "finality" | undefined;
+                };
+                "asset-hub": {
+                    ws: string;
+                    genesis: string;
+                    initialFinalized: {
+                        hash: string;
+                        number: string;
+                    };
+                    finalized: {
+                        hash: string;
+                        number: string;
+                    };
+                    runtime: {
+                        [x: string]: unknown;
+                        specName: string;
+                        specVersion: number;
+                        transactionVersion: number;
+                    };
+                    codeHash: string;
+                    observedAt: string;
+                    readiness?: "answered" | "finality" | undefined;
+                };
+                bulletin: {
+                    ws: string;
+                    genesis: string;
+                    initialFinalized: {
+                        hash: string;
+                        number: string;
+                    };
+                    finalized: {
+                        hash: string;
+                        number: string;
+                    };
+                    runtime: {
+                        [x: string]: unknown;
+                        specName: string;
+                        specVersion: number;
+                        transactionVersion: number;
+                    };
+                    codeHash: string;
+                    observedAt: string;
+                    readiness?: "answered" | "finality" | undefined;
+                };
+            };
+        };
+        template: string;
+        binary: string;
+    };
+    /** Wait until Engine's one-shot setup jobs (its initial-spec custom
+     * processes that are not services: attestation allowance, invites, design
+     * families, bootnodes) have exited. The dashboard is ready before they
+     * finish; stopping Engine then loses their transactions. */
+    /** Wait for Engine's one-shot setup jobs; `signal` (the start's) ends the wait at once. */
+    waitForSetupJobs(timeoutMs?: number, signal?: AbortSignal, progress?: (done: number, total: number, running: string[]) => void): Promise<{
+        name: string;
+        last: string;
+    }[]>;
+    /**
+     * The running network's node supervision (started at readiness unless engine.json `nodeSupervision` is false).
+     * Without one (supervision off) a supervision is started now and ends when `signal` aborts or stop() runs.
+     */
+    monitorNodes(signal: AbortSignal): Promise<EngineNodeSupervision>;
+    /**
+     * Called once when a node of the running network is lost (killed, unreachable or restarted), with the error naming
+     * it; at once when that already happened. Kept across reset(): each start's supervision reports here.
+     */
+    onLost(listener: (error: EngineNodeLost) => void): () => void;
+    /** Supervise every node of zombie.json `file`; Engine itself exiting is a loss too. */
+    private supervise;
+    /** `work`, or the supervision's node loss as soon as one happens (the work is left to settle; stop() follows). */
+    private whileSupervised;
+    /** Stop what this dependency owns. A start in progress is cancelled and joined first (its own cleanup runs). */
+    stop(): Promise<void>;
+    /** Retry a preparatory tree that did not stop; its data is removed only once no recorded member is alive. Never reports a clean stop over survivors. */
+    private stopUnstopped;
+    private stopOwned;
+}
+/** Engine's own test for a usable bundle: a manifest and at least one snapshot. */
+export declare function usableForkBundle(directory: string): boolean;