fauxnix-cli 0.7.1 → 0.9.0

package/dist/mcp.js

@@ -33,15 +33,46 @@ Output is formatted to look like GNU/Linux tooling (ls -l, ps aux, df -h ...), e
 
 Supported: pipes (|), && / || / ;, redirections (> >> 2> 2>&1 < /dev/null), variables ($VAR $HOME ~), command substitution $(...), and ${registeredNames().length}+ coreutils-style commands (${registeredNames().slice(0, 18).join(', ')}...).
 Unknown commands (git, node, npm, python, cargo...) are passed through and executed natively with argv-style quoting.
-Not supported: heredocs, while/until/case, background jobs. if/then/elif/else/fi, for-in loops, and word-level \$((...)) arithmetic expansion are supported.
+Not supported: heredocs, while/until/case, env -i/--ignore-environment, background jobs. if/then/elif/else/fi, for-in loops, and word-level \$((...)) arithmetic expansion are supported.
 
 CWD, environment variables, export/unset and cd persist across calls within this session — a resident PowerShell 5.1 host is started when the MCP session begins (and after reset), so the first bash tool call is already warm.
-Exit codes follow bash conventions (0 ok, 1 fail, 2 usage/serious, 127 command not found, 124 timeout).
+Exit codes follow bash conventions (0 ok, 1 fail, 2 usage/serious, 127 command not found, 124 timeout, 130 cancelled). The tool also returns structuredContent (schemaVersion 1) with stdout/stderr/exitCode/timedOut/cancelled/truncated/sessionId.
 
 Platform requirement: the execution backend is native Windows PowerShell 5.1+. On hosts without PowerShell on PATH (e.g. Linux containers/sandboxes), the bash tool returns exit code 127 with an actionable error instead of running the command.`;
+export function formatBashText(r) {
+    const parts = [];
+    if (r.stdout.length)
+        parts.push(r.stdout.replace(/\n$/, ''));
+    if (r.stderr.length)
+        parts.push(r.stderr.replace(/\n$/, ''));
+    if (r.cancelled)
+        parts.push('Cancelled');
+    else if (r.timedOut)
+        parts.push('Exit code: 124');
+    else if (r.exitCode !== 0)
+        parts.push('Exit code: ' + r.exitCode);
+    return parts.length ? parts.join('\n') : '(no output)';
+}
+export function bashToolResult(r, sessionId, infra) {
+    const structuredContent = {
+        schemaVersion: 1,
+        stdout: r.stdout,
+        stderr: r.stderr,
+        exitCode: r.exitCode,
+        timedOut: r.timedOut,
+        cancelled: r.cancelled,
+        truncated: r.truncated,
+        sessionId,
+    };
+    return {
+        content: [{ type: 'text', text: formatBashText(r) }],
+        structuredContent,
+        ...(infra ? { isError: true } : {}),
+    };
+}
 export async function startMcpServer() {
     const server = new McpServer({ name: 'fauxnix', version: packageVersion }, { capabilities: { tools: {} } });
-    let session = new FauxnixSession();
+    const session = new FauxnixSession();
     await session.prewarm();
     server.tool(TOOL_NAME, TOOL_DESCRIPTION, {
         command: z.string().describe('The bash-style command line to run'),
@@ -52,23 +83,26 @@ export async function startMcpServer() {
             .max(600_000)
             .optional()
             .describe('Timeout in milliseconds (default 120000)'),
-    }, EXEC_ANNOTATIONS, async ({ command, timeout_ms }) => {
+    }, EXEC_ANNOTATIONS, async ({ command, timeout_ms }, extra) => {
         try {
             const plans = translateCommandList(parseCommand(command));
-            const result = await session.run(plans, { timeoutMs: timeout_ms });
-            const parts = [];
-            if (result.stdout.trim())
-                parts.push(result.stdout.replace(/\n$/, ''));
-            if (result.stderr.trim())
-                parts.push(result.stderr.replace(/\n$/, ''));
-            if (result.exitCode !== 0)
-                parts.push('Exit code: ' + result.exitCode);
-            const text = parts.length ? parts.join('\n') : '(no output)';
-            return { content: [{ type: 'text', text }] };
+            const result = await session.run(plans, {
+                timeoutMs: timeout_ms,
+                signal: extra.signal,
+            });
+            const infra = result.spawnError === 'ENOENT' || result.spawnError === 'START';
+            return bashToolResult(result, session.id, infra);
         }
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
-            return { content: [{ type: 'text', text: msg }], isError: true };
+            return bashToolResult({
+                stdout: '',
+                stderr: msg,
+                exitCode: 2,
+                timedOut: false,
+                cancelled: false,
+                truncated: false,
+            }, session.id, true);
         }
     });
     server.tool('fauxnix_translate', 'Translate a bash-style command into the equivalent PowerShell script WITHOUT executing it. Useful for learning/debugging what fauxnix does under the hood.', { command: z.string().describe('The bash-style command line to translate (never executed)') }, TRANSLATE_ANNOTATIONS, async ({ command }) => {
@@ -90,18 +124,45 @@ export async function startMcpServer() {
             .describe('"status" shows the session state (cwd, tracked env keys); "reset" clears it back to a fresh shell'),
     }, SESSION_ANNOTATIONS, async ({ action }) => {
         if (action === 'reset') {
-            await session.dispose();
-            session = new FauxnixSession();
-            await session.prewarm();
+            await session.reset();
             return { content: [{ type: 'text', text: 'fauxnix: session reset' }] };
         }
         const envKeys = Object.keys(session.env).sort();
         const text = 'cwd: ' + (session.cwd ?? '(inherit from server start)') +
             '\nenv keys: ' + (envKeys.length ? envKeys.join(', ') : '(none tracked)') +
+            '\nsession: ' + session.id +
             '\ncommands registered: ' + registeredNames().length;
         return { content: [{ type: 'text', text }] };
     });
     const transport = new StdioServerTransport();
+    let shuttingDown = false;
+    const shutdown = async () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        await session.dispose();
+        try {
+            await server.close();
+        }
+        catch {
+            /* ignore */
+        }
+    };
+    process.stdin.on('end', () => {
+        void shutdown();
+    });
+    process.stdin.on('close', () => {
+        void shutdown();
+    });
+    process.on('SIGINT', () => {
+        void shutdown();
+    });
+    process.on('SIGTERM', () => {
+        void shutdown();
+    });
+    transport.onclose = () => {
+        void shutdown();
+    };
     await server.connect(transport);
 }
 // keep referenced for tree-shaking clarity

package/dist/parser.js

@@ -586,28 +586,62 @@ export function parseCommand(input) {
     let pos = 0;
     const peek = () => tokens[pos];
     const next = () => tokens[pos++];
+    const isListSep = (o) => o === ';' || o === '\n';
+    /** Consume `;` / newline / `&&` / `||`. Trailing `&&`/`||` and `;;` fail loud (bash). */
+    const consumeListOp = (stops) => {
+        const t = peek();
+        if (t.type !== 'OP')
+            return null;
+        if (!(t.op === '&&' || t.op === '||' || isListSep(t.op)))
+            return null;
+        if (t.op === ';') {
+            next();
+            if (peek().type === 'OP' && peek().op === ';') {
+                throw new FauxnixParseError("fauxnix: syntax error near unexpected token `;;'");
+            }
+            return ';';
+        }
+        if (t.op === '\n') {
+            next();
+            while (peek().type === 'OP' && peek().op === '\n')
+                next();
+            return ';';
+        }
+        const sep = t.op;
+        next();
+        while (peek().type === 'OP' && peek().op === '\n')
+            next();
+        const n = peek();
+        const kw = peekKw();
+        if (n.type === 'OP' && n.op === ';') {
+            throw new FauxnixParseError("fauxnix: syntax error near unexpected token `" + sep + "'");
+        }
+        if (n.type === 'EOF' || (stops && kw && stops.has(kw))) {
+            throw new FauxnixParseError(n.type === 'EOF'
+                ? 'fauxnix: syntax error: unexpected end of file after `' + sep + "'"
+                : "fauxnix: syntax error near unexpected token `" + sep + "'");
+        }
+        return sep;
+    };
     const parseList = () => {
         const segments = [];
         let op = ';';
-        const isListSep = (o) => o === ';' || o === '\n';
-        while (peek().type === 'OP' && isListSep(peek().op))
+        while (peek().type === 'OP' && isListSep(peek().op)) {
+            if (peek().op === ';' && tokens[pos + 1]?.type === 'OP' && tokens[pos + 1]?.op === ';') {
+                throw new FauxnixParseError("fauxnix: syntax error near unexpected token `;;'");
+            }
             next();
+        }
         while (peek().type !== 'EOF') {
             const pipeline = parsePipeline();
             segments.push({ pipeline, op });
-            const t = peek();
-            if (t.type === 'OP' && (t.op === '&&' || t.op === '||' || isListSep(t.op))) {
-                op = t.op === '\n' ? ';' : t.op;
-                next();
-                while (peek().type === 'OP' && isListSep(peek().op))
-                    next();
-            }
-            else if (t.type === 'EOF') {
-                break;
-            }
-            else {
+            const nextOp = consumeListOp();
+            if (nextOp === null) {
+                if (peek().type === 'EOF')
+                    break;
                 throw new FauxnixParseError('fauxnix: unexpected token after pipeline');
             }
+            op = nextOp;
         }
         if (segments.length === 0)
             throw new FauxnixParseError('fauxnix: empty command');
@@ -672,25 +706,22 @@ export function parseCommand(input) {
         const stop = new Set(stops);
         const segments = [];
         let op = ';';
-        const isListSep = (o) => o === ';' || o === '\n';
-        while (peek().type === 'OP' && isListSep(peek().op))
+        while (peek().type === 'OP' && isListSep(peek().op)) {
+            if (peek().op === ';' && tokens[pos + 1]?.type === 'OP' && tokens[pos + 1]?.op === ';') {
+                throw new FauxnixParseError("fauxnix: syntax error near unexpected token `;;'");
+            }
             next();
+        }
         while (peek().type !== 'EOF') {
             const kw = peekKw();
             if (kw && stop.has(kw))
                 break;
             const pipeline = parsePipeline();
             segments.push({ pipeline, op });
-            const t = peek();
-            if (t.type === 'OP' && (t.op === '&&' || t.op === '||' || isListSep(t.op))) {
-                op = t.op === '\n' ? ';' : t.op;
-                next();
-                while (peek().type === 'OP' && isListSep(peek().op))
-                    next();
-            }
-            else {
+            const nextOp = consumeListOp(stop);
+            if (nextOp === null)
                 break;
-            }
+            op = nextOp;
         }
         if (segments.length === 0) {
             throw new FauxnixParseError('fauxnix: empty command');

package/dist/ps-host.d.ts

@@ -1,16 +1,52 @@
 export declare const PS_MISSING_MESSAGE: string;
+export declare const DEFAULT_STDOUT_LIMIT = 8388608;
+export declare const DEFAULT_STDERR_LIMIT = 1048576;
 export interface HostInvokeResult {
     stdout: Buffer;
     stderr: Buffer;
     exitCode: number;
     timedOut: boolean;
+    cancelled: boolean;
+    truncated: boolean;
     spawnError?: 'ENOENT' | 'START';
     spawnMessage?: string;
 }
 export interface HostRequestEnv {
     [key: string]: string;
 }
-export declare function encodeHostRequest(id: string, script: string, env: HostRequestEnv): string;
+export declare function encodeHostRequest(id: string, script: string, env: HostRequestEnv, opts?: {
+    v?: number;
+    stdoutLimit?: number;
+    stderrLimit?: number;
+}): string;
+export type HostV2Frame = {
+    v: 2;
+    type: 'ready';
+    capabilities?: {
+        cancel?: boolean;
+        maxChunkBytes?: number;
+        stderrMarker?: boolean;
+    };
+} | {
+    v: 2;
+    type: 'stdout' | 'stderr';
+    id: string;
+    seq: number;
+    dataB64: string;
+} | {
+    v: 2;
+    type: 'end';
+    id: string;
+    exitCode: number;
+    timedOut?: boolean;
+    cancelled?: boolean;
+    truncated?: boolean;
+};
+export declare function parseHostLine(line: string): {
+    v1Ready?: boolean;
+    v2?: HostV2Frame;
+    v1?: ReturnType<typeof decodeHostResponse>;
+};
 export declare function decodeHostResponse(line: string): {
     id: string;
     stdout: Buffer;
@@ -36,11 +72,17 @@ export declare class PowerShellHost {
     private closed;
     private startLock;
     private invokeLock;
+    protocol: 1 | 2;
     constructor(hostFile: string, envFn: () => NodeJS.ProcessEnv);
     /** Start the resident process and wait for the ready handshake (B1 prewarm). */
     ready(): Promise<HostInvokeResult | null>;
-    invoke(script: string, env: HostRequestEnv, timeoutMs: number): Promise<HostInvokeResult>;
+    invoke(script: string, env: HostRequestEnv, timeoutMs: number, signal?: AbortSignal, limits?: {
+        stdoutLimit?: number;
+        stderrLimit?: number;
+    }): Promise<HostInvokeResult>;
+    drainNativeStderr(): Buffer;
     stop(): Promise<void>;
+    private cancelledResult;
     private invokeSerial;
     private ensureStarted;
     private deadRestart;
@@ -49,5 +91,7 @@ export declare class PowerShellHost {
     private nextLine;
     private nextReadyLine;
     private nextJsonLine;
+    private collectV2;
+    private waitNativeMarker;
     private failWaiters;
 }

package/dist/ps-host.js

@@ -6,12 +6,29 @@ 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 function encodeHostRequest(id, script, env) {
-    return JSON.stringify({
+export const DEFAULT_STDOUT_LIMIT = 8_388_608;
+export const DEFAULT_STDERR_LIMIT = 1_048_576;
+export function encodeHostRequest(id, script, env, opts) {
+    const body = {
         id,
         scriptB64: Buffer.from(script, 'utf8').toString('base64'),
         env,
-    });
+    };
+    if (opts?.v === 2) {
+        body.v = 2;
+        body.type = 'run';
+        body.stdoutLimit = opts.stdoutLimit ?? DEFAULT_STDOUT_LIMIT;
+        body.stderrLimit = opts.stderrLimit ?? DEFAULT_STDERR_LIMIT;
+    }
+    return JSON.stringify(body);
+}
+export function parseHostLine(line) {
+    const j = JSON.parse(line);
+    if (j && j.v === 2 && typeof j.type === 'string')
+        return { v2: j };
+    if (j && j.ready === true)
+        return { v1Ready: true };
+    return { v1: decodeHostResponse(line) };
 }
 export function decodeHostResponse(line) {
     const j = JSON.parse(line);
@@ -42,6 +59,7 @@ export class PowerShellHost {
     closed = false;
     startLock = null;
     invokeLock = Promise.resolve();
+    protocol = 1;
     constructor(hostFile, envFn) {
         this.hostFile = hostFile;
         this.envFn = envFn;
@@ -50,11 +68,18 @@ export class PowerShellHost {
     async ready() {
         return this.ensureStarted();
     }
-    async invoke(script, env, timeoutMs) {
-        const run = this.invokeLock.then(() => this.invokeSerial(script, env, timeoutMs));
+    async invoke(script, env, timeoutMs, signal, limits) {
+        const run = this.invokeLock.then(() => this.invokeSerial(script, env, timeoutMs, signal, limits));
         this.invokeLock = run.then(() => undefined, () => undefined);
         return run;
     }
+    drainNativeStderr() {
+        if (!this.stderrChunks.length)
+            return Buffer.alloc(0);
+        const b = Buffer.concat(this.stderrChunks);
+        this.stderrChunks = [];
+        return b;
+    }
     async stop() {
         const proc = this.proc;
         this.proc = null;
@@ -82,12 +107,28 @@ export class PowerShellHost {
             });
         });
     }
-    async invokeSerial(script, env, timeoutMs) {
+    cancelledResult() {
+        return {
+            stdout: Buffer.alloc(0),
+            stderr: Buffer.alloc(0),
+            exitCode: 130,
+            timedOut: false,
+            cancelled: true,
+            truncated: false,
+        };
+    }
+    async invokeSerial(script, env, timeoutMs, signal, limits) {
+        if (signal?.aborted) {
+            await this.stop();
+            return this.cancelledResult();
+        }
         const started = await this.ensureStarted();
         if (started)
-            return 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);
+        const line = encodeHostRequest(id, script, env, this.protocol === 2
+            ? { v: 2, stdoutLimit: limits?.stdoutLimit, stderrLimit: limits?.stderrLimit }
+            : undefined);
         try {
             this.proc.stdin.write(line + '\n');
         }
@@ -98,24 +139,48 @@ export class PowerShellHost {
                 stderr: Buffer.from('fauxnix: powershell host exited unexpectedly\n', 'utf8'),
                 exitCode: 1,
                 timedOut: false,
+                cancelled: false,
+                truncated: false,
                 spawnMessage: e.message,
             };
         }
+        let cancelled = false;
+        const onAbort = () => {
+            cancelled = true;
+            void this.stop();
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
         try {
+            if (this.protocol === 2) {
+                return await this.collectV2(id, timeoutMs);
+            }
             const raw = await this.nextJsonLine(timeoutMs, id);
             const msg = decodeHostResponse(raw);
+            const native = this.drainNativeStderr();
             return {
                 stdout: msg.stdout,
-                stderr: msg.stderr,
+                stderr: native.length ? Buffer.concat([msg.stderr, native]) : msg.stderr,
                 exitCode: msg.exitCode,
                 timedOut: false,
+                cancelled: false,
+                truncated: false,
             };
         }
         catch (e) {
             const timedOut = e.timedOut === true;
             await this.stop();
+            this.drainNativeStderr();
+            if (cancelled || signal?.aborted)
+                return this.cancelledResult();
             if (timedOut) {
-                return { stdout: Buffer.alloc(0), stderr: Buffer.alloc(0), exitCode: 124, timedOut: true };
+                return {
+                    stdout: Buffer.alloc(0),
+                    stderr: Buffer.alloc(0),
+                    exitCode: 124,
+                    timedOut: true,
+                    cancelled: false,
+                    truncated: false,
+                };
             }
             if (this.closeErr && this.closeErr.code === 'ENOENT') {
                 return {
@@ -123,6 +188,8 @@ export class PowerShellHost {
                     stderr: Buffer.from(PS_MISSING_MESSAGE, 'utf8'),
                     exitCode: 127,
                     timedOut: false,
+                    cancelled: false,
+                    truncated: false,
                     spawnError: 'ENOENT',
                 };
             }
@@ -134,8 +201,13 @@ export class PowerShellHost {
                     '\n', 'utf8'),
                 exitCode: code === 0 ? 1 : code,
                 timedOut: false,
+                cancelled: false,
+                truncated: false,
             };
         }
+        finally {
+            signal?.removeEventListener('abort', onAbort);
+        }
     }
     async ensureStarted() {
         if (this.proc && !this.closed)
@@ -154,6 +226,8 @@ export class PowerShellHost {
                     stderr: Buffer.from(PS_MISSING_MESSAGE, 'utf8'),
                     exitCode: 127,
                     timedOut: false,
+                    cancelled: false,
+                    truncated: false,
                     spawnError: 'ENOENT',
                 };
             }
@@ -162,6 +236,8 @@ export class PowerShellHost {
                 stderr: Buffer.from('fauxnix: failed to start powershell.exe: ' + err.message + '\n', 'utf8'),
                 exitCode: 127,
                 timedOut: false,
+                cancelled: false,
+                truncated: false,
                 spawnError: 'START',
                 spawnMessage: err.message,
             };
@@ -189,14 +265,26 @@ export class PowerShellHost {
             windowsHide: true,
         });
         this.proc = child;
-        child.stdout.on('data', (d) => this.onStdout(d));
-        child.stderr.on('data', (d) => this.stderrChunks.push(d));
+        child.stdout.on('data', (d) => {
+            if (this.proc !== child)
+                return;
+            this.onStdout(d);
+        });
+        child.stderr.on('data', (d) => {
+            if (this.proc !== child)
+                return;
+            this.stderrChunks.push(d);
+        });
         child.on('error', (e) => {
+            if (this.proc !== child)
+                return;
             this.closeErr = e;
             this.closed = true;
             this.failWaiters(e);
         });
         child.on('close', (c) => {
+            if (this.proc !== child)
+                return;
             this.closeCode = c;
             this.closed = true;
             this.proc = null;
@@ -204,10 +292,13 @@ export class PowerShellHost {
         });
         try {
             const readyLine = await this.nextReadyLine(READY_TIMEOUT_MS);
-            const msg = decodeHostResponse(readyLine);
-            if (!msg.ready) {
+            const parsed = parseHostLine(readyLine);
+            if (parsed.v2?.type === 'ready')
+                this.protocol = 2;
+            else if (parsed.v1Ready || decodeHostResponse(readyLine).ready)
+                this.protocol = 1;
+            else
                 throw new Error('fauxnix: powershell host handshake failed');
-            }
         }
         catch (e) {
             await this.stop();
@@ -267,8 +358,10 @@ export class PowerShellHost {
             if (!line.trim())
                 continue;
             try {
-                const msg = decodeHostResponse(line);
-                if (msg.ready)
+                const parsed = parseHostLine(line);
+                if (parsed.v2?.type === 'ready' || parsed.v1Ready)
+                    return line;
+                if (parsed.v1?.ready)
                     return line;
             }
             catch {
@@ -300,6 +393,77 @@ export class PowerShellHost {
         err.timedOut = true;
         throw err;
     }
+    async collectV2(id, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        const out = [];
+        const err = [];
+        let outSeq = 0;
+        let errSeq = 0;
+        let end = null;
+        while (!end) {
+            const line = await this.nextLine(Math.max(1, deadline - Date.now()));
+            if (!line.trim())
+                continue;
+            let parsed;
+            try {
+                parsed = parseHostLine(line);
+            }
+            catch {
+                continue;
+            }
+            const f = parsed.v2;
+            if (!f)
+                continue;
+            if (f.type === 'stdout' && f.id === id) {
+                if (f.seq !== outSeq)
+                    throw new Error('fauxnix: host stdout seq gap');
+                out.push(Buffer.from(f.dataB64 ?? '', 'base64'));
+                outSeq++;
+            }
+            else if (f.type === 'stderr' && f.id === id) {
+                if (f.seq !== errSeq)
+                    throw new Error('fauxnix: host stderr seq gap');
+                err.push(Buffer.from(f.dataB64 ?? '', 'base64'));
+                errSeq++;
+            }
+            else if (f.type === 'end' && f.id === id) {
+                end = f;
+            }
+        }
+        let native = Buffer.alloc(0);
+        try {
+            native = Buffer.from(await this.waitNativeMarker(id, 2000));
+        }
+        catch {
+            native = Buffer.from(this.drainNativeStderr());
+        }
+        const capturedErr = Buffer.from(Buffer.concat(err));
+        const n = Number(end.exitCode);
+        return {
+            stdout: Buffer.from(Buffer.concat(out)),
+            stderr: native.length ? Buffer.from(Buffer.concat([capturedErr, native])) : capturedErr,
+            exitCode: Number.isFinite(n) ? n : 0,
+            timedOut: end.timedOut === true,
+            cancelled: end.cancelled === true,
+            truncated: end.truncated === true,
+        };
+    }
+    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);
+            }
+            await new Promise((r) => setTimeout(r, 15));
+        }
+        throw new Error('fauxnix: native stderr marker missing');
+    }
     failWaiters(err) {
         const ws = this.waiters.splice(0);
         for (const w of ws) {