dev-cockpit 0.1.0 → 0.2.1

package/dist/commands/init-config.js

@@ -1,131 +0,0 @@
-/**
- * `dev-cockpit init-config` — write a starter `cockpit.yaml`.
- *
- * The template is intentionally minimal and domain-neutral. Every section is
- * commented out except `version` and `appName`; users uncomment the blocks
- * they need. `--with-docker` includes the docker stanza uncommented as a
- * jumping-off point for containerized workflows.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import { renderWizardYaml, runInitWizard } from './init-config-wizard.js';
-import { doctorCommand } from './doctor.js';
-export function buildTemplate(opts) {
-    const dockerBlock = opts.withDocker
-        ? `
-# Docker services to tail in the Output pane. Remove this block on plain-Node
-# projects.
-docker:
-  composeFile: docker-compose.yml
-  services:
-    - name: app
-      tail: true
-`
-        : `
-# Docker services to tail in the Output pane. Uncomment for containerized projects.
-# docker:
-#   composeFile: docker-compose.yml
-#   services:
-#     - name: app
-#       tail: true
-`;
-    return `# dev-cockpit configuration. All keys except \`version\` and \`appName\` are
-# optional; defaults from src/core/config.ts apply when missing.
-
-version: 1
-appName: ${opts.appName}
-
-# Long-running watcher processes streamed into the Output pane.
-# watchers:
-#   - id: build
-#     command: npm run watch
-#     color: cyan
-
-# Repos surfaced in the Repos pane (linkable to watchers / lint).
-# repos:
-#   - id: app
-#     path: .
-#     label: app
-${dockerBlock}
-# Output highlight patterns (regex) — matched lines render with elevated severity.
-# highlights:
-#   - pattern: 'ERROR'
-#     severity: error
-#   - pattern: 'WARN'
-#     severity: warn
-
-# Health checks. Built-in types: container-running, port-open, http-ok,
-# file-exists, exec-zero. See docs/health.md for the full schema.
-# health:
-#   - id: app-up
-#     label: app responsive
-#     type: http-ok
-#     url: http://localhost:3000/health
-
-# Help-pane sources (markdown trees) and the landing page slug.
-# help:
-#   sources: []
-#   defaultPage: getting-started
-
-# Native OS notifications. Set enabled: false to mute entirely.
-# notifications:
-#   enabled: true
-#   exclude: []
-
-# Bind-mount overlays applied by \`dev-cockpit mount\`.
-# mounts:
-#   - hostPath: ./packages/api
-#     containerPath: /srv/api
-`;
-}
-export async function initConfigCommand(opts = {}) {
-    const cwd = opts.cwd ?? process.cwd();
-    const target = path.join(cwd, 'cockpit.yaml');
-    const exists = fs.existsSync(target);
-    if (exists && !opts.force) {
-        process.stdout.write(`dev-cockpit init-config: ${target} already exists.\n` +
-            `  Pass --force to overwrite.\n`);
-        return null;
-    }
-    const content = opts.interactive
-        ? renderWizardYaml(await runInitWizard({
-            defaultAppName: opts.appName ?? (path.basename(cwd) || 'my-cockpit'),
-            cwd,
-        }))
-        : buildTemplate({
-            withDocker: opts.withDocker ?? false,
-            appName: opts.appName ?? 'my-cockpit',
-        });
-    fs.writeFileSync(target, content, 'utf8');
-    process.stdout.write(`\ndev-cockpit init-config: wrote ${target}\n`);
-    if (opts.withDocker) {
-        process.stdout.write('  Docker block uncommented; adjust composeFile/services as needed.\n');
-    }
-    if (opts.interactive) {
-        // Offer to run doctor immediately so the user gets instant feedback that
-        // the config parses + every health check has a baseline state. Note for
-        // edits: re-run `dev-cockpit doctor` any time after hand-editing.
-        const { confirm } = (await import('@inquirer/prompts'));
-        const runDoctorNow = await confirm({
-            message: 'Run `dev-cockpit doctor` now to validate the file + show initial health?',
-            default: true,
-        });
-        if (runDoctorNow) {
-            process.stdout.write('\n');
-            try {
-                await doctorCommand({ config: target, profile: opts.profile });
-            }
-            catch (err) {
-                process.stderr.write(`\ndoctor failed: ${err instanceof Error ? err.message : String(err)}\n`);
-            }
-        }
-        process.stdout.write('\nNext:\n');
-        process.stdout.write('  • Edit cockpit.yaml any time, then re-run `dev-cockpit doctor`.\n');
-        process.stdout.write('  • Run `dev-cockpit dev` to launch the cockpit (Tab/arrows cycle panes, q quits).\n');
-        process.stdout.write('  • The Help tab inside the cockpit has the full docs.\n');
-    }
-    else {
-        process.stdout.write('  Run `dev-cockpit doctor` to verify the config loads cleanly.\n');
-    }
-    return { path: target, overwrote: exists };
-}

package/dist/commands/mount.js

@@ -1,150 +0,0 @@
-/**
- * `dev-cockpit mount` — generic bind-mount overlay manager.
- *
- * Collects mount candidates from two sources and writes a Docker compose
- * override file plus a manifest:
- *   1. `config.mounts[]` — explicit, declared in cockpit.yaml
- *   2. `profile.mountCandidatesProvider?.()` — discovered programmatically
- *
- * The merged set is keyed by `containerPath`; if both sources name the same
- * container path, the config entry wins (explicit > discovered). The
- * compose override targets a single configurable service (default: first
- * service in `config.docker.services`).
- *
- * Subcommands:
- *   mount         — write/refresh the overlay and manifest
- *   mount status  — list active mounts from the manifest
- *   mount clear   — remove overlay and manifest
- */
-import path from 'node:path';
-import fs from 'node:fs';
-import { loadConfig } from '../core/config.js';
-import { getStatePaths } from '../core/paths.js';
-/**
- * Merge mount sources, keyed on containerPath. Config entries win over
- * provider-discovered ones for the same container path.
- */
-export function mergeMounts(configMounts, providerMounts) {
-    const seen = new Map();
-    for (const m of providerMounts)
-        seen.set(m.containerPath, m);
-    for (const m of configMounts)
-        seen.set(m.containerPath, m);
-    return Array.from(seen.values());
-}
-/**
- * Render a Docker compose override YAML for the given service + mounts.
- * Hand-rolled (no `yaml` writer) so the output stays stable + diff-friendly.
- */
-export function renderOverlay(service, mounts) {
-    if (mounts.length === 0) {
-        return `# dev-cockpit: no mounts to apply\nservices: {}\n`;
-    }
-    const lines = [
-        '# Generated by `dev-cockpit mount`. Do not edit by hand — re-run the command.',
-        'services:',
-        `  ${service}:`,
-        '    volumes:',
-    ];
-    for (const m of mounts) {
-        lines.push(`      - ${m.hostPath}:${m.containerPath}`);
-    }
-    lines.push('');
-    return lines.join('\n');
-}
-function resolveOverlayPath(workspaceRoot) {
-    return path.join(workspaceRoot, 'docker-compose.dev-cockpit.yml');
-}
-function manifestPath(workspaceRoot, appName) {
-    const paths = getStatePaths(workspaceRoot, { appName });
-    return path.join(paths.stateDir, 'mount.manifest.json');
-}
-function loadCommandConfig(opts) {
-    const profile = opts.profile;
-    const configPath = path.resolve(opts.config ?? 'cockpit.yaml');
-    if (!fs.existsSync(configPath)) {
-        process.stderr.write(`dev-cockpit mount: no cockpit.yaml found at ${configPath}.\n`);
-        process.exit(1);
-    }
-    const config = loadConfig(configPath, {
-        configSchemaExt: profile?.configSchemaExt,
-        profileKey: profile?.appName,
-    });
-    const workspaceRoot = profile?.discoverer?.()?.root ?? path.dirname(configPath);
-    const explicitService = opts.service ?? config.docker?.services?.[0]?.name;
-    if (!explicitService) {
-        process.stderr.write('dev-cockpit mount: no target service. Pass --service <name> or set docker.services in cockpit.yaml.\n');
-        process.exit(1);
-    }
-    const providerMounts = profile?.mountCandidatesProvider?.() ?? [];
-    return {
-        configPath,
-        workspaceRoot,
-        appName: config.appName,
-        service: explicitService,
-        configMounts: config.mounts,
-        providerMounts,
-    };
-}
-export async function mountCommand(opts = {}) {
-    const { workspaceRoot, appName, service, configMounts, providerMounts } = loadCommandConfig(opts);
-    const merged = mergeMounts(configMounts, providerMounts);
-    if (merged.length === 0) {
-        process.stdout.write('dev-cockpit mount: no mount candidates from config.mounts[] or profile.mountCandidatesProvider.\n');
-        return;
-    }
-    const overlayPath = resolveOverlayPath(workspaceRoot);
-    fs.writeFileSync(overlayPath, renderOverlay(service, merged), 'utf8');
-    const manifest = {
-        appName,
-        workspaceRoot,
-        service,
-        overlayPath,
-        mounts: merged,
-        appliedAt: new Date().toISOString(),
-    };
-    fs.writeFileSync(manifestPath(workspaceRoot, appName), JSON.stringify(manifest, null, 2), 'utf8');
-    process.stdout.write(`dev-cockpit mount: wrote ${overlayPath}\n`);
-    for (const m of merged) {
-        process.stdout.write(`  ${m.hostPath} → ${service}:${m.containerPath}\n`);
-    }
-    process.stdout.write(`  Apply with: docker compose -f <your-compose>.yml -f ${path.basename(overlayPath)} up -d\n`);
-}
-export async function mountStatusCommand(opts = {}) {
-    const { workspaceRoot, appName } = loadCommandConfig(opts);
-    const target = manifestPath(workspaceRoot, appName);
-    if (!fs.existsSync(target)) {
-        process.stdout.write('dev-cockpit mount: no active overlay (no manifest found).\n');
-        return;
-    }
-    const manifest = JSON.parse(fs.readFileSync(target, 'utf8'));
-    process.stdout.write(`dev-cockpit mount status — service: ${manifest.service}\n`);
-    process.stdout.write(`  overlay: ${manifest.overlayPath}\n`);
-    process.stdout.write(`  applied: ${manifest.appliedAt}\n`);
-    if (manifest.mounts.length === 0) {
-        process.stdout.write('  (no mounts)\n');
-        return;
-    }
-    for (const m of manifest.mounts) {
-        process.stdout.write(`  ${m.hostPath} → ${m.containerPath}\n`);
-    }
-}
-export async function mountClearCommand(opts = {}) {
-    const { workspaceRoot, appName } = loadCommandConfig(opts);
-    const overlayPath = resolveOverlayPath(workspaceRoot);
-    const target = manifestPath(workspaceRoot, appName);
-    let removed = 0;
-    if (fs.existsSync(overlayPath)) {
-        fs.rmSync(overlayPath);
-        removed += 1;
-        process.stdout.write(`dev-cockpit mount: removed ${overlayPath}\n`);
-    }
-    if (fs.existsSync(target)) {
-        fs.rmSync(target);
-        removed += 1;
-        process.stdout.write(`dev-cockpit mount: removed ${target}\n`);
-    }
-    if (removed === 0) {
-        process.stdout.write('dev-cockpit mount: nothing to clear.\n');
-    }
-}

