fauxnix-cli 0.9.3 → 0.12.0

package/dist/ps-host.js

@@ -1,11 +1,22 @@
 import { spawn } from 'node:child_process';
-import { writeFileSync } from 'node:fs';
+import { closeSync, mkdirSync, openSync, readSync, rmSync, statSync, writeFileSync, writeSync, } from 'node:fs';
 import { hostBootstrapScript } from './translator.js';
-const PS_ARGS = ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass'];
+import { POWERSHELL_ARGS, powerShellMissingMessage, resolvePowerShell, } from './powershell.js';
+class NativeStderrSpoolError extends Error {
+    constructor(operation, spoolPath, cause) {
+        const detail = cause instanceof Error ? cause.message : String(cause);
+        const code = cause?.code;
+        super('fauxnix: native stderr spool ' +
+            operation +
+            ' failed' +
+            (code ? ' (' + code + ')' : '') +
+            (spoolPath ? ' for ' + spoolPath : '') +
+            ': ' +
+            detail);
+        this.name = 'NativeStderrSpoolError';
+    }
+}
 const READY_TIMEOUT_MS = 30_000;
-export const PS_MISSING_MESSAGE = 'fauxnix: powershell.exe not found — fauxnix executes bash via native Windows PowerShell 5.1+.\n' +
-    'This host has no PowerShell on PATH (typical for Linux containers/sandboxes).\n' +
-    'Run fauxnix on Windows, or install PowerShell and make powershell.exe reachable on PATH.\n';
 export const DEFAULT_STDOUT_LIMIT = 8_388_608;
 export const DEFAULT_STDERR_LIMIT = 1_048_576;
 export function encodeHostRequest(id, script, env, opts) {
@@ -19,6 +30,12 @@ export function encodeHostRequest(id, script, env, opts) {
         body.type = 'run';
         body.stdoutLimit = opts.stdoutLimit ?? DEFAULT_STDOUT_LIMIT;
         body.stderrLimit = opts.stderrLimit ?? DEFAULT_STDERR_LIMIT;
+        body.stdoutMode = opts.stdoutMode ?? 'capture';
+        body.stderrMode = opts.stderrMode ?? 'capture';
+        if (opts.stdoutSpoolPath)
+            body.stdoutSpoolPath = opts.stdoutSpoolPath;
+        if (opts.stderrSpoolPath)
+            body.stderrSpoolPath = opts.stderrSpoolPath;
     }
     return JSON.stringify(body);
 }
