@parity/product-lab 0.0.1-placeholder → 0.1.0

package/composition/src/default-lab.js

@@ -0,0 +1,597 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+import { existsSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { Enum } from "polkadot-api";
+import { DEFAULT_FEATURES, devAccount, fromEnv, isSecretSource, liveEnvironmentId, mergeRequirements, nameEnvironment, } from "@parity/product-lab";
+import { isTopology, preOnboarded } from "@parity/product-lab/domain";
+import { deployedLocalRequirements } from "@parity/product-lab/deploy-bulletin";
+import { liveNetworkEnvironment } from "@parity/product-lab/env-attached";
+import { chopsticksTopology } from "@parity/product-lab/env-chopsticks";
+import { DEFAULT_RELAYLESS_PORTS, relaylessTopology } from "@parity/product-lab/env-relayless";
+import { paseoCopy, previewnetCopy } from "./network-copies.js";
+import { DEFAULT_SESSION_LAUNCHES } from "./deployed-app-server.js";
+import { attachedForkEnvironment } from "./fork-attach.js";
+import { chopsticksOfFast, chopsticksOfFastPorts } from "./chopsticks-of-fast.js";
+import { copiesDirectory, forkPortBase, machineEntries, machineInputs, MACHINE_VARIABLES, workerCache } from "./machine-inputs.js";
+import { ADAPTER_LABELS } from "./adapter-catalogue.js";
+import { chainConnector } from "./chain-connections.js";
+import { platformIntegration } from "./platform/platform-integration.js";
+import { productLabCacheDir } from "@parity/product-lab/versions-github";
+import { productVersions } from "./product-versions.js";
+import { declaredDevServer, detectDevServer } from "./default-dev-server.js";
+import { peopleDevGenesis } from "./people-dev/genesis.js";
+import { DEFAULT_FAST_ONBOARDING, DEFAULT_PERSON_PRODUCT, personProductId } from "./people-dev/member-key.js";
+import { insideProductLabCheckout } from "./checkout.js";
+import { LAB_PORTS_VARIABLE, parseLabPorts } from "./node-system.js";
+import { Sr25519KeyDerivation } from "@parity/product-lab/keys-sr25519";
+import { lockedRelease, releaseTakesLocalEndpoints, TRUAPI_CLI_HOST_OPTIONS } from "@parity/product-lab/host-truapi-cli";
+import { TRUAPI_WASM_HOST_OPTIONS, TRUAPI_WASM_LAB_DEFAULTS } from "@parity/product-lab/host-truapi-wasm";
+export const LOCAL_PEOPLE_SIGNING = { customSignedExtensions: { VerifyMultiSignature: { value: Enum("Disabled") }, RestrictOrigins: { value: false } } };
+const FAST_CHAINS = ["people", "asset-hub", "bulletin", "web3-storage"];
+export const LIVE_NETWORK_PRESETS = {
+    "next-v2": {
+        network: "paseo-next-v2",
+        label: "Live Paseo next-v2",
+        endpoints: {
+            people: "wss://paseo-people-next-system-rpc.polkadot.io",
+            "asset-hub": "wss://paseo-asset-hub-next-rpc.polkadot.io",
+            bulletin: "wss://paseo-bulletin-next-rpc.polkadot.io",
+        },
+        identityBackend: "https://identity-backend-next.parity-testnet.parity.io",
+    },
+    previewnet: { network: "previewnet", label: "Live Previewnet" },
+};
+const DECIMALS = { PAS: 10, DOT: 10, KSM: 12, WND: 12, ROC: 12 };
+export function planckOf(amount) {
+    const match = /^\s*(\d+)(?:\.(\d+))?\s*([A-Za-z]+)\s*$/.exec(amount);
+    const decimals = match ? DECIMALS[match[3].toUpperCase()] : undefined;
+    if (!match || decimals === undefined)
+        throw new Error(`"${amount}" is not an amount the lab reads: write it as "<number> <symbol>", one of ${Object.keys(DECIMALS).join(", ")} ("5 PAS")`);
+    const fraction = (match[2] ?? "").padEnd(decimals, "0");
+    if (fraction.length > decimals)
+        throw new Error(`"${amount}" has more decimals than ${match[3].toUpperCase()}'s ${decimals}`);
+    return (BigInt(match[1]) * 10n ** BigInt(decimals) + BigInt(fraction || "0")).toString();
+}
+export function millisecondsOf(duration) {
+    const match = /^\s*(\d+(?:\.\d+)?)\s*(ms|s|m)\s*$/.exec(duration);
+    if (!match)
+        throw new Error(`"${duration}" is not a duration the lab reads: write "500ms", "6s" or "2m"`);
+    return Math.round(Number(match[1]) * (match[2] === "ms" ? 1 : match[2] === "s" ? 1000 : 60_000));
+}
+const walletSecret = (person) => `${person.toLowerCase().replace(/[^a-z0-9]+/g, "-")}-wallet`;
+export function labDefinitionFrom(config, context) {
+    const { root } = context;
+    const output = context.env?.[OUTPUT_VARIABLE] || join(root, ".product-lab");
+    const entries = [];
+    const say = (entry) => entries.push(entry);
+    const stepSets = Array.isArray(config.app.steps) ? config.app.steps : [config.app.steps];
+    const steps = stepSets[0];
+    const appId = steps.id;
+    const label = config.app.label ?? config.name ?? steps.product?.label ?? steps.id;
+    const name = config.name ?? label;
+    say({ key: "name", label: "Lab name", value: name, source: config.name ? "yours" : "default", ...(config.name ? {} : { why: "the app's label" }), change: `name: "${name}"` });
+    const launch = appLaunch(config.app);
+    const { chains, requires: appRequires, added } = launchRequirements(config.app, launch);
+    say({ key: "app", label: "App", value: { id: appId, label }, source: "yours", why: "its id is its steps' id" });
+    say({ key: "app.chains", label: "Chains the app needs", value: chains, source: "yours", ...(added.length ? { why: `app.chains, and ${added.join(", ")} for the ${launch} launch` } : {}), change: `app: { chains: [${config.app.chains.map((chain) => `"${chain}"`).join(", ")}] }` });
+    const machine = machineInputs(context.env ?? {}, Object.values(config.live ?? {}).flatMap((live) => Object.keys(live?.people ?? {})));
+    const ownSessions = config.advanced?.sessions !== undefined;
+    say({
+        key: "app.launch", label: "How hosts get the app", value: launch, source: config.app.launch ? "yours" : "default",
+        why: `${LAUNCH_WORDS[launch]}${ownSessions ? "; the lab's own sessions (advanced.sessions) launch it" : ""}${config.app.launch ? "" : config.app.deployed ? " (app.deployed is set)" : ""}`,
+        change: launch !== "dev" ? `app: { launch: "dev" }${launch === "deployed" ? " without app.deployed" : ""}` : ownSessions ? 'app: { launch: "deployed-local" }' : 'app: { deployed: { name: "<name>.dot" } } (the deployed launch)',
+        options: LAUNCHES.filter((other) => other !== launch && (ownSessions || DEFAULT_SESSION_LAUNCHES.includes(other))),
+    });
+    if (!ownSessions)
+        for (const missing of LAUNCHES.filter((other) => !DEFAULT_SESSION_LAUNCHES.includes(other)))
+            say({
+                key: `app.launch.${missing}`, label: `The ${missing} launch`, value: false, source: "default",
+                why: `${LAUNCH_WORDS[missing]}: the lab's default session cannot do it yet, so a start with app: { launch: "${missing}" } is refused by name${launch === missing ? " (this config asks for it)" : ""}`,
+                change: launch === missing ? 'app: { launch: "dev" }' : `app: { launch: "${missing}" } with a session of the lab's own (advanced.sessions)`,
+            });
+    const environments = {};
+    const options = config.environments ?? {};
+    const fast = options.fast;
+    const sponsored = [...(chains.includes("bulletin") ? ["app.chains includes bulletin"] : []), ...(appRequires?.capabilities ?? []).filter((capability) => STATEMENT_STORE.includes(capability)).map((capability) => `app.requires names ${capability}`)];
+    const persons = fast !== false && sponsored.length > 0;
+    const onboarding = (fast ? fast.onboarding : undefined) ?? DEFAULT_FAST_ONBOARDING;
+    const personProduct = fast ? fast.personProduct : undefined, derivedUnder = personProductId("<network>", personProduct ?? DEFAULT_PERSON_PRODUCT);
+    if (fast !== false) {
+        const made = chains.filter((chain) => FAST_CHAINS.includes(chain));
+        const fastChains = [...new Set(["people", ...made])];
+        const pace = fast?.pace;
+        const timing = pace === undefined ? {} : typeof pace === "string" ? { pace } : { blockTime: millisecondsOf(pace.blockTime) };
+        const base = context.environmentPorts;
+        const ports = base === undefined ? undefined
+            : typeof base === "object" ? Object.fromEntries(Object.entries(base).filter(([key]) => fastChains.includes(key)))
+                : Object.fromEntries(Object.entries(RELAYLESS_PORT_OFFSETS).filter(([key]) => key === "ethRpc" || fastChains.includes(key)).map(([key, offset]) => [key, base + offset]));
+        const machineHooks = {
+            ...(machine.baseline ? { runtimes: machine.baseline.runtimes, binaries: machine.baseline.binaries } : {}),
+            ...(machine.nodeLog ? { nodeArgs: Object.fromEntries(fastChains.map((chain) => [chain, [`-l${machine.nodeLog}`]])) } : {}),
+        };
+        environments.fast = nameEnvironment(relaylessTopology({ chains: fastChains, ...timing, ...(ports ? { ports } : {}), ...(persons ? peopleDevGenesis(fastChains) : {}), ...machineHooks }), {
+            label: "Local dev chain (Omni Node)",
+            description: `${fastChains.join(", ")} on this machine from a fresh development genesis: blocks in seconds, nothing live touched`,
+            kind: "fast-local",
+        });
+        const missing = chains.filter((chain) => !FAST_CHAINS.includes(chain));
+        say({
+            key: "environments.fast", label: "Local dev chain (Omni Node)", value: { chains: fastChains, ...(pace === undefined ? {} : { pace }), ...(ports ? { ports: typeof base === "number" ? `${base}-${base + 99}` : ports } : {}) }, source: fast ? "yours" : "default",
+            why: `offered for every app; it runs People (the hosts need it)${made.filter((chain) => chain !== "people").length ? ` and ${made.filter((chain) => chain !== "people").join(", ")}` : ""}${missing.length ? `; it cannot make ${missing.join(", ")}` : ""}${pace === undefined ? "; with no pace set, a chain kept between starts (the interactive lab) runs in real time, so it never goes stale, and a clean start (product-lab test, CI) runs fast" : ""}`,
+            change: "environments: { fast: { pace: \"real-time\" } } (or fast: false)", options: ["fast", "real-time", "{ blockTime }", "false"],
+        });
+    }
+    else
+        say({ key: "environments.fast", label: "Local dev chain (Omni Node)", value: false, source: "yours", change: "environments: { fast: {} }" });
+    const fork = forkPortBase(context.env ?? {});
+    const copySettings = { directory: copiesDirectory(output), owner: name, portBase: fork.base };
+    const copy = (key, made, offeredByDefault, words) => {
+        const value = options[key];
+        if (value === false || (!offeredByDefault && value === undefined)) {
+            say({ key: `environments.${key}`, label: words, value: false, source: value === false ? "yours" : "default", ...(value === false ? {} : { why: "off unless listed" }), change: `environments: { "${key}": {} }` });
+            return;
+        }
+        const attach = machine.forkAttach;
+        if (attach) {
+            environments[key] = key === "paseo-copy"
+                ? nameEnvironment(attachedForkEnvironment(attach), { kind: "network-copy", label: `${words} (attached)`, description: `The Engine fork of paseo-next-v2 running on ports ${attach.base}+, attached (${MACHINE_VARIABLES.forkAttach}): never started, reset or stopped` })
+                : nameEnvironment(attachRefused(key, attach.base), { kind: "network-copy", label: words });
+            say({ key: `environments.${key}`, label: words, value: key === "paseo-copy" ? { attached: `ports ${attach.base}+` } : { refused: `${MACHINE_VARIABLES.forkAttach} is set` }, source: "machine", why: `${MACHINE_VARIABLES.forkAttach}=${attach.base}: ${key === "paseo-copy" ? "the running fork on that block, attached instead of the saved copy" : "it attaches paseo-copy only, so this copy is refused while it is set"}`, change: `unset ${MACHINE_VARIABLES.forkAttach}` });
+            return;
+        }
+        Object.assign(environments, made({ id: key, ...copySettings }));
+        say({ key: `environments.${key}`, label: words, value: { option: value?.option ?? "chosen by this machine's size", ports: `${fork.base}-${fork.base + 999}`, folder: join(copySettings.directory, key) }, source: value ? "yours" : "default", why: `${value ? "" : "offered for every app; "}ports: ${fork.why}`, change: `environments: { "${key}": { option: "light" } } (or false)`, options: ["full", "light", "false"] });
+    };
+    copy("paseo-copy", (made) => paseoCopy(made), true, "Local copy of Paseo");
+    copy("previewnet-copy", (made) => previewnetCopy(made), false, "Local copy of Previewnet");
+    const chopsticks = options.chopsticks;
+    if (chopsticks && chopsticks.from === "fast") {
+        const fastTopology = environments.fast;
+        if (!fastTopology)
+            throw new Error('environments.chopsticks copies the local dev chain (from: "fast"), which this config turns off (environments: { fast: false })');
+        const fastPorts = fastTopology.ports ?? {};
+        environments.chopsticks = nameEnvironment(chopsticksOfFast({ chains: chopsticks.chains, fastPorts, root, environments: join(output, "environments"), ...(machine.chopsticksBin ? { bin: machine.chopsticksBin } : {}) }), {
+            label: "Copy of the local dev chain (Chopsticks)", kind: "chain-copy",
+            description: `${chopsticks.chains.join(", ")} of the local dev chain, started here from the locked releases and copied block by block through Chopsticks: no public network`,
+        });
+        const { copy: copyPorts, upstream } = chopsticksOfFastPorts({ chains: chopsticks.chains, fastPorts });
+        say({ key: "environments.chopsticks", label: "Chopsticks", value: { chains: chopsticks.chains, from: "fast", ports: copyPorts, upstream }, source: "yours", why: "a copy of the local dev chain: the lab starts its chains as the upstream, each copy 2 ports after the local dev chain's, its upstream 4 after" });
+    }
+    else if (chopsticks) {
+        environments.chopsticks = nameEnvironment(chopsticksTopology({ chains: [...chopsticks.chains], ...chopsticksFrom(chopsticks) }), { label: "Chopsticks", kind: "chain-copy" });
+        say({ key: "environments.chopsticks", label: "Chopsticks", value: chopsticks, source: "yours" });
+    }
+    else if (Object.keys(config.advanced?.environments ?? {}).includes("chopsticks"))
+        say({ key: "environments.chopsticks", label: "Chopsticks", value: "the lab's own, under advanced.environments", source: "yours", why: "advanced.environments declares its own chopsticks environment" });
+    else
+        say({ key: "environments.chopsticks", label: "Chopsticks", value: false, source: chopsticks === false ? "yours" : "default", why: "off unless listed", change: 'environments: { chopsticks: { chains: ["people"], from: "paseo-next-v2" } }' });
+    const secrets = {};
+    const actors = {};
+    let deployer;
+    for (const [network, live] of Object.entries(config.live ?? {})) {
+        const preset = LIVE_NETWORK_PRESETS[network];
+        if (!preset)
+            throw new Error(`live.${network}: the lab knows the live networks ${Object.keys(LIVE_NETWORK_PRESETS).join(", ")}`);
+        const id = liveEnvironmentId(network);
+        const { people: named = {}, newPeople, deployContractsAs } = live;
+        const people = Object.entries(named);
+        for (const [person, variable] of people) {
+            const secret = walletSecret(person);
+            secrets[secret] = { ...secrets[secret], [id]: fromEnv(variable) };
+            const account = launch === "deployed" ? undefined : machine.liveAccounts?.[person];
+            actors[person] = preOnboarded(secret, account ? { account } : {});
+        }
+        if (deployContractsAs !== undefined) {
+            if (!named[deployContractsAs])
+                throw new Error(`live.${network}.deployContractsAs names ${deployContractsAs}, who is not one of its people (${people.map(([person]) => person).join(", ") || "none"})`);
+            deployer = { secret: walletSecret(deployContractsAs), environment: id };
+        }
+        const writes = people.length > 0;
+        let newIdentities;
+        if (newPeople) {
+            if (!named[newPeople.fundedBy])
+                throw new Error(`live.${network}.newPeople.fundedBy names ${newPeople.fundedBy}, who is not one of its people`);
+            const fund = typeof newPeople.fund === "string" ? { [chains[0] ?? "people"]: planckOf(newPeople.fund) } : Object.fromEntries(Object.entries(newPeople.fund).map(([chain, amount]) => [chain, planckOf(amount)]));
+            newIdentities = { funder: walletSecret(newPeople.fundedBy), usernamePrefix: newPeople.prefix, fund, maxPerRun: newPeople.maxPerRun ?? 1 };
+        }
+        environments[id] = nameEnvironment(liveNetworkEnvironment({
+            network: preset.network,
+            label: `${preset.label}${writes ? " (writes)" : ""}`,
+            reason: `${label} on ${preset.label}${writes ? `, writing as ${people.map(([person]) => person).join(", ")}` : ", read only"}`,
+            access: writes ? "read-write" : "read-only",
+            endpoints: () => preset.endpoints ?? {},
+            ...(preset.identityBackend ? { services: () => ({ identityBackend: preset.identityBackend }) } : {}),
+            ...(newIdentities ? { newIdentities } : {}),
+        }), { label: `${preset.label}${writes ? " (writes)" : ""}`, kind: "live" });
+        const unset = people.filter(([, variable]) => !context.env?.[variable]).map(([, variable]) => variable);
+        say({
+            key: `live.${network}`, label: preset.label, source: "yours",
+            value: { access: writes ? "read-write" : "read-only", people: people.map(([person, variable]) => ({ person, variable, set: !!context.env?.[variable] })), ...(newIdentities ? { newPeople: { ...newIdentities, funder: newPeople.fundedBy } } : {}) },
+            why: writes ? `writes as the people named, each by the variable holding their phrase${unset.length ? `; not set here: ${unset.join(", ")}` : ""}` : "no people named: read only",
+            ...(writes ? { set: unset.length === 0 } : {}),
+            ...(!writes ? { change: livePeopleLine(network) } : unset.length ? { change: unset.map((variable) => `export ${variable}=<their recovery phrase>`).join("; ") } : {}),
+        });
+    }
+    for (const [network, preset] of Object.entries(LIVE_NETWORK_PRESETS))
+        if (!config.live?.[network] && preset.endpoints)
+            say({ key: `live.${network}`, label: preset.label, value: false, source: "default", why: "off unless listed", change: `${livePeopleLine(network)} (or live: { "${network}": {} } to read only)`, options: ["{}", "{ people }"] });
+    const hostsConfig = config.hosts ?? {};
+    const hosts = {};
+    const hostAdapters = {};
+    const cli = hostsConfig["truapi-cli"];
+    if (cli !== false) {
+        hostAdapters["truapi-cli"] = {};
+        hosts["truapi-cli"] = { kind: "truapi-cli", options: { patches: ["local-network"], stateRoot: join(output, "hosts"), ...(cli ?? {}) } };
+    }
+    say({ key: "hosts.truapi-cli", label: "truAPI CLI host", value: cli === false ? false : { ...declaredDefaults(TRUAPI_CLI_HOST_OPTIONS), ...(cli ?? {}) }, source: cli === undefined ? "default" : "yours", ...hostChange("truapi-cli", TRUAPI_CLI_HOST_OPTIONS, cli === false) });
+    const wasm = hostsConfig["truapi-wasm"];
+    if (wasm !== false) {
+        hostAdapters["truapi-wasm"] = {};
+        hosts["truapi-wasm"] = { kind: "truapi-wasm", options: { ...TRUAPI_WASM_LAB_DEFAULTS, ...(wasm ?? {}) } };
+    }
+    say({ key: "hosts.truapi-wasm", label: "truAPI WASM host", value: wasm === false ? false : { ...declaredDefaults(TRUAPI_WASM_HOST_OPTIONS), ...TRUAPI_WASM_LAB_DEFAULTS, ...(wasm ?? {}) }, source: wasm === undefined ? "default" : "yours", ...hostChange("truapi-wasm", TRUAPI_WASM_HOST_OPTIONS, wasm === false) });
+    const dotli = hostsConfig.dotli;
+    if (dotli !== undefined && dotli !== false) {
+        hostAdapters.dotli = {};
+        hosts.dotli = { kind: "dotli", options: { ...dotli } };
+    }
+    say({ key: "hosts.dotli", label: "dot.li host", value: dotli !== undefined && dotli !== false, source: dotli === undefined ? "default" : "yours", ...(dotli === undefined ? { why: "off unless turned on" } : {}), change: "hosts: { dotli: {} }", options: ["{}", "false"] });
+    if (dotli !== undefined && dotli !== false) {
+        const hostPort = dotli.hostPort;
+        say(hostPort === undefined
+            ? { key: "hosts.dotli.hostPort", label: "dot.li host's port", value: "reserved when the host starts", source: "default", why: "a free port the lab reserves", change: "hosts: { dotli: { hostPort: 38500 } }" }
+            : { key: "hosts.dotli.hostPort", label: "dot.li host's port", value: hostPort, source: "yours", change: "hosts: { dotli: {} } (a free port the lab reserves)" });
+    }
+    const defaultHost = config.defaultHost ?? "truapi-cli";
+    if (!(defaultHost in hosts))
+        throw new Error(`defaultHost is ${defaultHost}, which is turned off; turn it on in hosts or choose one of ${Object.keys(hosts).join(", ") || "none"}`);
+    say({ key: "defaultHost", label: "Default host", value: defaultHost, source: config.defaultHost ? "yours" : "default", change: `defaultHost: "${defaultHost}"`, options: Object.keys(hosts) });
+    const defaultEnvironment = config.defaultEnvironment ?? (environments.fast ? "fast" : Object.keys(environments)[0]);
+    const offered = [...Object.keys(environments), ...Object.keys(config.advanced?.environments ?? {}).filter((id) => !(id in environments))];
+    if (defaultEnvironment !== undefined && !offered.includes(defaultEnvironment))
+        throw new Error(`defaultEnvironment is ${defaultEnvironment}, which this lab does not offer (${offered.join(", ")})`);
+    say({ key: "defaultEnvironment", label: "Default environment", value: defaultEnvironment ?? null, source: config.defaultEnvironment ? "yours" : "default", change: `defaultEnvironment: "${defaultEnvironment ?? "fast"}"`, options: offered });
+    const server = launch !== "dev" ? { devServer: undefined, why: `the ${launch} launch serves the app's build, not a dev server` } : config.app.devServer ? declaredDevServer(root, config.app.devServer) : detectDevServer(root);
+    const app = {
+        label,
+        ...(persons ? { persons: { environments: ["fast"], standIn: chains.includes("bulletin"), onboarding, ...(personProduct !== undefined ? { personProduct } : {}) } } : {}),
+        integration: steps,
+        requires: { chains, ...(appRequires ?? {}) },
+        ...(launch === "dev" ? {} : { launch }),
+        fundingSigning: { people: LOCAL_PEOPLE_SIGNING },
+        ...(server.devServer ? { devServer: { ...server.devServer, ...(config.app.settings ? { settings: config.app.settings } : {}) } } : {}),
+        ...(config.app.ready ? { ready: config.app.ready } : {}),
+        ...(config.app.deployed ? { deployed: config.app.deployed } : {}),
+        ...(config.app.restartOn?.length && launch === "dev" ? { watch: { paths: watchedSource(root, server.devServer?.cwd ?? "app"), restart: [...config.app.restartOn] } } : {}),
+        ...(config.hostBypass ? { hostBypass: config.hostBypass === "allow" ? { mode: "allow", reason: 'the lab config allows it (hostBypass: "allow")' } : { mode: config.hostBypass } } : {}),
+    };
+    say({ key: "app.devServer", label: "Dev server", value: server.devServer ?? null, source: config.app.devServer && launch === "dev" ? "yours" : server.devServer ? "detected" : "default", ...(server.why ? { why: server.why } : {}), change: 'app: { devServer: { command: "vite", args: ["--port", "{port}"], cwd: "app" } }' });
+    say({
+        key: "app.people", label: "New people on the local dev chain", source: "detected",
+        value: fast === false ? null : persons ? `persons on People (the lab attester${chains.includes("bulletin") ? "; the lab stands in for XCM to Bulletin" : ""}), funded by no one` : "funded wallets",
+        why: fast === false ? "no local dev chain" : persons ? `the app writes through sponsored paths: ${sponsored.join(", ")}` : "the app's chains include no bulletin and its requires name no statement-store",
+    });
+    const checkout = context.checkout ?? insideProductLabCheckout();
+    const cliRelease = lockedRelease(context.hostLockFile);
+    const cliLocal = checkout || releaseTakesLocalEndpoints(cliRelease);
+    const cliGap = `the truAPI CLI host's locked release (${cliRelease.release}) does not take the lab's local endpoints yet (https://github.com/paritytech/host-rust-core/pull/1166)`;
+    const cliKeeps = `the truAPI CLI host, which does, needs a release that takes the lab's local endpoints; ${cliRelease.release} does not: https://github.com/paritytech/host-rust-core/pull/1166`;
+    say({
+        key: "environments.fast.onboarding", label: "How the lab onboards new people on the local dev chain", value: persons ? onboarding : null, source: fast && fast.onboarding ? "yours" : "default",
+        why: !persons
+            ? `not used: ${fast === false ? "no local dev chain" : "the app gets funded wallets, not persons"}`
+            : onboarding === "released"
+                ? "the lab computes each new person's People member key with @parity/truapi-host's ringVrfMember and reads its ring on People: no CLI host, so it runs in a product too"
+                : checkout
+                    ? "the truAPI CLI host's alloc-check reads each new person's member key and ring (product-lab's checkout)"
+                    : cliLocal
+                        ? `the truAPI CLI host's alloc-check reads each new person's member key and ring (its locked release, ${cliRelease.release})`
+                        : `refused in a product: ${cliGap}`,
+        change: onboarding === "released" ? 'environments: { fast: { onboarding: "truapi-cli" } }' : 'environments: { fast: { onboarding: "released" } }',
+        options: ["released", "truapi-cli"],
+        ...(persons && onboarding === "truapi-cli" && !cliLocal
+            ? { cannotStart: { environments: ["fast"], problem: `onboarding "truapi-cli" is refused in a product: ${cliGap}; remove it to use "released"` } }
+            : {}),
+    });
+    say({
+        key: "environments.fast.personProduct", label: "The person product new people's member keys are derived under", value: persons ? (personProduct ?? DEFAULT_PERSON_PRODUCT) : null, source: personProduct !== undefined ? "yours" : "default", change: 'environments: { fast: { personProduct: "<your person product\'s label>" } }',
+        why: !persons ? `not used: ${fast === false ? "no local dev chain" : "the app gets funded wallets, not persons"}` : onboarding === "truapi-cli" ? "not used: the truAPI CLI host's alloc-check derives member keys under its own preset" : `each new person's People member key is derived under ${derivedUnder}, the network's suffix from its routes${personProduct !== undefined ? "" : ": the label the released truAPI host derives under"}`,
+        ...(persons && onboarding === "truapi-cli" && personProduct !== undefined ? { cannotStart: { environments: ["fast"], problem: `personProduct "${personProduct}" applies to onboarding "released" only: the truAPI CLI host's alloc-check derives member keys under its own preset; remove one of them` } } : {}),
+    });
+    say({ key: "app.ready", label: "Ready when", value: config.app.ready ?? "the host says the app connected", source: config.app.ready ? "yours" : "default", change: 'app: { ready: { testId: "status", attribute: "data-state", value: "ready" } }' });
+    const detectedSettings = !config.app.settings && !config.app.devServer ? server.devServer?.settings : undefined;
+    if (config.app.settings)
+        say({ key: "app.settings", label: "Settings the app reads", value: config.app.settings, source: "yours" });
+    else if (detectedSettings)
+        say({ key: "app.settings", label: "Settings the app reads", value: detectedSettings, source: "detected", why: "a Vite dev server: the names the lab's Vite default passes", change: 'app: { settings: { productId: "VITE_MY_PRODUCT_ID", genesis: "VITE_{CHAIN}_GENESIS" } }' });
+    if (config.app.deployed)
+        say({ key: "app.deployed", label: "Deployed build", value: config.app.deployed, source: "yours" });
+    if (config.app.restartOn)
+        say({ key: "app.restartOn", label: "Restart people when these change", value: config.app.restartOn, source: "yours" });
+    say({ key: "hostBypass", label: "Host check", value: config.hostBypass ?? "warn", source: config.hostBypass ? "yours" : "default", change: 'hostBypass: "fail"', options: ["warn", "fail", "allow"] });
+    const integrations = stepSets.slice(1).map((set) => ({ ...set, standalone: true }));
+    if (config.app.contracts && Object.keys(config.app.contracts).length) {
+        secrets["platform-signer"] = deployer ? { ...Object.fromEntries(Object.keys(environments).filter((id) => !id.startsWith("live-")).map((id) => [id, devAccount("//Alice")])), [deployer.environment]: fromEnv(liveVariable(config, deployer)) } : devAccount("//Alice");
+        integrations.push(platformIntegration({ chains: chainConnector({ people: LOCAL_PEOPLE_SIGNING }), contracts: Object.fromEntries(Object.entries(config.app.contracts).map(([contract, file]) => [contract, join(root, file)])) }));
+        say({ key: "app.contracts", label: "Contracts", value: config.app.contracts, source: "yours", why: deployer ? `deployed by the lab's development account locally, by ${Object.keys(config.live ?? {}).length ? "the person deployContractsAs names" : "nobody"} on live` : "deployed by the lab's development account" });
+    }
+    const companions = {};
+    for (const [id, companion] of Object.entries(config.companions ?? {})) {
+        if (id === appId)
+            throw new Error(`companions.${id}: ${id} is the app's own id (its first step set's)`);
+        companions[id] = {
+            label: companion.label ?? id,
+            integration: companion.steps,
+            requires: { chains: [...(companion.chains ?? chains)], ...(companion.requires ?? {}) },
+            fundingSigning: { people: LOCAL_PEOPLE_SIGNING },
+            ...(companion.devServer ? { devServer: declaredDevServer(root, companion.devServer).devServer } : {}),
+        };
+        say({ key: `companions.${id}`, label: companion.label ?? id, value: { chains: companion.chains ?? chains, ...(companion.requires ? { requires: companion.requires } : {}), devServer: companion.devServer ? "its own" : "none: opened by the app" }, source: "yours", why: "an app beside the product's own, opened by it in the same wallet" });
+    }
+    if (config.devices)
+        say({ key: "devices", label: "Devices", value: config.devices, source: "yours" });
+    else
+        say({ key: "devices", label: "Devices", value: false, source: "default", why: "none: the window's own size", change: 'devices: ["Pixel 7", "Desktop"]' });
+    const features = [...(config.features ?? DEFAULT_FEATURES)];
+    say({ key: "features", label: "Features", value: features, source: config.features ? "yours" : "default", change: 'features: ["lab/features/**/*.feature"]' });
+    const characters = Object.fromEntries(Object.entries(config.characters ?? {}).map(([character, made]) => [character, Array.isArray(made) ? { steps: [...made] } : made]));
+    if (config.characters)
+        say({ key: "characters", label: "Characters", value: Object.keys(characters), source: "yours" });
+    const fixtures = Object.fromEntries(Object.entries(config.fixtures ?? {}).map(([fixture, made]) => {
+        const declared = typeof made === "string" ? { setup: made } : made;
+        return [fixture, declared.inputs ? declared : { ...declared, inputs: [...FIXTURE_INPUTS] }];
+    }));
+    const defaultKind = hosts[defaultHost]?.kind ?? defaultHost;
+    const keepsNoOne = `the default host (${defaultHost}) keeps no person's state between starts, so each start makes new people`;
+    const keepsPeople = config.keepBetweenStarts === false ? undefined
+        : defaultKind === "truapi-cli" ? { people: "each person and their wallet, with their app's storage on the truAPI CLI host" }
+            : { peopleNot: cliLocal ? `${keepsNoOne}: make the truAPI CLI host the default (defaultHost: "truapi-cli") to keep them` : `${keepsNoOne}; no host a product can run keeps them yet (${cliKeeps})` };
+    const fixtureEnvironments = [...new Set(Object.values(fixtures).map((fixture) => fixture.environment ?? defaultEnvironment ?? "fast"))];
+    const keepsNoPeople = defaultKind === "truapi-cli" ? undefined : cliLocal ? `${keepsNoOne}: make the truAPI CLI host the default (defaultHost: "truapi-cli") to save them` : `${keepsNoOne}; no host a product can run keeps them yet (${cliKeeps})`;
+    if (config.fixtures)
+        say({
+            key: "fixtures", label: "Fixtures", value: fixtures, source: "yours",
+            why: `a fixture without inputs is rebuilt when ${FIXTURE_INPUTS.join(", ")} change${keepsNoPeople ? `; a fixture whose setup makes people cannot be saved here: ${keepsNoPeople}` : ""}`,
+            ...(keepsNoPeople ? { limits: { environments: fixtureEnvironments, limit: `fixtures whose setup makes people cannot be saved: ${keepsNoPeople}; a fixture whose setup makes no people can` } } : {}),
+        });
+    const copies = Object.keys(environments).filter((id) => id === "paseo-copy" || id === "previewnet-copy");
+    const rootCalls = config.rootCalls?.length && copies.length
+        ? Object.fromEntries(copies.map((id) => [id, { key: COPY_SUDO_SECRET, allow: [...config.rootCalls], signing: { people: LOCAL_PEOPLE_SIGNING } }]))
+        : undefined;
+    if (rootCalls)
+        secrets[COPY_SUDO_SECRET] = devAccount("//Alice");
+    if (config.rootCalls)
+        say({ key: "rootCalls", label: "Root calls", value: { allow: config.rootCalls, on: copies }, source: "yours", why: copies.length ? "on local copies only, with the copy's sudo key; each run is confirmed (--root-calls)" : "no local copy is offered, so no root call is allowed" });
+    const declaredRange = portsRange(config.ports);
+    const fixedPorts = parseLabPorts(context.env?.[LAB_PORTS_VARIABLE]) ?? declaredRange;
+    const workers = {
+        max: WORKERS_MAX,
+        env: ({ index, count }) => {
+            const slice = fixedPorts ? portSlice(fixedPorts, index, count) : undefined;
+            return { [OUTPUT_VARIABLE]: join(output, "workers", String(index)), ...(slice ? { [LAB_PORTS_VARIABLE]: `${slice.from}-${slice.to}` } : {}), ...workerCache(machine, index) };
+        },
+    };
+    say({ key: "workers", label: "Workers", value: { max: WORKERS_MAX }, source: "default", why: fixedPorts ? "each worker its own output folder and a slice of the lab's ports" : "each worker its own output folder and its own claimed ports" });
+    if (config.checks)
+        say({ key: "checks", label: "Checks after each step", value: config.checks, source: "yours", ...(config.checks.accessibility?.ignore?.length ? { why: "accessibility.ignore: those rules still run, their findings are kept but never fail a step" } : {}) });
+    say(config.modes
+        ? { key: "modes", label: "Modes", value: config.modes, source: "yours" }
+        : { key: "modes", label: "Modes", value: false, source: "default", why: "none: the window offers everything", change: 'modes: { ci: { environment: "fast", tags: "@smoke" } }' });
+    for (const [secret, entry] of Object.entries(config.secrets ?? {}))
+        secrets[secret] = entry;
+    if (config.secrets) {
+        const listed = Object.entries(config.secrets).map(([name, entry]) => ({ name, set: secretSet(entry, context.env ?? {}) }));
+        say({ key: "secrets", label: "Secrets", value: listed, source: "yours", set: listed.every((item) => item.set) });
+    }
+    const runtimeIds = [...new Set(["people", ...chains])].filter((chain) => `runtime:${chain}` in VERSION_SOURCES).map((chain) => `runtime:${chain}`);
+    const hostIds = Object.keys(hosts).filter((host) => host !== "dotli").map((host) => `host:${host}`);
+    const { versions, lock } = productVersions({ root, runtimes: runtimeIds, hosts: hostIds, ...(config.versions ? { choice: config.versions } : {}), sources: VERSION_SOURCES, npm: VERSION_NPM });
+    say({
+        key: "versions", label: "Versions", value: { runtime: config.versions?.runtime ?? "locked", hosts: config.versions?.hosts ?? "locked" }, source: config.versions ? "yours" : "default",
+        why: `${lock.problem ?? `lab.lock.json pins ${lock.pins.join(", ")}`}; runtimes ${runtimeIds.join(", ") || "none"} and hosts ${hostIds.join(", ") || "none"}; locked is lab.lock.json's (product-lab versions update), latest the newest release`,
+        change: 'versions: { runtime: "latest", hosts: "locked" }', options: ["locked", "latest"],
+    });
+    say({
+        key: "keepBetweenStarts", label: "Keep chain and people between starts", value: config.keepBetweenStarts ?? true, source: config.keepBetweenStarts === undefined ? "default" : "yours",
+        why: config.keepBetweenStarts === false ? "off: every start runs clean unless a start asks to keep (--keep)" : "the lab window keeps the chain as you left it; runs (product-lab test, CI) start clean unless asked (--keep)",
+        change: "keepBetweenStarts: false", options: ["true", "false"],
+    });
+    const fixtureSource = join(sharedFixtures(context.env ?? {}), slug(name));
+    say({ key: "fixtureSources", label: "Shared fixtures", value: fixtureSource, source: "default", why: "the machine's shared fixtures folder, under the lab's name" });
+    const chopsticksUsed = !!environments.chopsticks || Object.values(config.advanced?.environments ?? {}).some(chopsticksTopologyEntry);
+    const translated = {
+        name,
+        environments,
+        environmentAdapters: {
+            relayless: { directory: join(output, "environments") },
+            ...(chopsticksUsed || machine.chopsticksBin
+                ? { chopsticks: { ...(chopsticksUsed ? { db: join(output, "environments", "chopsticks") } : {}), ...(machine.chopsticksBin ? { bin: machine.chopsticksBin } : {}) } }
+                : {}),
+        },
+        ...(defaultEnvironment ? { defaultEnvironment } : {}),
+        hostAdapters,
+        hosts,
+        defaultHost,
+        ...(keepsPeople ? { keepBetweenStarts: keepsPeople } : {}),
+        apps: { [appId]: app, ...companions },
+        ...(config.devices ? { devices: [...config.devices] } : {}),
+        ...(integrations.length ? { integrations } : {}),
+        ...(Object.keys(secrets).length ? { secrets } : {}),
+        ...(Object.keys(actors).length ? { actors } : {}),
+        features,
+        ...(config.characters ? { characters } : {}),
+        ...(config.fixtures ? { fixtures } : {}),
+        ...(config.checks ? { checks: checksOf(config.checks) } : {}),
+        ...(config.modes ? { modes: config.modes } : {}),
+        ...(config.app.navigation ? { navigation: config.app.navigation } : {}),
+        ...(declaredRange ? { ports: declaredRange } : {}),
+        fixtureSources: { shared: { kind: "directory", path: fixtureSource } },
+        ...(rootCalls ? { rootCalls } : {}),
+        workers,
+        keys: new Sr25519KeyDerivation(),
+        versions,
+    };
+    for (const entry of machineEntries(machine, launch === "deployed" && machine.liveAccounts ? { liveAccountsUnused: "the deployed launch's product is the deployed build, whose accounts are the host's own" } : {}))
+        say(entry);
+    say({
+        key: "ports", label: "Ports", value: config.ports ? (declaredRange ?? `${config.ports.size} ports`) : "claimed", source: config.ports ? "yours" : "default",
+        why: !config.ports ? "the lab claims free ports on this machine (PRODUCT_LAB_PORTS gives it a range)" : declaredRange ? "the lab's ports, named" : "the lab window's port, then its sessions': a block claimed that size, or the top of PRODUCT_LAB_PORTS",
+        change: "ports: { from: 38000, to: 38999 } (or { size: 500 })",
+    });
+    for (const [field, value] of Object.entries(config.advanced ?? {})) {
+        const base = translated[field];
+        translated[field] = isRecord(base) && isRecord(value) && !FIELD_REPLACED.has(field)
+            ? { ...base, ...(FIELD_MERGED.has(field) ? Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, isRecord(base[key]) && isRecord(entry) ? { ...base[key], ...entry } : entry])) : value) }
+            : value;
+        say({ key: `advanced.${field}`, label: `Advanced: ${field}`, value: isRecord(value) ? Object.keys(value).map((key) => (ADAPTER_FIELDS.has(field) ? (ADAPTER_LABELS[key] ?? key) : key)) : Array.isArray(value) ? `${value.length} item(s)` : typeof value === "function" ? "a function" : value, source: "advanced", why: config.advancedWhy?.[field] ?? "a definition field the product config does not cover yet" });
+    }
+    const text = context.path ? readConfigText(context.path) : undefined;
+    const placed = text === undefined ? entries : entries.map((entry) => {
+        const line = entry.source === "yours" ? lineOfKey(text, entry.key) : undefined;
+        return line === undefined ? entry : { ...entry, at: `${basename(context.path)}:${line}` };
+    });
+    const warnings = Object.keys(config.advancedWhy ?? {}).filter((field) => !(field in (config.advanced ?? {}))).map((field) => `advancedWhy.${field} explains a field advanced does not set (${Object.keys(config.advanced ?? {}).join(", ") || "advanced is empty"})`);
+    const definition = { ...translated, resolvedConfig: { shape: "product", entries: placed, ...(warnings.length ? { warnings } : {}) } };
+    return definition;
+}
+function portsRange(ports) {
+    if (!ports)
+        return undefined;
+    const { size, from, to } = ports;
+    if (size !== undefined && (from !== undefined || to !== undefined))
+        throw new Error("ports names a range ({ from, to }) or a size ({ size }), not both");
+    if (size === undefined)
+        return { from: from, to: to };
+    if (typeof size !== "number" || !Number.isInteger(size) || size < 1 || size > MAX_PORTS_SIZE)
+        throw new Error(`ports.size must be a whole number of ports from 1 to ${MAX_PORTS_SIZE}, not ${JSON.stringify(size)}`);
+    return undefined;
+}
+const MAX_PORTS_SIZE = 10_000;
+function attachRefused(id, base) {
+    return {
+        label: `${id} (refused while ${MACHINE_VARIABLES.forkAttach} is set)`,
+        description: `${MACHINE_VARIABLES.forkAttach}=${base} attaches paseo-copy only`,
+        offer: { chains: ["people", "asset-hub", "bulletin"], local: true },
+        start: async () => {
+            throw new Error(`${id} is refused while ${MACHINE_VARIABLES.forkAttach} is set (${base}): it attaches a running Paseo fork to paseo-copy only, and the lab does not guess which fork ${id} would be. Unset ${MACHINE_VARIABLES.forkAttach} to start ${id}'s own saved copy`);
+        },
+    };
+}
+const LAUNCHES = ["dev", "deployed-local", "deployed"];
+const LAUNCH_WORDS = {
+    dev: "the app's dev server, behind the lab's proxy",
+    "deployed-local": "the app built, deployed to the environment's Bulletin and DotNS, and served through the local gateway",
+    deployed: "the deployed build app.deployed names, read from Bulletin through its DotNS name",
+};
+function appLaunch(app) {
+    if (app.launch !== undefined && !LAUNCHES.includes(app.launch))
+        throw new Error(`app.launch is "${String(app.launch)}": the lab launches ${LAUNCHES.join(", ")}`);
+    const launch = app.launch ?? (app.deployed ? "deployed" : "dev");
+    if (launch === "deployed" && !app.deployed)
+        throw new Error('app.launch is "deployed", and app.deployed names no build: add app: { deployed: { name: "<name>.dot" } }');
+    if (launch !== "deployed" && app.deployed)
+        throw new Error(`app.launch is "${launch}", and app.deployed is set, which is the deployed launch: drop one of them`);
+    return launch;
+}
+function launchRequirements(app, launch) {
+    const written = [...new Set(app.chains)];
+    const extra = launch === "deployed-local" ? deployedLocalRequirements : launch === "deployed" ? { chains: ["asset-hub", "bulletin"] } : undefined;
+    if (!extra)
+        return { chains: written, requires: app.requires, added: [] };
+    const merged = mergeRequirements({ chains: written, ...(app.requires ?? {}) }, extra);
+    const { chains, services, capabilities } = merged;
+    const requires = { ...(app.requires ?? {}), ...(services.length ? { services } : {}), ...(capabilities.length ? { capabilities } : {}) };
+    const added = [...chains.filter((chain) => !written.includes(chain)), ...capabilities.filter((capability) => !(app.requires?.capabilities ?? []).includes(capability))];
+    return { chains, requires: Object.keys(requires).length ? requires : undefined, added };
+}
+const RELAYLESS_PORT_OFFSETS = Object.fromEntries(Object.entries(DEFAULT_RELAYLESS_PORTS).map(([key, port]) => [key, port - 12_000]));
+function watchedSource(root, cwd) {
+    const found = ["src", "index.html", "public"].map((name) => join(cwd, name)).filter((path) => existsSync(join(root, path)));
+    return found.length ? found : [cwd];
+}
+function secretSet(entry, env) {
+    return (isSecretSource(entry) ? [entry] : Object.values(entry)).every((source) => source.read(env) !== undefined);
+}
+function readConfigText(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+export function lineOfKey(text, key) {
+    let at = 0;
+    for (const part of key.split(".")) {
+        const escaped = part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const found = new RegExp(`(^|[\\s{,])(["']?)${escaped}\\2\\s*:`, "m").exec(text.slice(at));
+        if (!found)
+            return undefined;
+        at += found.index + found[0].length;
+    }
+    return text.slice(0, at).split("\n").length;
+}
+const STATEMENT_STORE = ["statementStore", "statement-store"];
+export const VERSION_SOURCES = {
+    "runtime:people": { repository: "paritytech/individuality-community", tag: "v{version}", assets: { file: "next_people_paseo_runtime.compact.compressed.wasm" } },
+    "runtime:asset-hub": { repository: "paritytech/individuality-community", tag: "v{version}", assets: { file: "next_asset_hub_paseo_runtime.compact.compressed.wasm" } },
+    "runtime:bulletin": { repository: "paritytech/polkadot-bulletin-chain", tag: "{version}", assets: { file: "bulletin_paseo_runtime.compact.compressed.wasm" } },
+    "host:truapi-cli": {
+        repository: "paritytech/host-rust-core",
+        tag: "@parity/truapi@{version}",
+        assets: {
+            "archive:aarch64-apple-darwin": "truapi-host-{version}-aarch64-apple-darwin.tar.gz",
+            "archive:x86_64-unknown-linux-musl": "truapi-host-{version}-x86_64-unknown-linux-musl.tar.gz",
+            "archive:aarch64-unknown-linux-musl": "truapi-host-{version}-aarch64-unknown-linux-musl.tar.gz",
+        },
+    },
+};
+export const VERSION_NPM = { "host:truapi-wasm": { package: "@parity/truapi-host" } };
+export const OUTPUT_VARIABLE = "PRODUCT_LAB_OUTPUT_DIR";
+const FIELD_MERGED = new Set(["apps", "hosts", "environmentAdapters", "hostAdapters"]);
+const FIELD_REPLACED = new Set(["keepBetweenStarts"]);
+const ADAPTER_FIELDS = new Set(["environmentAdapters", "hostAdapters"]);
+function chopsticksTopologyEntry(entry) {
+    return isTopology(entry) && entry.provider === "chopsticks";
+}
+export const FIXTURE_INPUTS = ["app/src/**", "app/index.html", "lab/**"];
+const COPY_SUDO_SECRET = "copy-sudo";
+const WORKERS_MAX = 4;
+function portSlice(range, index, count) {
+    const size = Math.floor((range.to - range.from + 1) / count);
+    if (size < 10)
+        throw new Error(`The lab's ports ${range.from}-${range.to} are too few for ${count} workers (each needs at least ten)`);
+    return { from: range.from + index * size, to: range.from + (index + 1) * size - 1 };
+}
+const livePeopleLine = (network) => `live: { "${network}": { people: { Ada: "LIVE_${network.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_ADA_MNEMONIC" } } }`;
+const declaredDefaults = (options) => Object.fromEntries(options.map((option) => [option.name, option.default]));
+const hostChange = (host, options, off = false) => ({
+    change: off ? `hosts: { "${host}": {} }` : `hosts: { "${host}": { ${options[0] ? `${options[0].name}: ${JSON.stringify(options[0].type === "boolean" ? !options[0].default : options[0].default)}` : ""} } } (or false)`,
+    options: [...options.map((option) => option.name), "false"],
+});
+const isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+const slug = (text) => text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "lab";
+function sharedFixtures(env) {
+    return env.PRODUCT_LAB_SHARED_FIXTURES || join(productLabCacheDir({ PRODUCT_LAB_CACHE_DIR: env.PRODUCT_LAB_CACHE_DIR, XDG_CACHE_HOME: env.XDG_CACHE_HOME }), "shared-fixtures");
+}
+function liveVariable(config, deployer) {
+    for (const live of Object.values(config.live ?? {})) {
+        const { people = {}, deployContractsAs } = live;
+        if (deployContractsAs && walletSecret(deployContractsAs) === deployer.secret)
+            return people[deployContractsAs];
+    }
+    throw new Error(`No variable holds ${deployer.secret}`);
+}
+function chopsticksFrom(config) {
+    const network = config.from === "previewnet" ? "previewnet" : "paseo-next-v2";
+    const endpoints = network === "paseo-next-v2" ? LIVE_NETWORK_PRESETS["next-v2"].endpoints ?? {} : {};
+    const state = typeof config.at === "number" ? { state: { fork: { block: config.at } } } : {};
+    return { network, ...state, chopsticks: { upstream: Object.fromEntries(config.chains.filter((chain) => endpoints[chain]).map((chain) => [chain, endpoints[chain]])) } };
+}
+function checksOf(checks) {
+    return {
+        ...(checks.visual ? { visual: { ...(checks.visual.mask ? { mask: [...checks.visual.mask] } : {}), ...(checks.visual.waitFor ? { settled: [checks.visual.waitFor] } : {}) } } : {}),
+        ...(checks.accessibility ? { accessibility: { ...(checks.accessibility.ignore?.length ? { ignore: [...checks.accessibility.ignore] } : {}) } } : {}),
+    };
+}

package/composition/src/default-session-browser.d.ts

@@ -0,0 +1,7 @@
+import { type HostNetworkRoutes } from "@parity/product-lab/domain";
+import type { BrowserLaunchOptions } from "@parity/product-lab/ports/browser";
+import { type SessionHostsOptions } from "./session-hosts.js";
+/** Whether a declared host, or one of its aliases, denies by default (its adapter's `denyByDefaultNetwork`). */
+export declare function deniesByDefault(options: Omit<SessionHostsOptions, "progress">): boolean;
+/** The launch options' backstop for `routes` when a host denies by default; nothing otherwise. */
+export declare function resolverBackstop(denies: boolean, routes: HostNetworkRoutes): Pick<BrowserLaunchOptions, "args">;