package/dist/core/config.js

@@ -1,152 +0,0 @@
-import fs from 'node:fs';
-import { parse as parseYaml } from 'yaml';
-import { z } from 'zod';
-/** Schema version constant. Bumps reserved for breaking changes (see ADR 0004). */
-export const CONFIG_VERSION = 1;
-// ─── Sub-schemas ────────────────────────────────────────────────────────────
-const NotifyOverrideSchema = z.union([
-    z.literal(false),
-    z.object({
-        onTransitionTo: z.array(z.string()).optional(),
-    }),
-]);
-const WatcherSchema = z.object({
-    id: z.string(),
-    label: z.string().optional(),
-    command: z.string(),
-    cwd: z.string().optional(),
-    env: z.record(z.string()).optional(),
-    color: z.string().optional(),
-    restartOn: z.array(z.string()).optional(),
-    notify: NotifyOverrideSchema.optional(),
-});
-const RepoSchema = z.object({
-    id: z.string(),
-    path: z.string(),
-    label: z.string().optional(),
-});
-const ServiceSchema = z.object({
-    name: z.string(),
-    tail: z.boolean().optional().default(true),
-});
-const DockerSchema = z.object({
-    composeFile: z.string().optional(),
-    services: z.array(ServiceSchema).optional().default([]),
-});
-const HighlightSchema = z.object({
-    pattern: z.string(),
-    severity: z.enum(['info', 'warn', 'error']).optional().default('info'),
-});
-const RemediationSchema = z.object({
-    key: z.string(),
-    label: z.string(),
-    command: z.string(),
-    cwd: z.string().optional(),
-});
-const TriggerKindSchema = z.enum(['startup', 'fsevent', 'lockfile', 'docker']);
-const HealthCheckSchema = z.object({
-    id: z.string(),
-    label: z.string(),
-    type: z.string(),
-    severity: z.enum(['ok', 'warn', 'error']).optional(),
-    triggers: z.array(TriggerKindSchema).optional(),
-    url: z.string().optional(),
-    expectStatus: z.number().int().optional(),
-    container: z.string().optional(),
-    port: z.number().int().optional(),
-    host: z.string().optional(),
-    path: z.string().optional(),
-    command: z.string().optional(),
-    args: z.array(z.string()).optional(),
-    cwd: z.string().optional(),
-    notify: NotifyOverrideSchema.optional(),
-    remediation: RemediationSchema,
-});
-const HelpSchema = z.object({
-    sources: z.array(z.string()).optional().default([]),
-    defaultPage: z.string().optional(),
-});
-const NotificationsSchema = z.object({
-    enabled: z.boolean().optional().default(true),
-    onTransitionTo: z.array(z.string()).optional().default([]),
-    exclude: z.array(z.string()).optional().default([]),
-});
-const MountSchema = z.object({
-    hostPath: z.string(),
-    containerPath: z.string(),
-});
-// ─── Base schema ────────────────────────────────────────────────────────────
-export const BaseCockpitConfigSchema = z.object({
-    version: z.number().int(),
-    appName: z.string(),
-    watchers: z.array(WatcherSchema).optional().default([]),
-    repos: z.array(RepoSchema).optional().default([]),
-    docker: DockerSchema.optional(),
-    highlights: z.array(HighlightSchema).optional().default([]),
-    health: z.array(HealthCheckSchema).optional().default([]),
-    help: HelpSchema.optional().default({ sources: [] }),
-    notifications: NotificationsSchema.optional().default({
-        enabled: true,
-        onTransitionTo: [],
-        exclude: [],
-    }),
-    mounts: z.array(MountSchema).optional().default([]),
-    /**
-     * Profile-specific config namespace. Each profile owns one key under here
-     * (e.g. `profile.myapp = { ... }`) and validates it with its own zod schema
-     * passed to the loader as `configSchemaExt`.
-     */
-    profile: z.record(z.unknown()).optional().default({}),
-});
-// ─── Errors ─────────────────────────────────────────────────────────────────
-export class ConfigVersionError extends Error {
-    filePath;
-    found;
-    supported;
-    constructor(filePath, found, supported) {
-        super(`cockpit config at "${filePath}" declares version ${String(found)}, but this build supports version ${supported}`);
-        this.filePath = filePath;
-        this.found = found;
-        this.supported = supported;
-        this.name = 'ConfigVersionError';
-    }
-}
-export class ConfigValidationError extends Error {
-    filePath;
-    cause;
-    constructor(filePath, cause) {
-        super(`invalid cockpit config at "${filePath}": ${String(cause)}`);
-        this.filePath = filePath;
-        this.cause = cause;
-        this.name = 'ConfigValidationError';
-    }
-}
-/**
- * Loads, parses, and validates a `cockpit.yaml` (or any path the caller chooses).
- * Throws `ConfigVersionError` if the file's `version` does not match `CONFIG_VERSION`.
- * Throws `ConfigValidationError` if the schema fails.
- */
-export function loadConfig(filePath, opts = {}) {
-    if (!fs.existsSync(filePath)) {
-        throw new ConfigValidationError(filePath, 'file does not exist');
-    }
-    const content = fs.readFileSync(filePath, 'utf8');
-    const raw = (parseYaml(content) ?? {});
-    if (typeof raw['version'] !== 'number' || raw['version'] !== CONFIG_VERSION) {
-        throw new ConfigVersionError(filePath, raw['version'], CONFIG_VERSION);
-    }
-    const baseResult = BaseCockpitConfigSchema.safeParse(raw);
-    if (!baseResult.success) {
-        throw new ConfigValidationError(filePath, baseResult.error);
-    }
-    const config = baseResult.data;
-    if (opts.configSchemaExt && opts.profileKey) {
-        const profileBlock = config.profile?.[opts.profileKey] ?? {};
-        const profileResult = opts.configSchemaExt.safeParse(profileBlock);
-        if (!profileResult.success) {
-            throw new ConfigValidationError(filePath, profileResult.error);
-        }
-        config.profile[opts.profileKey] = profileResult.data;
-    }
-    return config;
-}

