@rehearsal-labs/retest 0.2.0 → 0.3.0

package/dist/shared/process-ownership.d.ts

@@ -21,26 +21,76 @@ export type ProcessOwnershipSystem = {
     readAsync?(deadline?: Deadline): Promise<readonly OwnedProcessIdentity[]>;
     /** The same immediate pre-signal reading without holding the event loop. */
     readProcessAsync?(pid: number, deadline?: Deadline): Promise<OwnedProcessIdentity | undefined>;
-    signal(pid: number, signal: NodeJS.Signals | 0): void;
+    /** `expected` is the fresh reading the signal follows, for a host that checks it again as it signals. */
+    signal(pid: number, signal: NodeJS.Signals | 0, expected?: OwnedProcessIdentity): void;
+    /**
+     * Set where `read` lists one job's processes and nothing else, as on Windows: the job the launch `root` was put in,
+     * which holds every process it and its descendants started. There, a member is owned by being in the job, and the
+     * group is ended by ending the job.
+     */
+    job?: OwnedJob;
+};
+/**
+ * A launch's job: the pid it was made for, and its end, which ends every process in it at once. A job holds only
+ * processes born of the launch, so ending it ends nothing else, and nothing in it is left out.
+ */
+export type OwnedJob = {
+    readonly root: number;
+    /**
+     * The launch as it was read when it was put in the job, alive. A process gone from the job is gone from its list at
+     * once, where Unix still shows it until it is reaped, so a launch that ended before the first reading is recorded
+     * from this.
+     */
+    readonly launched?: OwnedProcessIdentity;
+    end(deadline?: Deadline): void;
+    endAsync(deadline?: Deadline): Promise<void>;
+    /** Sends Ctrl+C to the console the job's processes are on, which is how a console program is asked to stop. */
+    interrupt(deadline?: Deadline): void;
+    /** What the job's end could not confirm, once the job was read empty: processes still running outside every job. */
+    unconfirmed(): readonly string[];
 };
 /** Signal failures stay failures; identity refusals can be reconciled only by a later proof of absence. */
 export type ProcessSignalReport = {
     readonly problems: readonly string[];
     readonly identityRefusals: readonly string[];
 };
