@nocville/npc 0.2.3 → 0.3.1

package/dist/npcs/office-characters/index.d.ts

@@ -0,0 +1,55 @@
+import { PollingNPC } from '../../core/polling-npc.js';
+import type { PollingNpcConfig } from '../../core/polling-npc.js';
+import type { Archetype, BehaviorHints, CollectedMetrics } from '../../core/types.js';
+/** Quiet heartbeats; the authoritative server drives routines and conversation. */
+declare abstract class OfficeCharacterNPC extends PollingNPC {
+    constructor(config: PollingNpcConfig);
+    abstract get name(): NonNullable<BehaviorHints['role']>;
+    get archetype(): Archetype;
+    get behavior(): BehaviorHints;
+    protected collect(): Promise<CollectedMetrics>;
+}
+export declare class JanitorNPC extends OfficeCharacterNPC {
+    get name(): 'janitor';
+    protected get defaultDisplayName(): string;
+}
+export declare class BaristaNPC extends OfficeCharacterNPC {
+    get name(): 'barista';
+    protected get defaultDisplayName(): string;
+}
+export declare class OfficeCatNPC extends OfficeCharacterNPC {
+    get name(): 'office-cat';
+    protected get defaultDisplayName(): string;
+}
+export declare class OfficeDogNPC extends OfficeCharacterNPC {
+    get name(): 'office-dog';
+    protected get defaultDisplayName(): string;
+}
+export declare class PlantCaretakerNPC extends OfficeCharacterNPC {
+    get name(): 'plant-caretaker';
+    protected get defaultDisplayName(): string;
+}
+export declare class ITTechnicianNPC extends OfficeCharacterNPC {
+    get name(): 'it-technician';
+    protected get defaultDisplayName(): string;
+}
+export declare class OutOfTouchExecutiveNPC extends OfficeCharacterNPC {
+    get name(): 'out-of-touch-executive';
+    protected get defaultDisplayName(): string;
+}
+export declare class SlightlyInappropriateHRNPC extends OfficeCharacterNPC {
+    get name(): 'slightly-inappropriate-hr';
+    protected get defaultDisplayName(): string;
+}
+export declare const OFFICE_CHARACTER_NPCS: {
+    readonly janitor: typeof JanitorNPC;
+    readonly barista: typeof BaristaNPC;
+    readonly 'office-cat': typeof OfficeCatNPC;
+    readonly 'office-dog': typeof OfficeDogNPC;
+    readonly 'plant-caretaker': typeof PlantCaretakerNPC;
+    readonly 'it-technician': typeof ITTechnicianNPC;
+    readonly 'out-of-touch-executive': typeof OutOfTouchExecutiveNPC;
+    readonly 'slightly-inappropriate-hr': typeof SlightlyInappropriateHRNPC;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/npcs/office-characters/index.js

@@ -0,0 +1,91 @@
+import { PollingNPC } from '../../core/polling-npc.js';
+/** Quiet heartbeats; the authoritative server drives routines and conversation. */
+class OfficeCharacterNPC extends PollingNPC {
+    constructor(config) {
+        super({ ...config, pollInterval: config.pollInterval ?? 60_000 });
+    }
+    get archetype() {
+        return 'custom';
+    }
+    get behavior() {
+        return { role: this.name, activity: 'idle', idlePose: 'stand' };
+    }
+    async collect() {
+        return { status: 'healthy', mood: 'happy', message: '', metrics: {} };
+    }
+}
+export class JanitorNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'janitor';
+    }
+    get defaultDisplayName() {
+        return 'Janitor';
+    }
+}
+export class BaristaNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'barista';
+    }
+    get defaultDisplayName() {
+        return 'Barista';
+    }
+}
+export class OfficeCatNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'office-cat';
+    }
+    get defaultDisplayName() {
+        return 'Office Cat';
+    }
+}
+export class OfficeDogNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'office-dog';
+    }
+    get defaultDisplayName() {
+        return 'Office Dog';
+    }
+}
+export class PlantCaretakerNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'plant-caretaker';
+    }
+    get defaultDisplayName() {
+        return 'Plant Caretaker';
+    }
+}
+export class ITTechnicianNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'it-technician';
+    }
+    get defaultDisplayName() {
+        return 'IT Technician';
+    }
+}
+export class OutOfTouchExecutiveNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'out-of-touch-executive';
+    }
+    get defaultDisplayName() {
+        return 'Out-of-Touch Executive';
+    }
+}
+export class SlightlyInappropriateHRNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'slightly-inappropriate-hr';
+    }
+    get defaultDisplayName() {
+        return 'Slightly Inappropriate HR';
+    }
+}
+export const OFFICE_CHARACTER_NPCS = {
+    janitor: JanitorNPC,
+    barista: BaristaNPC,
+    'office-cat': OfficeCatNPC,
+    'office-dog': OfficeDogNPC,
+    'plant-caretaker': PlantCaretakerNPC,
+    'it-technician': ITTechnicianNPC,
+    'out-of-touch-executive': OutOfTouchExecutiveNPC,
+    'slightly-inappropriate-hr': SlightlyInappropriateHRNPC,
+};
+//# sourceMappingURL=index.js.map