@@ -42,27 +59,32 @@ export function decodeHostResponse(line) {
     };
 }
 /**
- * One resident powershell.exe 5.1 process. Frames are UTF-8 JSON lines;
- * command stdout/stderr come back as base64 so PS 5.1's UTF-16LE pipe
- * encoding cannot scramble the payload.
+ * One resident selected PowerShell process. Frames are UTF-8 JSON lines;
+ * command stdout/stderr come back as base64 so Windows PowerShell 5.1's
+ * UTF-16LE pipe encoding cannot scramble the payload.
  */
 export class PowerShellHost {
     hostFile;
     envFn;
+    powerShell;
+    nativeSpoolWrite;
     proc = null;
     stdoutBuf = Buffer.alloc(0);
     queuedLines = [];
     waiters = [];
     stderrChunks = [];
+    nativeCapture = null;
     closeCode;
     closeErr = null;
     closed = false;
     startLock = null;
     invokeLock = Promise.resolve();
     protocol = 1;
-    constructor(hostFile, envFn) {
+    constructor(hostFile, envFn, powerShell = resolvePowerShell(), nativeSpoolWrite = (fd, buffer, offset, length) => writeSync(fd, buffer, offset, length)) {
         this.hostFile = hostFile;
         this.envFn = envFn;
+        this.powerShell = powerShell;
+        this.nativeSpoolWrite = nativeSpoolWrite;
     }
     /** Start the resident process and wait for the ready handshake (B1 prewarm). */
     async ready() {
@@ -81,10 +103,11 @@ export class PowerShellHost {
         return b;
     }
     async stop() {
+        this.cancelNativeCapture();
         const proc = this.proc;
         this.proc = null;
         this.closed = true;
-        this.failWaiters(new Error('fauxnix: powershell host stopped'));
+        this.failWaiters(new Error('fauxnix: PowerShell host stopped'));
         if (!proc)
             return;
         try {
@@ -126,14 +149,31 @@ export class PowerShellHost {
         if (started)
             return { ...started, cancelled: false, truncated: false };
         const id = 'f' + Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
-        const line = encodeHostRequest(id, script, env, this.protocol === 2
-            ? { v: 2, stdoutLimit: limits?.stdoutLimit, stderrLimit: limits?.stderrLimit }
+        const resolvedLimits = { ...limits };
+        if (resolvedLimits.stdoutMode === 'spool') {
+            resolvedLimits.stdoutSpoolPath = this.hostFile + '.' + id + '.stdout';
+        }
+        if (resolvedLimits.stderrMode === 'spool') {
+            resolvedLimits.stderrSpoolPath = this.hostFile + '.' + id + '.stderr';
+        }
+        if (resolvedLimits.stderrMode !== 'discard') {
+            resolvedLimits.nativeStderrSpoolPath = this.hostFile + '.' + id + '.native-stderr';
+        }
+        const nativeSpoolDir = this.hostFile + '.' + id + '.native';
+        mkdirSync(nativeSpoolDir);
+        const requestEnv = { ...env, FAUXNIX_NATIVE_SPOOL_DIR: nativeSpoolDir };
+        const line = encodeHostRequest(id, script, requestEnv, this.protocol === 2
+            ? {
+                v: 2,
+                ...resolvedLimits,
+            }
             : undefined);
         try {
             this.proc.stdin.write(line + '\n');
         }
         catch (e) {
             await this.deadRestart();
+            rmSync(nativeSpoolDir, { recursive: true, force: true });
             return {
                 stdout: Buffer.alloc(0),
                 stderr: Buffer.from('fauxnix: powershell host exited unexpectedly\n', 'utf8'),
@@ -152,14 +192,15 @@ export class PowerShellHost {
         signal?.addEventListener('abort', onAbort, { once: true });
         try {
             if (this.protocol === 2) {
-                return await this.collectV2(id, timeoutMs);
+                return await this.collectV2(id, timeoutMs, resolvedLimits);
             }
             const raw = await this.nextJsonLine(timeoutMs, id);
             const msg = decodeHostResponse(raw);
             const native = this.drainNativeStderr();
             return {
                 stdout: msg.stdout,
-                stderr: native.length ? Buffer.concat([msg.stderr, native]) : msg.stderr,
+                stderr: msg.stderr,
+                nativeStderr: native,
                 exitCode: msg.exitCode,
                 timedOut: false,
                 cancelled: false,
@@ -168,9 +209,12 @@ export class PowerShellHost {
         }
         catch (e) {
             const timedOut = e.timedOut === true;
+            const wasCancelled = cancelled || signal?.aborted === true;
+            const nativeSpoolError = e instanceof NativeStderrSpoolError ? e : null;
             await this.stop();
             this.drainNativeStderr();
-            if (cancelled || signal?.aborted)
+            this.removeRequestSpools(resolvedLimits);
+            if (wasCancelled)
                 return this.cancelledResult();
             if (timedOut) {
                 return {
@@ -182,10 +226,20 @@ export class PowerShellHost {
                     truncated: false,
                 };
             }
+            if (nativeSpoolError) {
+                return {
+                    stdout: Buffer.alloc(0),
+                    stderr: Buffer.from(nativeSpoolError.message + '\n', 'utf8'),
+                    exitCode: 1,
+                    timedOut: false,
+                    cancelled: false,
+                    truncated: false,
+                };
+            }
             if (this.closeErr && this.closeErr.code === 'ENOENT') {
                 return {
                     stdout: Buffer.alloc(0),
-                    stderr: Buffer.from(PS_MISSING_MESSAGE, 'utf8'),
+                    stderr: Buffer.from(powerShellMissingMessage(this.powerShell), 'utf8'),
                     exitCode: 127,
                     timedOut: false,
                     cancelled: false,
@@ -207,9 +261,27 @@ export class PowerShellHost {
         }
         finally {
             signal?.removeEventListener('abort', onAbort);
+            try {
+                rmSync(nativeSpoolDir, { recursive: true, force: true });
+            }
+            catch {
+                /* best effort; never mask the request result */
+            }
         }
     }
     async ensureStarted() {
+        if (this.powerShell.error) {
+            return {
+                stdout: Buffer.alloc(0),
+                stderr: Buffer.from(this.powerShell.error + '\n', 'utf8'),
+                exitCode: 127,
+                timedOut: false,
+                cancelled: false,
+                truncated: false,
+                spawnError: 'START',
+                spawnMessage: this.powerShell.error,
+            };
+        }
         if (this.proc && !this.closed)
             return null;
         if (!this.startLock)
@@ -223,7 +295,7 @@ export class PowerShellHost {
             if (err.code === 'ENOENT') {
                 return {
                     stdout: Buffer.alloc(0),
-                    stderr: Buffer.from(PS_MISSING_MESSAGE, 'utf8'),
+                    stderr: Buffer.from(powerShellMissingMessage(this.powerShell), 'utf8'),
                     exitCode: 127,
                     timedOut: false,
                     cancelled: false,
@@ -233,7 +305,7 @@ export class PowerShellHost {
             }
             return {
                 stdout: Buffer.alloc(0),
-                stderr: Buffer.from('fauxnix: failed to start powershell.exe: ' + err.message + '\n', 'utf8'),
+                stderr: Buffer.from('fauxnix: failed to start ' + this.powerShell.executable + ': ' + err.message + '\n', 'utf8'),
                 exitCode: 127,
                 timedOut: false,
                 cancelled: false,
@@ -259,7 +331,7 @@ export class PowerShellHost {
         await this.deadRestart();
         this.closed = false;
         writeFileSync(this.hostFile, '\ufeff' + hostBootstrapScript(), 'utf8');
-        const child = spawn('powershell.exe', [...PS_ARGS, '-File', this.hostFile], {
+        const child = spawn(this.powerShell.executable, [...POWERSHELL_ARGS, '-File', this.hostFile], {
             env: this.envFn(),
             stdio: ['pipe', 'pipe', 'pipe'],
             windowsHide: true,
@@ -273,7 +345,7 @@ export class PowerShellHost {
         child.stderr.on('data', (d) => {
             if (this.proc !== child)
                 return;
-            this.stderrChunks.push(d);
+            this.onNativeStderr(d);
         });
         child.on('error', (e) => {
             if (this.proc !== child)
@@ -393,13 +465,18 @@ export class PowerShellHost {
         err.timedOut = true;
         throw err;
     }
-    async collectV2(id, timeoutMs) {
+    async collectV2(id, timeoutMs, limits) {
         const deadline = Date.now() + timeoutMs;
         const out = [];
         const err = [];
         let outSeq = 0;
         let errSeq = 0;
         let end = null;
+        const nativePromise = this.beginNativeCapture(id, limits?.stderrMode ?? 'capture', limits?.stderrLimit ?? DEFAULT_STDERR_LIMIT, limits?.nativeStderrSpoolPath, timeoutMs + 2000);
+        // collectV2 can leave through a frame timeout before it reaches the await
+        // below. Attach a handler immediately so teardown never reports a stray
+        // promise rejection; the awaited path still receives the same failure.
+        void nativePromise.catch(() => undefined);
         while (!end) {
             const line = await this.nextLine(Math.max(1, deadline - Date.now()));
             if (!line.trim())
@@ -430,39 +507,224 @@ export class PowerShellHost {
                 end = f;
             }
         }
-        let native = Buffer.alloc(0);
+        let nativeBytes = 0;
+        let markerTimer;
         try {
-            native = Buffer.from(await this.waitNativeMarker(id, 2000));
+            const captured = await Promise.race([
+                nativePromise,
+                new Promise((_, reject) => {
+                    markerTimer = setTimeout(() => reject(new Error('fauxnix: native stderr marker missing')), 2000);
+                }),
+            ]);
+            nativeBytes = captured.bytesSeen;
         }
-        catch {
-            native = Buffer.from(this.drainNativeStderr());
+        catch (e) {
+            this.cancelNativeCapture();
+            if (e instanceof NativeStderrSpoolError)
+                throw e;
+        }
+        finally {
+            if (markerTimer)
+                clearTimeout(markerTimer);
         }
         const capturedErr = Buffer.from(Buffer.concat(err));
+        let native = Buffer.alloc(0);
+        let nativeTruncated = false;
+        const nativeSpool = limits?.nativeStderrSpoolPath;
+        if ((limits?.stderrMode ?? 'capture') === 'capture' && nativeSpool) {
+            const remaining = Math.max(0, (limits?.stderrLimit ?? DEFAULT_STDERR_LIMIT) - capturedErr.length);
+            const clipped = this.readUtf8Prefix(nativeSpool, remaining, nativeBytes);
+            native = Buffer.from(clipped.data);
+            nativeTruncated = clipped.truncated;
+            rmSync(nativeSpool, { force: true });
+        }
+        if (limits?.stderrMode === 'spool' && nativeSpool && nativeBytes === 0) {
+            rmSync(nativeSpool, { force: true });
+        }
         const n = Number(end.exitCode);
         return {
             stdout: Buffer.from(Buffer.concat(out)),
-            stderr: native.length ? Buffer.from(Buffer.concat([capturedErr, native])) : capturedErr,
+            stderr: capturedErr,
+            nativeStderr: native,
             exitCode: Number.isFinite(n) ? n : 0,
             timedOut: end.timedOut === true,
             cancelled: end.cancelled === true,
-            truncated: end.truncated === true,
+            truncated: end.truncated === true || nativeTruncated,
+            stdoutTruncated: end.stdoutTruncated === true,
+            stderrTruncated: end.stderrTruncated === true || nativeTruncated,
+            stdoutSpool: limits?.stdoutSpoolPath,
+            stderrSpool: limits?.stderrSpoolPath,
+            nativeStderrSpool: limits?.stderrMode === 'spool' && nativeBytes > 0 ? nativeSpool : undefined,
         };
     }
-    async waitNativeMarker(id, timeoutMs) {
-        const needle = Buffer.from('FAUXNIX_ERR_END:' + id + '\n', 'utf8');
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            const buf = Buffer.concat(this.stderrChunks);
-            const idx = buf.indexOf(needle);
-            if (idx >= 0) {
-                const before = buf.subarray(0, idx);
-                const after = buf.subarray(idx + needle.length);
-                this.stderrChunks = after.length ? [Buffer.from(after)] : [];
-                return Buffer.from(before);
+    beginNativeCapture(id, mode, limit, spoolPath, timeoutMs) {
+        this.cancelNativeCapture();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                if (this.nativeCapture?.id !== id)
+                    return;
+                const state = this.nativeCapture;
+                const failure = state.ioError ?? new Error('fauxnix: native stderr marker missing');
+                this.closeNativeSpool(state);
+                this.nativeCapture = null;
+                reject(failure);
+            }, timeoutMs);
+            let spoolFd;
+            let ioError;
+            if (mode !== 'discard' && spoolPath) {
+                try {
+                    spoolFd = openSync(spoolPath, 'w');
+                }
+                catch (e) {
+                    ioError = new NativeStderrSpoolError('open', spoolPath, e);
+                }
+            }
+            this.nativeCapture = {
+                id,
+                needle: Buffer.from('FAUXNIX_ERR_END:' + id + '\n', 'utf8'),
+                mode,
+                limit: Math.max(0, limit),
+                tail: Buffer.alloc(0),
+                spoolPath,
+                spoolFd,
+                bytesWritten: 0,
+                bytesSeen: 0,
+                ioError,
+                resolve,
+                reject,
+                timer,
+            };
+            if (this.stderrChunks.length) {
+                const pending = Buffer.concat(this.stderrChunks);
+                this.stderrChunks = [];
+                this.onNativeStderr(pending);
+            }
+        });
+    }
+    appendNativePayload(state, data) {
+        if (!data.length)
+            return;
+        state.bytesSeen += data.length;
+        if (state.ioError || state.mode === 'discard' || state.spoolFd === undefined)
+            return;
+        let retained = data;
+        if (state.mode === 'capture') {
+            const remaining = Math.max(0, state.limit + 3 - state.bytesWritten);
+            retained = data.subarray(0, remaining);
+        }
+        try {
+            let offset = 0;
+            while (offset < retained.length) {
+                const remaining = retained.length - offset;
+                const written = this.nativeSpoolWrite(state.spoolFd, retained, offset, remaining);
+                if (!Number.isInteger(written) || written <= 0 || written > remaining) {
+                    throw new Error('short write to native stderr spool');
+                }
+                offset += written;
+                state.bytesWritten += written;
+            }
+        }
+        catch (e) {
+            state.ioError = new NativeStderrSpoolError('write', state.spoolPath, e);
+            this.closeNativeSpool(state);
+        }
+    }
+    onNativeStderr(chunk) {
+        const state = this.nativeCapture;
+        if (!state) {
+            // Startup/teardown noise is diagnostic only. Keep a bounded tail so a
+            // noisy host cannot grow the resident Node process indefinitely.
+            const max = DEFAULT_STDERR_LIMIT;
+            const combined = Buffer.concat([...this.stderrChunks, chunk]);
+            this.stderrChunks = [Buffer.from(combined.subarray(Math.max(0, combined.length - max)))];
+            return;
+        }
+        const combined = state.tail.length ? Buffer.concat([state.tail, chunk]) : chunk;
+        const idx = combined.indexOf(state.needle);
+        if (idx >= 0) {
+            this.appendNativePayload(state, combined.subarray(0, idx));
+            const after = combined.subarray(idx + state.needle.length);
+            const ioError = state.ioError;
+            clearTimeout(state.timer);
+            this.closeNativeSpool(state);
+            this.nativeCapture = null;
+            if (after.length)
+                this.onNativeStderr(after);
+            if (ioError)
+                state.reject(ioError);
+            else
+                state.resolve({ bytesSeen: state.bytesSeen });
+            return;
+        }
+        const keep = Math.min(state.needle.length - 1, combined.length);
+        const emit = combined.length - keep;
+        if (emit > 0)
+            this.appendNativePayload(state, combined.subarray(0, emit));
+        state.tail = Buffer.from(combined.subarray(emit));
+    }
+    cancelNativeCapture() {
+        const state = this.nativeCapture;
+        if (!state)
+            return;
+        clearTimeout(state.timer);
+        this.appendNativePayload(state, state.tail);
+        const ioError = state.ioError;
+        this.closeNativeSpool(state);
+        this.nativeCapture = null;
+        state.reject(ioError ?? new Error('fauxnix: native stderr capture cancelled'));
+    }
+    closeNativeSpool(state) {
+        if (state.spoolFd === undefined)
+            return;
+        try {
+            closeSync(state.spoolFd);
+        }
+        catch {
+            /* already closed */
+        }
+        state.spoolFd = undefined;
+    }
+    readUtf8Prefix(file, limit, totalBytes = statSync(file).size) {
+        const size = statSync(file).size;
+        const wanted = Math.min(size, Math.max(0, limit) + 3);
+        const buf = Buffer.alloc(wanted);
+        if (wanted > 0) {
+            const fd = openSync(file, 'r');
+            try {
+                let offset = 0;
+                while (offset < wanted) {
+                    const n = readSync(fd, buf, offset, wanted - offset, offset);
+                    if (n <= 0)
+                        break;
+                    offset += n;
+                }
+            }
+            finally {
+                closeSync(fd);
+            }
+        }
+        let use = Math.min(limit, buf.length);
+        if (use < buf.length && use > 0 && (buf[use] & 0xc0) === 0x80) {
+            while (use > 0 && (buf[use] & 0xc0) === 0x80)
+                use--;
+        }
+        return { data: Buffer.from(buf.subarray(0, use)), truncated: totalBytes > use };
+    }
+    removeRequestSpools(limits) {
+        for (const file of [
+            limits.stdoutSpoolPath,
+            limits.stderrSpoolPath,
+            limits.nativeStderrSpoolPath,
+        ]) {
+            if (!file)
+                continue;
+            try {
+                rmSync(file, { force: true });
+            }
+            catch {
+                /* best effort; preserve the original transport error */
             }
-            await new Promise((r) => setTimeout(r, 15));
         }
-        throw new Error('fauxnix: native stderr marker missing');
     }
     failWaiters(err) {
         const ws = this.waiters.splice(0);

package/dist/qwen-launch.d.ts

@@ -0,0 +1,12 @@
+export type QwenLaunchTuple = {
+    command: string;
+    args: string[];
+};
+export declare function resolveQwenLaunchTuple(): {
+    ok: true;
+    value: QwenLaunchTuple;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function sameQwenLaunchTuple(value: unknown, expected: QwenLaunchTuple): boolean;

package/dist/qwen-launch.js

@@ -0,0 +1,29 @@
+import { existsSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export function resolveQwenLaunchTuple() {
+    const command = process.execPath;
+    const entry = fileURLToPath(new URL('../dist/index.js', import.meta.url));
+    if (!isAbsolute(command) || !existsSync(command)) {
+        return {
+            ok: false,
+            reason: 'cannot locate the Node.js executable; reinstall Node.js, then retry `fauxnix install --qwen`',
+        };
+    }
+    if (!isAbsolute(entry) || !existsSync(entry)) {
+        return {
+            ok: false,
+            reason: `cannot locate the built fauxnix entry at ${entry}; run \`npm run build\` or reinstall fauxnix-cli, then retry \`fauxnix install --qwen\``,
+        };
+    }
+    return { ok: true, value: { command, args: [entry, 'mcp'] } };
+}
+export function sameQwenLaunchTuple(value, expected) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const rec = value;
+    return (rec.command === expected.command &&
+        Array.isArray(rec.args) &&
+        rec.args.length === expected.args.length &&
+        rec.args.every((part, index) => part === expected.args[index]));
+}

package/dist/registry.d.ts

@@ -32,6 +32,8 @@ export interface PipelineCtx {
     position: 'first' | 'middle' | 'last';
     /** True when stdin is available (piped input or `< file` redirect). */
     hasStdin: boolean;
+    /** Whether translation is preparing an executable plan or only rendering it. */
+    translationMode?: 'execute' | 'pure';
 }
 export type Handler = (args: Word[], ctx: PipelineCtx) => string;
 export declare function register(name: string, handler: Handler): void;
@@ -103,6 +105,26 @@ export interface CommandSpec {
     leadingOptions?: boolean;
     handler: Handler;
 }
+/**
+ * C-5's curated agent-daily command set. Keep this explicit: a raw count of
+ * CommandSpecs is not enough to prove that the commands agents use every day
+ * are the ones protected by fail-loud option validation.
+ */
+export declare const AGENT_DAILY_60: readonly ["basename", "cat", "cd", "chmod", "chown", "clear", "command", "cp", "cut", "date", "df", "diff", "dirname", "du", "echo", "env", "export", "file", "free", "grep", "groups", "gunzip", "gzip", "head", "hostname", "id", "ll", "ln", "ls", "mkdir", "mktemp", "mv", "nproc", "printenv", "printf", "ps", "pwd", "readlink", "realpath", "rm", "rmdir", "sleep", "sort", "stat", "tail", "tee", "timeout", "touch", "tr", "type", "uname", "uniq", "unset", "unzip", "uptime", "wc", "which", "whoami", "zcat", "zip"];
+/** Commands deliberately kept outside generic CommandSpec option walking. */
+export declare const COMMAND_SPEC_EXCLUSIONS: readonly [{
+    readonly names: readonly ["find"];
+    readonly reason: "option-looking predicates are parsed by the find expression compiler; generic short-option bundling would misread -name";
+}, {
+    readonly names: readonly ["sed", "awk"];
+    readonly reason: "program text and option grammar require command-specific parsing; any remaining unchecked options must be fixed there rather than treated as generic flags";
+}, {
+    readonly names: readonly ["egrep"];
+    readonly reason: "semantic alias injects grep -E through its own handler; it must not be wrapped as an independent generic option parser";
+}, {
+    readonly names: readonly ["tar"];
+    readonly reason: "argv is passed to Windows bsdtar; rejecting unlisted GNU/bsdtar options before native dispatch would reduce compatibility";
+}];
 /** Register a spec'd command. Unknown/unsupported options become GNU-style usage errors. */
 export declare function registerSpec(spec: CommandSpec): void;
 export declare function registerSpecs(list: CommandSpec[]): void;