package/dist/core/logger.js

@@ -1,38 +0,0 @@
-import fs from 'node:fs';
-import pino from 'pino';
-const LOG_SIZE_CAP = 10 * 1024 * 1024;
-function rotateIfNeeded(logFile) {
-    try {
-        const stat = fs.statSync(logFile);
-        if (stat.size > LOG_SIZE_CAP) {
-            fs.renameSync(logFile, `${logFile}.1`);
-        }
-    }
-    catch {
-        // File doesn't exist yet — no rotation needed.
-    }
-}
-export function createLogger(logFile) {
-    rotateIfNeeded(logFile);
-    const level = process.env['LOG_LEVEL'] ?? 'info';
-    return pino({ level }, pino.transport({
-        targets: [
-            {
-                target: 'pino/file',
-                level,
-                options: { destination: logFile, mkdir: true },
-            },
-        ],
-    }));
-}
-let _logger = null;
-export function initLogger(logFile) {
-    _logger = createLogger(logFile);
-    return _logger;
-}
-export function getLogger() {
-    if (!_logger) {
-        throw new Error('logger not initialized — call initLogger(logFile) first');
-    }
-    return _logger;
-}

package/dist/core/notifier.js

@@ -1,100 +0,0 @@
-export function detectTransitions(prev, next) {
-    const prevMap = new Map();
-    for (const s of prev) {
-        prevMap.set(s.id, s);
-    }
-    const transitions = [];
-    for (const nextStatus of next) {
-        const prevStatus = prevMap.get(nextStatus.id);
-        if (!prevStatus) {
-            if (nextStatus.severity === 'error') {
-                transitions.push({
-                    event: 'health-failed',
-                    id: nextStatus.id,
-                    label: nextStatus.label,
-                    detail: nextStatus.detail,
-                });
-            }
-            continue;
-        }
-        const wasOk = prevStatus.severity !== 'error';
-        const isOk = nextStatus.severity !== 'error';
-        if (wasOk && !isOk) {
-            transitions.push({
-                event: 'health-failed',
-                id: nextStatus.id,
-                label: nextStatus.label,
-                detail: nextStatus.detail,
-            });
-        }
-        else if (!wasOk && isOk) {
-            transitions.push({
-                event: 'health-recovered',
-                id: nextStatus.id,
-                label: nextStatus.label,
-                detail: nextStatus.detail,
-            });
-        }
-    }
-    return transitions;
-}
-export function notify(transition, opts) {
-    const { config, sessionEnabled, sender, appName = 'cockpit' } = opts;
-    if (!sessionEnabled)
-        return;
-    if (!config.enabled)
-        return;
-    if (config.exclude.includes(transition.event))
-        return;
-    const title = `${appName} — ${transition.label}`;
-    const message = transition.detail;
-    if (sender) {
-        sender(title, message);
-        return;
-    }
-    defaultPlatformNotify(title, message);
-}
-/**
- * OS notification via a detached child process. The child runs independently
- * (`detached: true`, `stdio: 'ignore'`, `unref()`) so it never enters the
- * parent's event loop — the cockpit can exit while the notification helper
- * is still flushing without leaving an unreaped ChildProcess handle.
- *
- * Platforms:
- *  - darwin: `osascript -e 'display notification …'`
- *  - linux:  `notify-send`
- *  - other:  silently skipped
- */
-function defaultPlatformNotify(title, message) {
-    // Lazy require so test environments don't pull child_process at import time.
-    void import('node:child_process').then(({ spawn }) => {
-        try {
-            let child = null;
-            if (process.platform === 'darwin') {
-                const safeTitle = title.replace(/(["\\])/g, '\\$1');
-                const safeMsg = message.replace(/(["\\])/g, '\\$1');
-                child = spawn('osascript', ['-e', `display notification "${safeMsg}" with title "${safeTitle}"`], { detached: true, stdio: 'ignore' });
-            }
-            else if (process.platform === 'linux') {
-                child = spawn('notify-send', [title, message], {
-                    detached: true,
-                    stdio: 'ignore',
-                });
-            }
-            child?.unref();
-        }
-        catch {
-            // Notification is best-effort. Don't crash the cockpit if the helper
-            // binary is missing (e.g. headless Linux without notify-send).
-        }
-    });
-}
-export function notifyTransitions(prev, next, opts) {
-    const transitions = detectTransitions(prev, next);
-    for (const t of transitions) {
-        notify(t, opts);
-    }
-}
-export function emitEvent(event, label, detail, opts) {
-    notify({ event, id: String(event), label, detail }, opts);
-}

package/dist/core/paths.js

@@ -1,18 +0,0 @@
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-export function hashWorkspacePath(workspaceRoot) {
-    return crypto.createHash('sha256').update(workspaceRoot).digest('hex').slice(0, 8);
-}
-export function getStatePaths(workspaceRoot, opts) {
-    const xdgStateHome = process.env['XDG_STATE_HOME'] ?? path.join(os.homedir(), '.local', 'state');
-    const hash = hashWorkspacePath(workspaceRoot);
-    const stateDir = path.join(xdgStateHome, opts.appName, hash);
-    fs.mkdirSync(stateDir, { recursive: true });
-    return {
-        stateDir,
-        lockFile: path.join(stateDir, 'cockpit.lock'),
-        logFile: path.join(stateDir, 'cockpit.log'),
-    };
-}

package/dist/core/subprocess.js

@@ -1,82 +0,0 @@
-import { execa } from 'execa';
-/**
- * Module-level registry of every currently-running spawnStream child. Each
- * spawn auto-registers; auto-deregisters when the child exits. Callers that
- * own a long-running session (typically the `dev` command) sweep this on
- * teardown via {@link killAllSpawned} so no rogue subprocess keeps the Node
- * event loop alive after the cockpit unmounts.
- */
-const ACTIVE = new Set();
-export function spawnStream(cmd, args, opts = {}) {
-    const child = execa(cmd, args, {
-        cwd: opts.cwd,
-        env: opts.env ? { ...process.env, ...opts.env } : process.env,
-        all: false,
-        lines: true,
-        reject: false,
-        stdout: 'pipe',
-        stderr: 'pipe',
-    });
-    if (opts.onStdout && child.stdout) {
-        child.stdout.on('data', (chunk) => {
-            const text = chunk.toString();
-            for (const line of text.split('\n')) {
-                if (line)
-                    opts.onStdout(line);
-            }
-        });
-    }
-    if (opts.onStderr && child.stderr) {
-        child.stderr.on('data', (chunk) => {
-            const text = chunk.toString();
-            for (const line of text.split('\n')) {
-                if (line)
-                    opts.onStderr(line);
-            }
-        });
-    }
-    const exitCode = child.then((result) => result.exitCode ?? 0);
-    const handle = {
-        exitCode,
-        kill: (signal = 'SIGTERM') => {
-            child.kill(signal);
-        },
-        child,
-    };
-    ACTIVE.add(handle);
-    void exitCode.finally(() => ACTIVE.delete(handle));
-    return handle;
-}
-/**
- * Send SIGTERM to every still-running spawnStream child and await each one's
- * reap. After {@link sigkillAfterMs} the holdouts are SIGKILLed so the sweep
- * cannot hang indefinitely on an unresponsive subprocess.
- */
-export async function killAllSpawned(sigkillAfterMs = 1500) {
-    if (ACTIVE.size === 0)
-        return;
-    const handles = Array.from(ACTIVE);
-    for (const h of handles)
-        h.kill('SIGTERM');
-    const reaps = handles.map((h) => h.exitCode.catch(() => undefined));
-    let timer = null;
-    const guard = new Promise((resolve) => {
-        timer = setTimeout(() => {
-            for (const h of handles) {
-                try {
-                    h.kill('SIGKILL');
-                }
-                catch {
-                    // already dead
-                }
-            }
-            resolve();
-        }, sigkillAfterMs);
-    });
-    await Promise.race([Promise.all(reaps), guard]);
-    if (timer)
-        clearTimeout(timer);
-    // After the SIGKILL fallback, drain the original exitCodes so handles are
-    // fully released from the event loop.
-    await Promise.all(reaps);
-}

package/dist/core/types.js

@@ -1 +0,0 @@
-export {};