+/** What one reading of whether a group remains said: the processes of the group it found running, or why it failed. */
+export type LivenessReading = {
+    readonly running: readonly OwnedProcessIdentity[];
+} | {
+    readonly problem: string;
+};
 /**
  * Records a launched process and the descendants observed beneath a still-verified owned process. Group membership
  * alone never establishes ownership. Signals are sent to recorded, freshly verified pids, never to a numeric group.
+ * A launch held in a job of its own, as on Windows, is the exception the job makes possible: the job holds nothing but
+ * what the launch started, so its members are owned by being there, and it is ended whole.
  */
 export declare class OwnedProcessGroup {
     #private;
     constructor(pid: number, parentPid?: number, system?: ProcessOwnershipSystem);
     /** The first successful host reading found no launched pid. A failed reading never sets this fact. */
     get initialProcessAbsent(): boolean;
-    /** Failed metadata readings remain visible even when a later reading proves the launch ended. */
+    /**
+     * Failed metadata readings remain visible even when a later reading proves the launch ended, as does, for a launch
+     * held in a job, anything its job's end could not confirm.
+     */
     get readProblems(): readonly string[];
     /** Whether the launch has been read once, whatever the reading found or however it failed. */
     get captured(): boolean;
+    /** Whether this group is a launch held in a job of its own, which ends it whole rather than one signal at a time. */
+    get heldByJob(): boolean;
+    /**
+     * The processes of the group on record, recorded or not traced to the launch, as the newest reading that succeeded
+     * left them. A reading that failed changes nothing here, so this is no proof that they still run. Empty once a reading
+     * found the group gone.
+     */
+    get stillThere(): readonly OwnedProcessIdentity[];
+    /**
+     * What the newest reading of whether the group remains said: the processes of the group it found still running, or
+     * the problem it failed with. Undefined before the first.
+     */
+    get lastLook(): LivenessReading | undefined;
     /** Records descendants only while their chain reaches an already verified process this owner launched. */
     capture(deadline?: Deadline): string[];
     /**

package/dist/shared/process-ownership.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"process-ownership.d.ts","sourceRoot":"","sources":["../../src/shared/process-ownership.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"process-ownership.d.ts","sourceRoot":"","sources":["../../src/shared/process-ownership.ts"],"names":[],"mappings":"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"}

package/dist/shared/process-ownership.js

@@ -11,6 +11,8 @@ const host = {
 /**
  * Records a launched process and the descendants observed beneath a still-verified owned process. Group membership
  * alone never establishes ownership. Signals are sent to recorded, freshly verified pids, never to a numeric group.
+ * A launch held in a job of its own, as on Windows, is the exception the job makes possible: the job holds nothing but
+ * what the launch started, so its members are owned by being there, and it is ended whole.
  */
 export class OwnedProcessGroup {
     #pid;
@@ -19,6 +21,7 @@ export class OwnedProcessGroup {
     #records = new Map();
     #unowned = new Map();
     #readProblems = new Set();
+    #lastLook;
     #initialized = false;
     #retired = false;
     #initialProcessAbsent = false;
@@ -43,14 +46,41 @@ export class OwnedProcessGroup {
     get initialProcessAbsent() {
         return this.#initialProcessAbsent;
     }
-    /** Failed metadata readings remain visible even when a later reading proves the launch ended. */
+    /**
+     * Failed metadata readings remain visible even when a later reading proves the launch ended, as does, for a launch
+     * held in a job, anything its job's end could not confirm.
+     */
     get readProblems() {
-        return [...this.#readProblems];
+        return [...this.#readProblems, ...(this.#ownJob()?.unconfirmed() ?? [])];
     }
     /** Whether the launch has been read once, whatever the reading found or however it failed. */
     get captured() {
         return this.#initialized;
     }
+    /** Whether this group is a launch held in a job of its own, which ends it whole rather than one signal at a time. */
+    get heldByJob() {
+        return this.#ownJob() !== undefined;
+    }
+    /**
+     * The processes of the group on record, recorded or not traced to the launch, as the newest reading that succeeded
+     * left them. A reading that failed changes nothing here, so this is no proof that they still run. Empty once a reading
+     * found the group gone.
+     */
+    get stillThere() {
+        return [...this.#records.values(), ...this.#unowned.values()];
+    }
+    /**
+     * What the newest reading of whether the group remains said: the processes of the group it found still running, or
+     * the problem it failed with. Undefined before the first.
+     */
+    get lastLook() {
+        return this.#lastLook;
+    }
+    // The job of this very launch; a descendant handed off by `groupFor` shares the system but is not its job's root.
+    #ownJob() {
+        const { job } = this.#system;
+        return job?.root === this.#pid ? job : undefined;
+    }
     #failedRead(error) {
         const problem = `Could not read ownership of process ${this.#pid}: ${errorMessage(error)}`;
         this.#readProblems.add(problem);
@@ -104,7 +134,7 @@ export class OwnedProcessGroup {
         this.#newest = Math.max(this.#newest, sequence);
         const initial = !this.#initialized;
         this.#initialized = true;
-        const root = processes.find((entry) => entry.pid === this.#pid);
+        const root = processes.find((entry) => entry.pid === this.#pid) ?? (initial ? this.#ownJob()?.launched : undefined);
         if (initial) {
             if (root === undefined) {
                 this.#initialProcessAbsent = true;
@@ -115,6 +145,12 @@ export class OwnedProcessGroup {
             this.#records.set(root.pid, root);
             this.#launchIdentity = root;
         }
+        // A job lists only processes born of its launch, even one whose parent is gone, so its members need no ancestry.
+        if (this.#ownJob() !== undefined) {
+            for (const entry of processes)
+                if (running(entry) && entry.groupId === this.#pid && !this.#records.has(entry.pid))
+                    this.#records.set(entry.pid, entry);
+        }
         for (const entry of processes) {
             const record = this.#records.get(entry.pid);
             // A process recorded while its command could not be read keeps the first readable one, so a later change is seen.
@@ -217,6 +253,11 @@ export class OwnedProcessGroup {
     signalReport(signal, deadline) {
         if (this.#retired)
             return { problems: [], identityRefusals: [] };
+        const job = this.#ownJob();
+        if (job !== undefined && endsProcess(signal))
+            return this.#endJob(job, deadline);
+        if (job !== undefined && signal === 'SIGINT')
+            return this.#interruptJob(job, deadline);
         let processes;
         try {
             checkDeadline(deadline);
@@ -252,6 +293,11 @@ export class OwnedProcessGroup {
     async signalReportAsync(signal, deadline) {
         if (this.#retired)
             return { problems: [], identityRefusals: [] };
+        const job = this.#ownJob();
+        if (job !== undefined && endsProcess(signal))
+            return this.#endJobAsync(job, deadline);
+        if (job !== undefined && signal === 'SIGINT')
+            return this.#interruptJob(job, deadline);
         const asked = this.#sequence;
         let read;
         try {
@@ -285,6 +331,41 @@ export class OwnedProcessGroup {
         }
         return { problems, identityRefusals };
     }
+    // Windows has no SIGINT to send; a console program is asked to stop by Ctrl+C on its console, which reaches every
+    // process on it at once, so it is sent once for the launch. It is only asked: one that cannot be asked, as one with no
+    // console left, is ended when its grace runs out, as one that ignores Ctrl+C is, and that end is what cleanup reports.
+    #interruptJob(job, deadline) {
+        try {
+            checkDeadline(deadline);
+            job.interrupt(deadline);
+        }
+        catch {
+            // As above: the end that follows is the outcome.
+        }
+        return { problems: [], identityRefusals: [] };
+    }
+    // A job is ended whole, without a reading first: it holds only what the launch started, so nothing else can be in it,
+    // and a helper born a moment ago is in it too. Whether it is then gone is for `remains` to read.
+    #endJob(job, deadline) {
+        try {
+            checkDeadline(deadline);
+            job.end(deadline);
+        }
+        catch (error) {
+            return { problems: [endProblem(this.#pid, error)], identityRefusals: [] };
+        }
+        return { problems: [], identityRefusals: [] };
+    }
+    async #endJobAsync(job, deadline) {
+        try {
+            checkDeadline(deadline);
+            await job.endAsync(deadline);
+        }
+        catch (error) {
+            return { problems: [endProblem(this.#pid, error)], identityRefusals: [] };
+        }
+        return { problems: [], identityRefusals: [] };
+    }
     #signalCurrent(record, current, signal, problems, identityRefusals, deadline) {
         // Another awaited cleanup may already have confirmed this record gone. It must not be restored by a late reply.
         if (this.#retired || !sameProcess(this.#records.get(record.pid), record))
@@ -310,7 +391,7 @@ export class OwnedProcessGroup {
         }
         try {
             checkDeadline(deadline);
-            this.#system.signal(record.pid, signal);
+            this.#system.signal(record.pid, signal, current);
         }
         catch (error) {
             if (errorCode(error) !== 'ESRCH')
@@ -411,7 +492,7 @@ export class OwnedProcessGroup {
             checkDeadline(deadline);
         }
         catch (error) {
-            this.#failedRead(error);
+            this.#lastLook = { problem: this.#failedRead(error) };
             return true;
         }
         return this.#remainsFrom(processes, this.#next());
@@ -432,7 +513,7 @@ export class OwnedProcessGroup {
             checkDeadline(deadline);
         }
         catch (error) {
-            this.#failedRead(error);
+            this.#lastLook = { problem: this.#failedRead(error) };
             return true;
         }
         if (this.#retired || read === undefined)
@@ -443,8 +524,12 @@ export class OwnedProcessGroup {
         this.#newest = Math.max(this.#newest, sequence);
         // A failed first reading never grants signal authority, and an empty ledger is no proof that the launched
         // child ended. Until its pid and group are absent, that unresolved launch continues to hold its resource.
-        if (this.#launchIdentity === undefined && processes.some((entry) => running(entry) && (entry.pid === this.#pid || entry.groupId === this.#pid)))
-            return true;
+        if (this.#launchIdentity === undefined) {
+            const unresolved = processes.filter((entry) => running(entry) && (entry.pid === this.#pid || entry.groupId === this.#pid));
+            this.#lastLook = { running: unresolved };
+            if (unresolved.length > 0)
+                return true;
+        }
         const root = processes.find((entry) => entry.pid === this.#pid);
         const reusedGroup = root !== undefined && this.#launchIdentity !== undefined && !sameBirth(this.#launchIdentity, root);
         if (!reusedGroup)
@@ -453,9 +538,10 @@ export class OwnedProcessGroup {
                     this.#unowned.set(current.pid, current);
             }
         this.#forgetGone(processes);
-        for (const current of processes)
-            if (running(current) && (sameBirth(this.#records.get(current.pid), current) || sameBirth(this.#unowned.get(current.pid), current)))
-                return true;
+        const left = processes.filter((current) => running(current) && (sameBirth(this.#records.get(current.pid), current) || sameBirth(this.#unowned.get(current.pid), current)));
+        this.#lastLook = { running: left };
+        if (left.length > 0)
+            return true;
         this.#retired = true;
         this.#records.clear();
         this.#unowned.clear();
@@ -471,6 +557,13 @@ export class OwnedProcessGroup {
 export function unverifiedMembersProblem(groupId) {
     return `Process group ${groupId} contains processes whose launch ownership could not be verified; they were left alone.`;
 }
+// The signals a job's end stands for. Windows has no gentler end than its job's, so SIGTERM ends a job as SIGKILL does.
+function endsProcess(signal) {
+    return signal === 'SIGKILL' || signal === 'SIGTERM';
+}
+function endProblem(pid, error) {
+    return `Could not end the job holding process ${pid} and what it started: ${errorMessage(error)}`;
+}
 function sameProcess(record, current) {
     return record !== undefined && sameProcessIdentity(record, current);
 }

package/dist/shared/process-supervisor.d.ts

@@ -0,0 +1,309 @@
+import type { OwnedJob, ProcessOwnershipSystem } from './process-ownership.ts';
+import type { Deadline } from '../protocol/deadline.ts';
+/** How to run the supervisor: its executable, the arguments before each command, and its whole environment. */
+export type SupervisorProgram = {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly environment: Readonly<Record<string, string>>;
+};
+/**
+ * One process as the supervisor read it, every field from one handle on it. `startedAt` is the 100 ns ticks since 1601
+ * Windows keeps, as digits; `commandLine` what it was started with.
+ */
+export type SupervisedProcess = {
+    readonly pid: number;
+    readonly parentPid: number | undefined;
+    readonly startedAt: string;
+    readonly image: string | undefined;
+    readonly commandLine: string | undefined;
+};
+/** The runner's own job: its name, and the value of the runner's handle that keeps it. */
+export type HeldRunner = {
+    readonly job: string;
+    readonly handle: number;
+};
+/**
+ * A launch held in a job of its own: the job, the runner's handle to it, the launched process, whether it had already
+ * ended, so only what it started is in the job, the processes it had already started before it was held, which the
+ * supervisor held then, those it found already in a job of their own inside the runner's, which the process that
+ * started them holds, any it could not hold, and whether the search for them finished.
+ */
+export type HeldLaunch = {
+    readonly job: string;
+    readonly handle: number;
+    readonly root: SupervisedProcess;
+    readonly ended: boolean;
+    readonly late: readonly SupervisedProcess[];
+    readonly byParent: readonly SupervisedProcess[];
+    readonly unheld: readonly number[];
+    readonly complete: boolean;
+};
+/** The console Ctrl+C went to, by the job's process it was reached through, and every process on that console. */
+export type Interrupted = {
+    readonly console: number;
+    readonly reached: readonly number[];
+};
+/** What `terminate` found under the pid: the recorded process, ended; nothing; or another process. */
+export type TerminateOutcome = 'terminated' | 'absent' | 'different';
+/** One process in a reply, as the supervisor prints it. */
+type Identity = {
+    pid: number;
+    parentPid: number | null;
+    startedAt: string;
+    image: string | null;
+    commandLine: string | null;
+};
+/** The one line the supervisor prints for each command, a refusal included. */
+export type SupervisorReply = {
+    schemaVersion: 1;
+    type: 'held';
+    job: string;
+    runner: number;
+    handle: number;
+} | {
+    schemaVersion: 1;
+    type: 'adopted';
+    job: string;
+    handle: number;
+    root: Identity;
+    ended: boolean;
+    late: Identity[];
+    byParent: Identity[];
+    unheld: number[];
+    complete: boolean;
+} | {
+    schemaVersion: 1;
+    type: 'members';
+    job: string;
+    processes: Identity[];
+} | {
+    schemaVersion: 1;
+    type: 'process';
+    process: Identity | null;
+    inJob: boolean | null;
+} | {
+    schemaVersion: 1;
+    type: 'ended';
+    job: string;
+} | {
+    schemaVersion: 1;
+    type: 'terminated';
+    pid: number;
+    outcome: TerminateOutcome;
+} | {
+    schemaVersion: 1;
+    type: 'released';
+    job: string;
+} | {
+    schemaVersion: 1;
+    type: 'strays';
+    job: string;
+    processes: Identity[];
+} | {
+    schemaVersion: 1;
+    type: 'interrupted';
+    job: string;
+    console: number;
+    reached: number[];
+} | {
+    schemaVersion: 1;
+    type: 'refused';
+    problem: string;
+    detail: string | null;
+};
+type Reply = SupervisorReply;
+/**
+ * The supervisor's answers for one runner, the process that asks. Every job it makes is named after the runner and a
+ * random word chosen here, so the names are new and nobody else's; a name already taken is refused by the supervisor.
+ * A launch's job also carries the launch's pid and a count, so a later launch given the same pid gets a name of its
+ * own. Each method runs the supervisor once; a refusal throws with the supervisor's own sentence, and the Windows call
+ * behind it, when one failed, as the error's cause.
+ *
+ * @example const supervisor = new Supervisor(program); supervisor.hold(); const launch = supervisor.adopt(child.pid)
+ */
+export declare class Supervisor {
+    #private;
+    readonly program: SupervisorProgram;
+    readonly runner: number;
+    constructor(program: SupervisorProgram, runner?: number, word?: string);
+    /** The name of the runner's own job. */
+    get runnerJob(): string;
+    /** The name the next launch with this pid is held under. */
+    launchJob(pid: number): string;
+    /** The jobs of launches the runner holds a handle to, oldest first. */
+    get launchJobs(): readonly string[];
+    /**
+     * The launches the runner holds a handle to, each by its job, the process it was made for, what that held by its
+     * parent when it was held, and the markers it was held with.
+     */
+    get launches(): readonly {
+        readonly job: string;
+        readonly root: SupervisedProcess;
+        readonly byParent: readonly SupervisedProcess[];
+        readonly markers: readonly string[];
+    }[];
+    /** The processes named so far, by pid and start, as they stand now: what a later `forgetEnded` may forget. */
+    get named(): ReadonlySet<string>;
+    /**
+     * Forgets those of `named`, taken before `runnerJob` was read, that this reading of the runner's job no longer holds:
+     * each has ended, and a process given its pid later is another one. A process named after `named` was taken is kept,
+     * whatever the reading says, since the reading may be older than its naming.
+     */
+    forgetEnded(named: ReadonlySet<string>, runnerJob: readonly SupervisedProcess[]): void;
+    /** How many processes are named now, which `forgetEnded` keeps to those still running. */
+    get namedCount(): number;
+    /**
+     * Of these processes, those not named before, each counted as named from now on. One no handle could read, whose
+     * start is 0, is named by its pid alone, and a later reading of the same pid is that process, named already.
+     */
+    firstNamed(processes: readonly SupervisedProcess[]): readonly SupervisedProcess[];
+    /** Puts the runner in its own job, which ends everything in it once the runner ends. */
+    hold(deadline?: Deadline): HeldRunner;
+    /**
+     * Puts a child the runner just started in a job of its own, with whatever it already started. When no answer says it
+     * was held, whatever the job came to hold is ended: a reply lost after the job was made leaves only an empty job,
+     * whose handle goes with the runner.
+     */
+    adopt(pid: number, deadline?: Deadline, markers?: readonly string[]): HeldLaunch;
+    /** The processes a job holds now. */
+    members(job: string, deadline?: Deadline): readonly SupervisedProcess[];
+    membersAsync(job: string, deadline?: Deadline): Promise<readonly SupervisedProcess[]>;
+    /** One process as it is now, or undefined when no process runs under the pid, and whether the job, if named, holds it. */
+    process(pid: number, job?: string, deadline?: Deadline): {
+        readonly process: SupervisedProcess | undefined;
+        readonly inJob: boolean;
+    };
+    processAsync(pid: number, job?: string, deadline?: Deadline): Promise<{
+        readonly process: SupervisedProcess | undefined;
+        readonly inJob: boolean;
+    }>;
+    /** Ends every process a launch's job holds. The supervisor refuses a job that holds the runner. */
+    end(job: string, deadline?: Deadline): void;
+    endAsync(job: string, deadline?: Deadline): Promise<void>;
+    /** Ends one process of a job only while it is the process that started at `startedAt`. */
+    terminate(job: string, pid: number, startedAt: string, deadline?: Deadline): TerminateOutcome;
+    terminateAsync(job: string, pid: number, startedAt: string, deadline?: Deadline): Promise<TerminateOutcome>;
+    /**
+     * The pids every launch but `job`'s holds now, in its job or, as it was held, by its parent, for a claim that rests on
+     * a marker or on a browser read one reading late, which must never take another launch's process; undefined when a
+     * job still held could not be read.
+     */
+    otherLaunchMembers(job: string, deadline?: Deadline): ReadonlySet<number> | undefined;
+    otherLaunchMembersAsync(job: string, deadline?: Deadline): Promise<ReadonlySet<number> | undefined>;
+    /** Closes the runner's handle to a job that holds nothing any more, which frees the job. */
+    release(job: string, handle: number, deadline?: Deadline): void;
+    releaseAsync(job: string, handle: number, deadline?: Deadline): Promise<void>;
+    /**
+     * At the end of a run, each process still running in a job of a launch whose own process has ended, as a helper a test
+     * file left running is, with the launch's pid, leaving out console hosts; and each such launch's job that could not be
+     * read. A job given back meanwhile holds nothing, and one whose answer was lost may be gone too, its processes ended
+     * with its last handle; leaving the unread ones out of `straysAsync` names whatever they still hold there instead.
+     * `only`, when given, names the launches' jobs to read, such as one run's own among several a host holds at once.
+     */
+    leftoversAsync(deadline?: Deadline, only?: ReadonlySet<string>): Promise<{
+        readonly found: readonly {
+            readonly root: number;
+            readonly process: SupervisedProcess;
+        }[];
+        readonly unread: readonly string[];
+    }>;
+    /**
+     * What the runner's job holds that no launch's job does and that nothing still running stands behind: a process left
+     * by one that had ended before its launch was held, which no launch's job took, and which runs until the runner ends.
+     * Console hosts are left out. `leaveOut` names launches' jobs to read as no launch's, so what they hold is named.
+     */
+    strays(deadline?: Deadline): readonly SupervisedProcess[];
+    straysAsync(deadline?: Deadline, leaveOut?: readonly string[]): Promise<readonly SupervisedProcess[]>;
+    /**
+     * Sends Ctrl+C to the console of a launch's processes, or of `pid` among them, unless Retest itself is on that console;
+     * Ctrl+Break with `key: 'break'`, which a console program cannot be set to ignore.
+     */
+    interrupt(job: string, options?: {
+        readonly pid?: number;
+        readonly key?: 'c' | 'break';
+        readonly deadline?: Deadline;
+    }): Interrupted;
+}
+/**
+ * The supervisor's one line of output as a checked reply. Anything else, a second line included, is no answer.
+ *
+ * @example readReply('{"schemaVersion":1,"type":"ended","job":"Local\\\\retest-1-ab-2"}\n').type // 'ended'
+ */
+export declare function readReply(text: string): Reply;
+/**
+ * Whether a process is the console host Windows starts beside a console program given a console of its own, as each test
+ * file's process, app server and media process is. It belongs to the programs on that console, runs nothing anyone gave
+ * it and ends a moment after the last of them, so it is never named as left running: a program still on its console is
+ * named itself.
+ *
+ * @example consoleHost({ pid: 7300, parentPid: 7200, startedAt: '1', image: 'C:\\Windows\\System32\\conhost.exe' }) // true
+ */
+export declare function consoleHost(process: SupervisedProcess): boolean;
+/** Processes by pid and start, as a launch keeps what it has read as its own. */
+export type ProcessRecords = ReadonlyMap<number, string>;
+/**
+ * Whether a command line names `marker` as a folder of its own: between two separators, or after one at the end of a
+ * path, never as part of a longer name. Windows compares names whatever their case.
+ *
+ * @example namesFolder('firefox.exe --profile "C:\\Temp\\retest-firefox-1-a\\profile"', 'retest-firefox-1-a') // true
+ */
+export declare function namesFolder(commandLine: string | undefined, marker: string): boolean;
+/** What a launch of a run has on record, and the markers that name its processes, for the run's end to tie strays by. */
+export type LaunchRecord = {
+    readonly onRecord: () => ProcessRecords;
+    readonly markers: readonly string[];
+};
+/**
+ * Of the processes no launch's job holds and nothing running stands behind, those a run can tie to itself by the facts
+ * a launch's own reading goes by: each one on a launch's record by its pid and start, each one whose parent runs in this
+ * reading on such a record, and each one whose command line names a launch's marker. A record of any age is only ever
+ * its own process, so nothing is tied through a process that has ended.
+ *
+ * @example tiedTo([{ onRecord: () => new Map([[5001, '13437009000005001']]), markers: [] }], strays) // 5001, and what 5001 runs
+ */
+export declare function tiedTo(launches: readonly LaunchRecord[], strays: readonly SupervisedProcess[]): SupervisedProcess[];
+/**
+ * A process left running, as cleanup names it; `when` says when it was seen, such as `after process 5000 ended`.
+ *
+ * @example stillRunningProblem({ pid: 6100, parentPid: 6050, startedAt: '1', image: 'C:\\Apps\\helper.exe' }, 'after process 5000 ended') // 'Process 6100 (helper.exe) is still running after process 5000 ended. Retest ends it when Retest exits.'
+ */
+export declare function stillRunningProblem(process: SupervisedProcess, when: string): string;
+/** What cleanup says when it could not look for processes left running; `when` as for `stillRunningProblem`. */
+export declare function leftoversUnreadProblem(error: unknown, when: string): string;
+/**
+ * The command a process stands under when Windows would not name its executable. It has the shape the ownership rule
+ * reads as a command that cannot be read, so it is never compared as one.
+ */
+export declare const unreadableImage = "(unreadable)";
+/**
+ * A launch's ownership readings on Windows, its job, what it has on record by pid and start (its job's members as its
+ * newest reading of the job found them, and those it holds by their parents as its newest reading of the runner's job
+ * left them), and its markers.
+ */
+export type JobOwnershipSystem = ProcessOwnershipSystem & LaunchRecord & {
+    readonly job: OwnedJob;
+};
+/**
+ * A launch's ownership readings on Windows: its job's own process list, where every member has the launch's pid as its
+ * group, a pid read with whether the job holds it, and the job's end, which ends every member at once. A job that was
+ * read empty holds nothing from then on, since only Retest puts processes in it and only when it is made, so its
+ * handle is given back and every later reading answers empty without asking.
+ *
+ * A process held by its parent, already in a job of its own when the launch was held, as the browser Firefox's Windows
+ * launcher starts is, belongs to the launch as well, with everything it starts while it runs: they are read from the
+ * runner's job as members, by the starts on record, through parents running in the same reading, and by `markers`, the
+ * names in a command line only this launch's processes carry, such as its profile folder.
+ *
+ * An empty job is not yet proof that the launch left nothing. A process whose own parent had ended before the launch
+ * was held cannot be tied to it, and stays in the runner's job only; so once the job is read empty, the runner's job is
+ * read too, and anything there that no launch's job holds and nothing running stands behind leaves the launch's
+ * cleanup unconfirmed, naming it. Each such process is named once in the host, for the first launch it is seen after.
+ *
+ * @example const ownership = new OwnedProcessGroup(child.pid, process.pid, jobSystem(supervisor, supervisor.adopt(child.pid)))
+ */
+export declare function jobSystem(supervisor: Supervisor, launch: HeldLaunch, options?: {
+    readonly markers?: readonly string[];
+    readonly lateParentMs?: number;
+}): JobOwnershipSystem;
+export {};
+//# sourceMappingURL=process-supervisor.d.ts.map

package/dist/shared/process-supervisor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-supervisor.d.ts","sourceRoot":"","sources":["../../src/shared/process-supervisor.ts"],"names":[],"mappings":"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"}