rvlib-shipkit 1.5.0 → 1.7.0

package/src/trace/read-trace.ts

@@ -0,0 +1,485 @@
+// A TRACE, TURNED INTO A READ SET, or into the reason no read set can be
+// trusted. trace/interpose.c writes the lines, one log per process; this reads
+// them after the task exited and decides what its answer depended on.
+//
+// Every rule here fails toward "not kept". A hole in the trace (a child that
+// ran untraced), a socket to a service the task did not start, anything the
+// task looked at that moved while it ran: each one keeps the answer out of
+// the store, with the reason, and the next run measures again.
+//
+// What the read set holds:
+// - a file the task opened: in the repo by content (with its stat as a fast
+//   path), outside it by stat.
+// - a file it only stat'ed, by stat: a tool with an mtime cache (tsc -b,
+//   eslint --cache) decides from that alone whether to read the file at all.
+// - every image it ran or loaded (its executables, their libraries, a
+//   dlopen'd addon), like a file it opened.
+// - every path it probed, present or absent, and every dir it listed.
+// - a local port it found closed, re-checked before a replay.
+// A file the task READ and also wrote (`eslint --fix`, a tsbuildinfo, a
+// sqlite file opened read-write) stays an input, by its content AFTER the run:
+// the answer holds for the state the task left, and any later edit re-runs
+// it. Only its mid-run guard is off, since the task moved it itself.
+//
+// What is NOT an input, by design:
+// - what the task wrote without ever reading it: its pure outputs.
+// - the OS and the tool caches: /System, /usr, /dev, the dyld and timezone
+//   databases, the temp dirs, ~/Library/Caches, ~/.bun/install/cache and
+//   ~/.cache. A verdict that changes with a tool's cache is that tool's bug.
+// - `.git/objects/`: an object never changes under its name, and the refs
+//   and the index that choose among them are recorded like any file.
+// - what the gate itself writes: `.shipkit/tmp/` (its run logs and scratch,
+//   which the suite runner writes and sweeps while it runs), the status
+//   files every gate rewrites at its end, and its store under git's dir (the
+//   ledger db the suite runner records timings in, the scan indexes). A check that reads them reads the
+//   previous gate's output, which moves on every run by construction.
+// - a listing of an ancestor of the repo root: a resolver walks up to `/`,
+//   and a new sibling repo in ~/dev must not re-run anything. What it looked
+//   for up there (a node_modules, a package.json) is kept as an existence
+//   probe, so one appearing still counts.
+//
+// Known limits, the same as for every content key: environment variables,
+// the clock, randomness, UDP sent without a connect, and Mach or XPC
+// services, none of which a file trace can see.
+import { readdirSync, readFileSync, realpathSync, statSync } from 'fs'
+import { homedir, tmpdir } from 'os'
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'path'
+import { dirEntries, entriesHash, kindOf, linkTarget, oidOnDisk, statSig, type PathKind, type ReadSet } from '../core/read-set.ts'
+import { LAYOUT } from '../core/layout.ts'
+import { probeGitRoot } from '../core/git-root.ts'
+import { shipkitRoot } from '../ledger/db.ts'
+
+/** a traced run, read back */
+export type TraceResult = {
+    /** what the answer depended on, null when it cannot be kept */
+    reads: ReadSet | null
+    /** why it cannot be kept, null when it can */
+    why: string | null
+    /** executables that ran untraced, absolute: what tracer.ts may be able
+     *  to make traceable for the next run */
+    blind: string[]
+    /** how many processes wrote a trace, and how many lines */
+    processes: number
+    lines: number
+}
+
+const O_WRONLY = 0x1
+const O_RDWR = 0x2
+const O_APPEND = 0x8
+const O_CREAT = 0x200
+const O_TRUNC = 0x400
+const WRITES = O_WRONLY | O_RDWR | O_APPEND | O_CREAT | O_TRUNC
+/** a failed call that says nothing is there */
+const ABSENT = new Set([2, 20])
+
+const real = (p: string): string => { try { return realpathSync(p) } catch { return p } }
+
+/** path prefixes that are never an input: the OS, and the tool caches */
+export function ignoredPrefixes(): string[] {
+    const home = homedir()
+    const t = real(tmpdir())
+    return [
+        '/System/', '/usr/lib/', '/usr/libexec/', '/usr/share/', '/usr/bin/', '/usr/sbin/', '/bin/', '/sbin/', '/dev/',
+        '/private/var/db/', '/var/db/', '/private/var/run/', '/var/run/', '/Library/Apple/', '/Library/Preferences/Logging/',
+        '/private/var/folders/', '/var/folders/', '/private/tmp/', '/tmp/', `${t}/`,
+        `${home}/Library/Caches/`, `${home}/.bun/install/cache/`, `${home}/.cache/`,
+    ]
+}
+
+/** what the task saw at a path when it probed it: its kind, and for a file
+ *  its size, mtime and inode. `mixed` when two looks disagreed */
+type Seen = { kind: PathKind | '?'; sig: string | null; mixed: boolean }
+
+type Parsed = {
+    /** pid → how many images it started traced, and the parent of the first */
+    started: Map<number, { n: number; ppid: number }>
+    /** pids a traced parent spawned, with what it asked to run */
+    spawned: Map<number, string>
+    /** pid → execs that went through, and the last image it asked for */
+    execs: Map<number, { n: number; exe: string }>
+    images: Set<string>
+    reads: Map<string, { size: number; mtime: string }>
+    seen: Map<string, Seen>
+    /** dir → its mtime when the task listed it (`mixed` when two listings saw
+     *  two), and the wall clock of the first listing, ms */
+    dirs: Map<string, { mtime: string; at: number }>
+    /** dir → every entry name a listing of it returned */
+    names: Map<string, Set<string>>
+    /** symlink → the target the task read, `\0mixed` when two reads disagreed */
+    targets: Map<string, string>
+    /** file → its stat when the task last closed it after writing */
+    closed: Map<string, string>
+    /** an exec whose new image never wrote its start line */
+    unstarted: string[]
+    written: Set<string>
+    /** every connect, with how it ended: a non-blocking one takes the errno of
+     *  the next SO_ERROR read on its fd, in its own process's log order */
+    connects: { family: string; addr: string; port: number; errno: number }[]
+    binds: Set<string>
+    processes: number
+    lines: number
+}
+
+/** `size:mtimeNs:ino` from an S or O line's fields, the form statSig gives */
+const sigOf = (size: string, mtime: string, ino: string): string => {
+    const [sec, nsec] = mtime.split('.')
+    return `${size}:${BigInt(sec!) * 1_000_000_000n + BigInt(nsec ?? '0')}:${ino}`
+}
+
+function parse(dir: string): Parsed {
+    const p: Parsed = { started: new Map(), spawned: new Map(), execs: new Map(), images: new Set(), reads: new Map(), seen: new Map(), dirs: new Map(), names: new Map(), targets: new Map(), closed: new Map(), unstarted: [], written: new Set(), connects: [], binds: new Set(), processes: 0, lines: 0 }
+    const abs = (base: string, path: string): string => resolve(isAbsolute(path) || base === '' ? '/' : base, path)
+    const look = (path: string, kind: PathKind | '?', sig: string | null): void => {
+        const was = p.seen.get(path)
+        if (was == null) { p.seen.set(path, { kind, sig, mixed: false }); return }
+        if (kind !== '?' && was.kind !== '?' && (was.kind !== kind || (sig != null && was.sig != null && sig !== was.sig))) was.mixed = true
+        if (was.kind === '?') was.kind = kind
+        was.sig ??= sig
+    }
+    for (const f of readdirSync(dir)) {
+        if (!f.endsWith('.log')) continue
+        p.processes++
+        // a connect left in progress, by fd: fds are reused, so only the next
+        // answer on that fd in this log belongs to it
+        const pending = new Map<number, number>()
+        // an exec writes its line into its own pid's log, and the image it
+        // becomes writes its start line into the same log, after it
+        let awaiting: string | null = null
+        // a rename logs its two paths as two lines in a row
+        let renamed: string | null = null
+        for (const line of readFileSync(join(dir, f), 'utf8').split('\n')) {
+            if (line === '') continue
+            p.lines++
+            const c = line.split('\t')
+            if (c[0] !== 'W') renamed = null
+            switch (c[0]) {
+                case 'H': {
+                    awaiting = null
+                    const pid = Number(c[1])
+                    const s = p.started.get(pid) ?? { n: 0, ppid: Number(c[2]) }
+                    s.n++
+                    p.started.set(pid, s)
+                    if (c[3] != null && c[3] !== '') p.images.add(c[3])
+                    break
+                }
+                case 'L': if (c[1] != null && c[1] !== '') p.images.add(c[1]); break
+                case 'P': {
+                    const [, op, r, pidText, , path] = c
+                    const pid = Number(pidText)
+                    // a relative target names no file without the spawner's cwd; the
+                    // child's own H and L lines give it absolute, and a child that
+                    // wrote none is refused anyway
+                    if (path != null && isAbsolute(path) && (op !== 'spawn' || r === '0')) p.images.add(path)
+                    if (op === 'exec') { if (awaiting != null) p.unstarted.push(awaiting); awaiting = path ?? '' }
+                    if (op === 'execfail') awaiting = null
+                    if (op === 'spawn' && r === '0') p.spawned.set(pid, path ?? '')
+                    else if (op === 'exec' || op === 'execfail') {
+                        const e = p.execs.get(pid) ?? { n: 0, exe: path ?? '' }
+                        e.n += op === 'exec' ? 1 : -1
+                        if (op === 'exec') e.exe = path ?? e.exe
+                        p.execs.set(pid, e)
+                    }
+                    break
+                }
+                case 'O': {
+                    if (c.length < 7) break
+                    const path = abs(c[3]!, c[4]!)
+                    const flags = Number(c[1])
+                    if ((flags & WRITES) !== 0) p.written.add(path)
+                    // a read-write open reads too
+                    const reads = (flags & WRITES) === 0 || (flags & O_RDWR) !== 0
+                    if (c[2] === 'd') look(path, 'dir', null)
+                    else if (reads && !p.reads.has(path)) p.reads.set(path, { size: Number(c[5]), mtime: c[6]! })
+                    break
+                }
+                case 'S': {
+                    if (c.length < 5) break
+                    const kind = c[2] === 'f' ? 'file' : c[2] === 'd' ? 'dir' : '?'
+                    const at = abs(c[3]!, c[4]!)
+                    look(at, kind, c.length >= 8 ? sigOf(c[5]!, c[6]!, c[7]!) : null)
+                    // an lstat that found a link learned that a link stands
+                    // there: its target is recorded, with nothing to compare
+                    if (c[2] === 'l' && !p.targets.has(at)) p.targets.set(at, '\0lstat')
+                    break
+                }
+                case 'E': if (c.length >= 5) look(abs(c[3]!, c[4]!), ABSENT.has(Number(c[2])) ? null : '?', null); break
+                case 'D': {
+                    if (c[1] == null || c[1] === '') break
+                    const was = p.dirs.get(c[1])
+                    const at = Number(c[3] ?? 0) * 1000
+                    if (was == null) p.dirs.set(c[1], { mtime: c[2] ?? '', at })
+                    else { if (was.mtime !== c[2]) was.mtime = 'mixed'; was.at = Math.min(was.at, at) }
+                    break
+                }
+                case 'W': {
+                    if (c.length < 4) break
+                    const w = abs(c[2]!, c[3]!)
+                    p.written.add(w)
+                    // a file written under one name and renamed into place keeps
+                    // the stat its close left
+                    if (c[1] === 'rename' && renamed != null) {
+                        const was = p.closed.get(norm(renamed))
+                        if (was != null) p.closed.set(norm(w), was)
+                        renamed = null
+                    } else renamed = c[1] === 'rename' ? w : null
+                    break
+                }
+                case 'M': {
+                    if (c[1] == null || c[1] === '') break
+                    const set = p.names.get(c[1]) ?? new Set<string>()
+                    for (const n of (c[2] ?? '').split('\x1f')) if (n !== '') set.add(n)
+                    p.names.set(c[1], set)
+                    break
+                }
+                case 'K': {
+                    if (c.length < 4) break
+                    const at = abs(c[1]!, c[2]!)
+                    const was = p.targets.get(at)
+                    // a real read replaces what an lstat alone learned
+                    p.targets.set(at, was == null || was === '\0lstat' || was === c[3] ? c[3] ?? '' : '\0mixed')
+                    break
+                }
+                case 'C': if (c.length >= 5) p.closed.set(norm(c[1]!), sigOf(c[2]!, c[3]!, c[4]!)); break
+                case 'N': {
+                    const errno = Number(c[5] ?? 0)
+                    p.connects.push({ family: c[1] ?? '', addr: c[2] ?? '', port: Number(c[3] ?? 0), errno })
+                    if (errno === EINPROGRESS) pending.set(Number(c[6] ?? -1), p.connects.length - 1)
+                    break
+                }
+                case 'R': {
+                    const i = pending.get(Number(c[1]))
+                    if (i != null) { p.connects[i]!.errno = Number(c[2] ?? 0); pending.delete(Number(c[1])) }
+                    break
+                }
+                case 'B': p.binds.add(c[1] === 'unix' ? `unix:${c[2]}` : `port:${c[3]}`); break
+            }
+        }
+        if (awaiting != null) p.unstarted.push(awaiting)
+    }
+    return p
+}
+
+/** a path with its dir's links resolved: /var and /private/var name one file,
+ *  and a file the task removed has no path of its own left to resolve */
+const norm = (p: string): string => join(real(dirname(p)), p.slice(dirname(p).length + 1))
+
+/** the images that should have written a start line and did not. A pid owes
+ *  one for a spawn a traced parent made, one per exec, and one more when it
+ *  is a ROOT (started by the untraced gate): the root's own start line must
+ *  not pay for an image it later exec'd into */
+function blindOf(p: Parsed): string[] {
+    const blind: string[] = [...p.unstarted]
+    for (const pid of new Set([...p.started.keys(), ...p.spawned.keys(), ...p.execs.keys()])) {
+        const s = p.started.get(pid)
+        const root = s != null && !p.spawned.has(pid) && !p.started.has(s.ppid)
+        const owed = (p.spawned.has(pid) ? 1 : 0) + (p.execs.get(pid)?.n ?? 0) + (root ? 1 : 0)
+        if ((s?.n ?? 0) < owed) blind.push(p.execs.get(pid)?.exe ?? p.spawned.get(pid) ?? `pid ${pid}`)
+    }
+    return blind
+}
+
+/** repo paths the gate writes itself: never an input of what it runs */
+const GATE_WRITES: string[] = [LAYOUT.tmp, LAYOUT.status, LAYOUT.statusFull, `${LAYOUT.status}.lock`, `${LAYOUT.statusFull}.lock`]
+
+const LOOPBACK = /^(127\.|::1$|::ffff:127\.|0\.0\.0\.0$|::$)/
+const ECONNREFUSED = 61
+const EINPROGRESS = 36
+/** AF_SYSTEM: kernel event sockets the runtime opens for itself */
+const KERNEL = 'family32'
+
+/** the connect that reached outside the task, in words, or null, and the
+ *  local ports it found closed. A local port the task bound itself is inside
+ *  it. A local port nothing listens on is an answer about this machine, so it
+ *  joins the read set and a replay asks again. Any other connect reads a
+ *  service the trace cannot see into.
+ *
+ *  A non-blocking connect ends after the call, and the runtime may learn how
+ *  from its event loop rather than through SO_ERROR, which the trace sees.
+ *  Such a local port is asked again now: nothing listening means the task
+ *  met a refusal too */
+async function networkOf(p: Parsed): Promise<{ world: string | null; closed: string[] }> {
+    const unsure = new Map<number, string>()
+    const closed = new Set<string>()
+    for (const n of p.connects) {
+        if (n.family === KERNEL) continue
+        if (n.family === 'unix') { if (!p.binds.has(`unix:${n.addr}`)) return { world: `it connected to the socket ${n.addr}`, closed: [] }; continue }
+        if (n.family === 'inet' || n.family === 'inet6') {
+            if (LOOPBACK.test(n.addr) && p.binds.has(`port:${n.port}`)) continue
+            if (LOOPBACK.test(n.addr) && n.errno === ECONNREFUSED) { closed.add(String(n.port)); continue }
+            if (LOOPBACK.test(n.addr) && n.errno === EINPROGRESS) { unsure.set(n.port, n.addr); continue }
+            return { world: `it connected to ${n.addr}:${n.port}`, closed: [] }
+        }
+        return { world: `it opened a ${n.family} connection`, closed: [] }
+    }
+    for (const [port, addr] of unsure) {
+        if (await listening(port)) return { world: `it connected to ${addr}:${port}, where a service listens`, closed: [] }
+        closed.add(String(port))
+    }
+    return { world: null, closed: [...closed].sort() }
+}
+
+/** does anything accept on this local port right now? */
+function listening(port: number): Promise<boolean> {
+    return new Promise((done) => {
+        const t = setTimeout(() => done(true), 1_000)
+        Bun.connect({ hostname: '127.0.0.1', port, socket: { open(s) { clearTimeout(t); s.end(); done(true) }, data() {}, connectError() { clearTimeout(t); done(false) } } }).catch(() => { clearTimeout(t); done(false) })
+    })
+}
+
+/** the stat a file had when it was opened still holds, as size and mtime */
+function heldStill(abs: string, at: { size: number; mtime: string }): boolean {
+    const sig = statSig(abs)
+    if (sig === '-') return false
+    const [size, mtimeNs] = sig.split(':')
+    const [sec, nsec] = at.mtime.split('.')
+    return Number(size) === at.size && BigInt(mtimeNs!) === BigInt(sec!) * 1_000_000_000n + BigInt(nsec ?? '0')
+}
+
+/** an entry of `dir` the task did not write that came into being after
+ *  `at` (ms), or null. APFS keeps a birth time per file */
+function bornAfter(dir: string, at: number, written: (abs: string) => boolean): string | null {
+    let names: string[]
+    try { names = readdirSync(dir) } catch { return null }
+    for (const n of names) {
+        const abs = join(dir, n)
+        if (written(abs)) continue
+        try { if (statSync(abs).birthtimeMs > at) return abs } catch { /* gone: nothing was added */ }
+    }
+    return null
+}
+
+/** a dir's mtime as the D lines write it */
+function dirMtime(abs: string): string | null {
+    try {
+        const s = statSync(abs, { bigint: true })
+        return `${s.mtimeNs / 1_000_000_000n}.${String(s.mtimeNs % 1_000_000_000n).padStart(9, '0')}`
+    } catch {
+        return null
+    }
+}
+
+/**
+ * read one trace dir. `root` is the repo; a path under it is recorded
+ * repo-relative and by content, one outside by stat.
+ */
+export async function readTrace(dir: string, root: string): Promise<TraceResult> {
+    const p = parse(dir)
+    const done = (why: string, blind: string[] = []): TraceResult => ({ reads: null, why, blind, processes: p.processes, lines: p.lines })
+    if (p.processes === 0) return done('the trace is empty: the task ran without the tracer')
+
+    const blind = blindOf(p)
+    if (blind.length > 0) {
+        const names = [...new Set(blind)]
+        return done(`\`${names[0]}\` ran untraced${names.length > 1 ? `, and ${names.length - 1} more` : ''}`, names)
+    }
+    const net = await networkOf(p)
+    if (net.world != null) return done(net.world)
+
+    const roots = [...new Set([resolve(root), real(root)])]
+    const inRepo = (abs: string): string | null => {
+        for (const r of roots) {
+            const rel = relative(r, abs)
+            if (rel === '') return '.'
+            if (!rel.startsWith('..') && !isAbsolute(rel)) return rel.split(sep).join('/')
+        }
+        return null
+    }
+    const skip = ignoredPrefixes()
+    const ancestors = new Set<string>()
+    for (const r of roots) for (let d = r; ; d = resolve(d, '..')) { ancestors.add(d); if (d === '/') break }
+    // the gate's own store: the ledger db (shared by every worktree) and this
+    // checkout's scan indexes
+    const gitDir = probeGitRoot(root).root?.gitDir
+    const state = [...new Set([shipkitRoot(root), ...(gitDir == null ? [] : [join(gitDir, 'shipkit')])].flatMap((d) => [resolve(d), real(d)]))].map((d) => `${d}/`)
+    const writtenSet = new Set([...p.written].map(norm))
+    const written = (abs: string): boolean => writtenSet.has(norm(abs))
+    // the dirs the task itself added to or removed from: their mtime moved
+    // for the task's own reasons
+    const touchedDirs = new Set([...p.written].map((w) => dirname(w)))
+    /** the key a path is recorded under, null when it is not an input */
+    const keyOf = (abs: string): string | null => {
+        if (state.some((d) => abs.startsWith(d))) return null
+        const rel = inRepo(abs)
+        if (rel != null) return rel.startsWith('.git/objects/') || GATE_WRITES.some((w) => rel === w || rel.startsWith(`${w}/`)) ? null : rel
+        return skip.some((s) => abs.startsWith(s) || `${abs}/` === s) ? null : abs
+    }
+    const moved = (k: string): TraceResult => done(`${k} changed while it ran`)
+
+    const set: ReadSet = { files: {}, exists: {}, lists: {}, dirs: {}, sigs: {}, targets: {} }
+    /** a file by stat, and by content in the repo */
+    const byFile = (abs: string, k: string): void => {
+        set.sigs![k] = statSig(abs)
+        if (!isAbsolute(k)) set.files[k] = oidOnDisk(abs)
+    }
+    for (const [abs, at] of p.reads) {
+        const k = keyOf(abs)
+        if (k == null) continue
+        // a file another process changed while this task read it: the answer
+        // describes content that is gone, and nothing on disk says which
+        if (!written(abs) && !heldStill(abs, at)) return moved(k)
+        // one the task rewrote must still be what its last close left
+        const left = p.closed.get(norm(abs))
+        if (written(abs) && left != null && left !== statSig(abs)) return moved(k)
+        byFile(abs, k)
+    }
+    for (const abs of p.images) {
+        const k = keyOf(abs)
+        if (k != null && !(k in set.sigs!)) byFile(abs, k)
+    }
+    for (const [abs, seen] of p.seen) {
+        const k = keyOf(abs)
+        if (k == null || k in set.sigs!) continue
+        const now = kindOf(abs)
+        if (!written(abs)) {
+            // what the task saw then, against what stands there now: a file
+            // appearing after the task looked for it, or edited after it was
+            // stat'ed, changed the answer under it
+            if (seen.mixed) return moved(k)
+            if ((seen.kind === 'file' || seen.kind === 'dir' || seen.kind === null) && seen.kind !== now) return moved(k)
+            if (seen.sig != null && seen.sig !== statSig(abs)) return moved(k)
+        }
+        if (now === 'file' && seen.sig != null) set.sigs![k] = statSig(abs)
+        else set.exists[k] = now
+    }
+    for (const [abs, { mtime, at }] of p.dirs) {
+        if (ancestors.has(abs)) continue
+        const k = keyOf(abs)
+        if (k == null) continue
+        // an entry another process added, removed or renamed while the task
+        // listed the dir: a test file created mid-run that the runner never
+        // saw. The names the listing returned, against the names there now,
+        // the ones the task wrote itself set aside
+        const names = p.names.get(abs)
+        if (names != null) {
+            let now: string[] = []
+            try { now = readdirSync(abs) } catch { now = [] }
+            const others = (n: string): boolean => !written(join(abs, n))
+            if (now.some((n) => others(n) && !names.has(n)) || [...names].some((n) => others(n) && !now.includes(n))) return moved(`${k}/`)
+        } else {
+            // a listing with no names (getattrlistbulk): its mtime, and in a dir
+            // the task wrote into, no entry born after the listing
+            if (!touchedDirs.has(abs) && (mtime === 'mixed' || mtime !== dirMtime(abs))) return moved(`${k}/`)
+            if (touchedDirs.has(abs) && bornAfter(abs, at, written) != null) return moved(`${k}/`)
+        }
+        set.dirs![k] = entriesHash(dirEntries(abs))
+    }
+    for (const [abs, target] of p.targets) {
+        const k = keyOf(abs)
+        if (k == null) continue
+        const now = linkTarget(abs)
+        if (!written(abs) && target !== '\0lstat' && (target === '\0mixed' || target !== now)) return moved(k)
+        set.targets![k] = now
+    }
+    const sorted = <V>(o: Record<string, V>): Record<string, V> => Object.fromEntries(Object.entries(o).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)))
+    return {
+        reads: {
+            files: sorted(set.files), exists: sorted(set.exists), lists: {}, dirs: sorted(set.dirs!), sigs: sorted(set.sigs!),
+            ...(Object.keys(set.targets!).length > 0 ? { targets: sorted(set.targets!) } : {}),
+            ...(net.closed.length > 0 ? { ports: Object.fromEntries(net.closed.map((port) => [port, 'closed' as const])) } : {}),
+        },
+        why: null,
+        blind: [],
+        processes: p.processes,
+        lines: p.lines,
+    }
+}