package/dist/npcs/process-watcher/index.js

@@ -1,7 +1,7 @@
 import { PollingNPC } from '../../core/polling-npc.js';
 import { evaluateThreshold, worstStatus, moodForStatus } from '../../core/thresholds.js';
 import { statusColor, pushHistory } from '../../core/screen.js';
-import { NpcConfigError, assertPosix } from '../../core/errors.js';
+import { NpcConfigError } from '../../core/errors.js';
 import { scanProcesses, detectTransitions } from './process-scanner.js';
 import { DEFAULTS } from './defaults.js';
 /** Max per-process panels on the companion dashboard. */
@@ -13,7 +13,6 @@ export class ProcessWatcherNPC extends PollingNPC {
     cpuHistories = new Map();
     previousRunning = null;
     constructor(config) {
-        assertPosix('process-watcher', 'It relies on the POSIX `ps` command; run it under WSL/Linux, or use system-monitor instead.');
         super(config);
         this.processes = [...new Set(config.processes.map((p) => p.trim()).filter(Boolean))];
         if (this.processes.length === 0) {

package/dist/npcs/process-watcher/process-scanner.d.ts

@@ -37,11 +37,13 @@ export declare function parsePsOutput(stdout: string): PsEntry[];
 export declare function matchesName(comm: string, searchName: string): boolean;
 /** List every process. Throws if `ps` fails — callers must not read that as "all dead". */
 export declare function listProcesses(): Promise<PsEntry[]>;
+/** Windows instance suffixes (#1, #2) distinguish copies of the same executable. */
+export declare function parseWindowsProcesses(stdout: string, cores?: number): PsEntry[];
 /** Summarise each watched name against a process list (CPU and memory summed per name). */
 export declare function matchProcesses(names: string[], entries: PsEntry[]): ProcessInfo[];
 /**
  * Scan for processes by name and return their status and resource usage.
- * Works on macOS and Linux via `ps`. Throws when the process list is unavailable.
+ * Uses `ps` on macOS/Linux and CIM on Windows. Throws when the process list is unavailable.
  */
 export declare function scanProcesses(names: string[]): Promise<ProcessInfo[]>;
 //# sourceMappingURL=process-scanner.d.ts.map

package/dist/npcs/process-watcher/process-scanner.js

@@ -1,5 +1,7 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { cpus } from 'node:os';
+import { join } from 'node:path';
 const execFileAsync = promisify(execFile);
 /** Bounds on the `ps` call: a wedged or enormous process table can't stall or flood us. */
 const PS_TIMEOUT_MS = 5000;
@@ -52,10 +54,10 @@ export function parsePsOutput(stdout) {
  * Unlike a substring match, `sh` does not match `bash` or `ssh-agent`.
  */
 export function matchesName(comm, searchName) {
-    if (searchName.includes('/'))
+    if (/[\\/]/.test(searchName))
         return comm === searchName;
-    const base = (comm.split('/').pop() ?? comm).toLowerCase();
-    const name = searchName.toLowerCase();
+    const base = (comm.split(/[\\/]/).pop() ?? comm).toLowerCase().replace(/\.exe$/, '');
+    const name = searchName.toLowerCase().replace(/\.exe$/, '');
     if (base === name)
         return true;
     if (name.length > LINUX_COMM_LEN && base === name.slice(0, LINUX_COMM_LEN))
@@ -64,6 +66,18 @@ export function matchesName(comm, searchName) {
 }
 /** List every process. Throws if `ps` fails — callers must not read that as "all dead". */
 export async function listProcesses() {
+    if (process.platform === 'win32') {
+        // Fixed command, no user strings interpolated. Performance counters report a
+        // sampling interval (Get-Process.CPU is lifetime CPU seconds, not a percent).
+        const executable = join(process.env['SystemRoot'] || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+        const { stdout } = await execFileAsync(executable, [
+            '-NoProfile',
+            '-NonInteractive',
+            '-Command',
+            '$ErrorActionPreference="Stop"; Get-CimInstance Win32_PerfFormattedData_PerfProc_Process | Select-Object IDProcess,Name,PercentProcessorTime,WorkingSetPrivate | ConvertTo-Json -Compress',
+        ], { timeout: PS_TIMEOUT_MS, maxBuffer: PS_MAX_BUFFER, windowsHide: true });
+        return parseWindowsProcesses(stdout, cpus().length);
+    }
     const { stdout } = await execFileAsync('ps', ['-eo', 'pid=,pcpu=,rss=,comm='], {
         timeout: PS_TIMEOUT_MS,
         maxBuffer: PS_MAX_BUFFER,
@@ -72,6 +86,29 @@ export async function listProcesses() {
     });
     return parsePsOutput(stdout);
 }
+/** Windows instance suffixes (#1, #2) distinguish copies of the same executable. */
+export function parseWindowsProcesses(stdout, cores = 1) {
+    const value = JSON.parse(stdout.replace(/^\uFEFF/, ''));
+    const rows = Array.isArray(value) ? value : value ? [value] : [];
+    return rows.flatMap((row) => {
+        const pid = Number(row.IDProcess);
+        const cpu = Number(row.PercentProcessorTime);
+        const bytes = Number(row.WorkingSetPrivate);
+        if (!(pid > 0) ||
+            !Number.isFinite(cpu) ||
+            !Number.isFinite(bytes) ||
+            typeof row.Name !== 'string')
+            return [];
+        return [
+            {
+                pid,
+                cpu: cpu / Math.max(1, cores),
+                memKb: bytes / 1024,
+                comm: row.Name.replace(/#\d+$/, ''),
+            },
+        ];
+    });
+}
 /** Summarise each watched name against a process list (CPU and memory summed per name). */
 export function matchProcesses(names, entries) {
     return names.map((name) => {
@@ -92,7 +129,7 @@ export function matchProcesses(names, entries) {
 }
 /**
  * Scan for processes by name and return their status and resource usage.
- * Works on macOS and Linux via `ps`. Throws when the process list is unavailable.
+ * Uses `ps` on macOS/Linux and CIM on Windows. Throws when the process list is unavailable.
  */
 export async function scanProcesses(names) {
     return matchProcesses(names, await listProcesses());

package/dist/npcs/receptionist/index.d.ts

@@ -1,39 +1,20 @@
 import { PollingNPC } from '../../core/polling-npc.js';
 import type { PollingNpcConfig } from '../../core/polling-npc.js';
-import type { CollectedMetrics, Archetype, BehaviorHints, CompanionDecl } from '../../core/types.js';
+import type { CollectedMetrics, Archetype, BehaviorHints } from '../../core/types.js';
 export interface ReceptionistConfig extends PollingNpcConfig {
+    /** @deprecated Reception no longer uses weather or geolocation. Accepted for compatibility. */
     lat?: number;
     lon?: number;
     location?: string;
-    /** Display temperature in Fahrenheit instead of Celsius. */
     fahrenheit?: boolean;
-    /**
-     * Fall back to IP geolocation (ipapi.co) when no --lat/--lon or --location
-     * is given. Default true; false keeps the receptionist in time-only mode
-     * rather than sending this machine's IP to a third party.
-     */
     ipGeo?: boolean;
 }
 export declare class ReceptionistNPC extends PollingNPC {
-    private explicitCoords;
-    private location?;
-    private fahrenheit;
-    private ipGeo;
-    private coords;
-    /** Earliest time to retry geocoding / IP geo after a failure. */
-    private nextGeoAttempt;
-    private weather;
-    private weatherFetchedAt;
-    /** Earliest time to retry the weather after a failure. */
-    private nextWeatherAttempt;
     constructor(config: ReceptionistConfig);
     get name(): string;
     protected get defaultDisplayName(): string;
     get archetype(): Archetype;
     get behavior(): BehaviorHints;
-    get companion(): CompanionDecl;
     protected collect(): Promise<CollectedMetrics>;
-    private refreshWeather;
-    private resolveCoords;
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/npcs/receptionist/index.js

@@ -1,34 +1,7 @@
 import { PollingNPC } from '../../core/polling-npc.js';
-import { NpcConfigError } from '../../core/errors.js';
-import { DEFAULTS } from './defaults.js';
-import { fetchWeather, geocodeLocation, autoGeo, formatClock, toFahrenheit, validCoords, } from './weather.js';
 export class ReceptionistNPC extends PollingNPC {
-    explicitCoords;
-    location;
-    fahrenheit;
-    ipGeo;
-    coords = null;
-    /** Earliest time to retry geocoding / IP geo after a failure. */
-    nextGeoAttempt = 0;
-    weather = null;
-    weatherFetchedAt = 0;
-    /** Earliest time to retry the weather after a failure. */
-    nextWeatherAttempt = 0;
     constructor(config) {
-        super({ ...config, pollInterval: config.pollInterval ?? DEFAULTS.pollInterval });
-        if ((config.lat === undefined) !== (config.lon === undefined)) {
-            throw new NpcConfigError('--lat and --lon must be given together');
-        }
-        if (config.lat !== undefined && !validCoords(config.lat, config.lon)) {
-            throw new NpcConfigError('--lat must be within ±90 and --lon within ±180');
-        }
-        this.explicitCoords =
-            config.lat !== undefined && config.lon !== undefined
-                ? { lat: config.lat, lon: config.lon }
-                : null;
-        this.location = config.location?.trim() || undefined;
-        this.fahrenheit = config.fahrenheit ?? false;
-        this.ipGeo = config.ipGeo ?? true;
+        super({ ...config, pollInterval: config.pollInterval ?? 60_000 });
     }
     get name() {
         return 'receptionist';
@@ -41,102 +14,16 @@ export class ReceptionistNPC extends PollingNPC {
     }
     get behavior() {
         return {
+            role: 'receptionist',
+            activity: 'idle',
             greetPlayers: true,
-            patrol: { everyMinutes: [15, 30], stops: 5 },
             idle: 'stay',
-            home: { near: 'entrance' },
-        };
-    }
-    get companion() {
-        return {
-            screenType: 'welcome-sign',
-            size: { w: 2, h: 1 },
-            placement: 'adjacent-wall',
-            label: 'Welcome',
+            idlePose: 'sit',
         };
     }
     async collect() {
-        await this.refreshWeather();
-        const now = new Date();
-        const { day, date, time } = formatClock(now);
-        const values = [
-            { label: 'time', value: time },
-            { label: 'day', value: day },
-            { label: 'date', value: date },
-        ];
-        let message = `${day} ${time}`;
-        const metrics = { weather_ok: this.weather ? 1 : 0 };
-        if (this.weather) {
-            const temp = this.fahrenheit
-                ? `${toFahrenheit(this.weather.tempC)}°F`
-                : `${this.weather.tempC}°C`;
-            message += ` • ${temp} ${this.weather.text}`;
-            values.push({ label: 'temp', value: temp }, { label: 'condition', value: this.weather.text }, { label: 'icon', value: this.weather.icon });
-            metrics['temp_c'] = this.weather.tempC;
-            metrics['weather_code'] = this.weather.code;
-            metrics['wind_kph'] = this.weather.windKph;
-        }
-        // The receptionist is a greeter/clock — it stays healthy even when weather
-        // is unavailable (degraded time-only mode).
-        return {
-            status: 'healthy',
-            mood: 'happy',
-            message,
-            screenData: { layout: 'welcome-sign', values },
-            metrics,
-        };
-    }
-    async refreshWeather() {
-        const now = Date.now();
-        if (!this.coords)
-            await this.resolveCoords(now);
-        // Don't show a reading that has gone stale through repeated failures.
-        if (this.weather && now - this.weatherFetchedAt > DEFAULTS.weatherMaxAgeMs) {
-            this.weather = null;
-        }
-        if (!this.coords || now < this.nextWeatherAttempt)
-            return;
-        if (this.weather && now - this.weatherFetchedAt < DEFAULTS.weatherRefreshMs)
-            return;
-        const w = await fetchWeather(this.coords, DEFAULTS.fetchTimeoutMs);
-        if (w) {
-            this.weather = w;
-            this.weatherFetchedAt = now;
-        }
-        else {
-            this.nextWeatherAttempt = now + DEFAULTS.retryBackoffMs;
-        }
-    }
-    async resolveCoords(now) {
-        if (this.explicitCoords) {
-            this.coords = this.explicitCoords;
-            return;
-        }
-        // Back off after a failure rather than hitting the keyless endpoints every tick.
-        if (now < this.nextGeoAttempt)
-            return;
-        this.nextGeoAttempt = now + DEFAULTS.retryBackoffMs;
-        if (this.location) {
-            this.coords = await geocodeLocation(this.location, DEFAULTS.fetchTimeoutMs);
-            if (this.coords)
-                return;
-            this.logger.warn(`Could not geocode "${this.location}"` + (this.ipGeo ? ', falling back to IP geo' : ''));
-        }
-        if (!this.ipGeo) {
-            if (!this.location) {
-                this.nextGeoAttempt = Infinity; // nothing to resolve, ever
-                this.logger.info('No location set and IP geolocation disabled: time-only mode');
-            }
-            return;
-        }
-        this.coords = await autoGeo(DEFAULTS.fetchTimeoutMs);
-        if (this.coords) {
-            this.logger.info("Weather location estimated from this machine's IP via ipapi.co " +
-                '(set --location or --lat/--lon, or pass --no-ip-geo to disable)');
-        }
-        else {
-            this.logger.warn('Weather geo unavailable — running in time-only mode for now');
-        }
+        // The server handles conversation and movement. Heartbeats stay quiet.
+        return { status: 'healthy', mood: 'happy', message: '', metrics: {} };
     }
 }
 //# sourceMappingURL=index.js.map

package/dist/npcs/security/index.d.ts

@@ -0,0 +1,12 @@
+import { PollingNPC } from '../../core/polling-npc.js';
+import type { PollingNpcConfig } from '../../core/polling-npc.js';
+import type { CollectedMetrics, Archetype, BehaviorHints } from '../../core/types.js';
+export declare class SecurityNPC extends PollingNPC {
+    constructor(config: PollingNpcConfig);
+    get name(): string;
+    protected get defaultDisplayName(): string;
+    get archetype(): Archetype;
+    get behavior(): BehaviorHints;
+    protected collect(): Promise<CollectedMetrics>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/npcs/security/index.js

@@ -0,0 +1,22 @@
+import { PollingNPC } from '../../core/polling-npc.js';
+export class SecurityNPC extends PollingNPC {
+    constructor(config) {
+        super({ ...config, pollInterval: config.pollInterval ?? 60_000 });
+    }
+    get name() {
+        return 'security';
+    }
+    get defaultDisplayName() {
+        return 'Security';
+    }
+    get archetype() {
+        return 'custom';
+    }
+    get behavior() {
+        return { role: 'security', activity: 'idle', idlePose: 'stand' };
+    }
+    async collect() {
+        return { status: 'healthy', mood: 'happy', message: '', metrics: {} };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/npcs/web-page-watcher/basic.d.ts

@@ -0,0 +1,16 @@
+import type { Status } from '../../core/types.js';
+export interface BasicCheck {
+    status: number;
+    title: string;
+    ok: boolean;
+    timedOut: boolean;
+}
+/** Extract the <title> text from an HTML string (empty if none). */
+export declare function extractTitle(html: string): string;
+/** Map an HTTP status to NPC status: 2xx/3xx ok, 4xx/timeout warn, 5xx/refused crit. */
+export declare function statusFromHttp(code: number, timedOut?: boolean): Status;
+/** Fetch a page and extract HTTP status + <title> (basic, no browser). */
+export declare function basicCheck(url: string, timeoutMs?: number): Promise<BasicCheck>;
+/** Best-effort hostname for a URL, falling back to the raw string. */
+export declare function hostnameOf(url: string): string;
+//# sourceMappingURL=basic.d.ts.map

package/dist/npcs/web-page-watcher/basic.js

@@ -0,0 +1,52 @@
+/** Extract the <title> text from an HTML string (empty if none). */
+export function extractTitle(html) {
+    const m = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+    return m ? m[1].replace(/\s+/g, ' ').trim().slice(0, 80) : '';
+}
+/** Map an HTTP status to NPC status: 2xx/3xx ok, 4xx/timeout warn, 5xx/refused crit. */
+export function statusFromHttp(code, timedOut = false) {
+    if (code >= 200 && code < 400)
+        return 'healthy';
+    if (code >= 400 && code < 500)
+        return 'warning';
+    if (code >= 500)
+        return 'critical';
+    return timedOut ? 'warning' : 'critical'; // 0 = network error
+}
+/** Fetch a page and extract HTTP status + <title> (basic, no browser). */
+export async function basicCheck(url, timeoutMs = 8000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, {
+            signal: controller.signal,
+            headers: { 'User-Agent': 'nocville-npc' },
+            redirect: 'follow',
+        });
+        let title = '';
+        try {
+            title = extractTitle(await res.text());
+        }
+        catch {
+            // body unavailable; leave title blank
+        }
+        return { status: res.status, title, ok: res.ok, timedOut: false };
+    }
+    catch (err) {
+        const timedOut = err instanceof Error && err.name === 'AbortError';
+        return { status: 0, title: '', ok: false, timedOut };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Best-effort hostname for a URL, falling back to the raw string. */
+export function hostnameOf(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return url.slice(0, 40);
+    }
+}
+//# sourceMappingURL=basic.js.map

package/dist/npcs/web-page-watcher/capture.js

@@ -1,3 +1,4 @@
+import { join } from 'node:path';
 import { existsSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 const MAC_PATHS = [
@@ -43,6 +44,25 @@ export function findChrome(explicit) {
                 return p;
         return null;
     }
+    if (process.platform === 'win32') {
+        const roots = [
+            process.env['LOCALAPPDATA'],
+            process.env['PROGRAMFILES'],
+            process.env['PROGRAMFILES(X86)'],
+        ].filter((p) => !!p);
+        for (const root of roots)
+            for (const relative of [
+                ['Google', 'Chrome', 'Application', 'chrome.exe'],
+                ['Microsoft', 'Edge', 'Application', 'msedge.exe'],
+                ['Chromium', 'Application', 'chrome.exe'],
+                ['BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'],
+            ]) {
+                const path = join(root, ...relative);
+                if (existsSync(path))
+                    return path;
+            }
+        return null;
+    }
     if (process.platform === 'linux') {
         for (const bin of LINUX_BINARIES) {
             const resolved = which(bin);
@@ -76,6 +96,12 @@ export function runningAsRoot() {
  */
 export async function loadPuppeteer() {
     try {
+        // Prefer CommonJS in bundled runtimes so Electron resolves through its
+        // ASAR loader. Native ESM installations use the optional dynamic import below.
+        if (typeof require === 'function') {
+            const mod = require('puppeteer-core');
+            return mod.default ?? mod;
+        }
         const dynImport = new Function('m', 'return import(m)');
         const mod = await dynImport('puppeteer-core');
         return (mod.default ?? mod);

package/dist/npcs/web-page-watcher/chrome.d.ts

@@ -0,0 +1,46 @@
+export interface PuppeteerViewport {
+    width: number;
+    height: number;
+    deviceScaleFactor?: number;
+}
+export interface PuppeteerResponse {
+    status(): number;
+}
+export interface PuppeteerPage {
+    setViewport(v: PuppeteerViewport): Promise<void>;
+    goto(url: string, opts?: {
+        waitUntil?: string;
+        timeout?: number;
+    }): Promise<PuppeteerResponse | null>;
+    screenshot(opts: {
+        type?: string;
+        fullPage?: boolean;
+    }): Promise<Buffer | Uint8Array>;
+    close(): Promise<void>;
+}
+export interface PuppeteerBrowser {
+    newPage(): Promise<PuppeteerPage>;
+    close(): Promise<void>;
+    /** puppeteer >= 20 exposes `connected`; older versions expose isConnected(). */
+    connected?: boolean;
+    isConnected?(): boolean;
+    on(event: string, cb: () => void): void;
+}
+export interface PuppeteerModule {
+    launch(opts: {
+        executablePath?: string;
+        headless?: boolean | 'new';
+        args?: string[];
+    }): Promise<PuppeteerBrowser>;
+}
+/** Find a usable Chrome/Chromium executable: explicit path → env → known paths. */
+export declare function findChrome(explicit?: string): string | null;
+/**
+ * Load the optional `puppeteer-core` peer dependency without a static import,
+ * so the package builds and runs when it isn't installed. Returns null if the
+ * module is absent.
+ */
+export declare function loadPuppeteer(): Promise<PuppeteerModule | null>;
+/** True if the browser reports a live connection. */
+export declare function browserConnected(browser: PuppeteerBrowser): boolean;
+//# sourceMappingURL=chrome.d.ts.map