@caupulican/pi-adaptative 0.91.4 → 0.92.0

package/dist/core/tools/shell-session.js

@@ -22,10 +22,11 @@
  * process; the direct child's own exit is what unblocks the sentinel line, exactly like the
  * per-command backend and like bash's stdio inheritance above. The bounded consequence: a native
  * command's stderr no longer merges into the session's stdout pipe (there is no capturing pipeline
- * stage to merge it) — it arrives on the session's own stderr pipe instead, forwarded via
- * `onStderr` -> `onData` same as the shell's own diagnostics. PowerShell 5.1's habit of wrapping
- * redirected stderr text in a `NativeCommandError` record also disappears, which is an accuracy
- * improvement (the raw stderr bytes are reported, not a wrapped/duplicated rendering of them).
+ * stage to merge it) — it arrives on the session's own stderr pipe instead. A nonce-bearing barrier
+ * on that pipe joins it deterministically with the stdout completion frame before the command
+ * resolves. PowerShell 5.1's habit of wrapping redirected stderr text in a `NativeCommandError`
+ * record also disappears, which is an accuracy improvement (the raw stderr bytes are reported,
+ * not a wrapped/duplicated rendering of them).
  *
  * Kill semantics: timeout/abort/silence kill the WHOLE session process tree (a hung foreground
  * command cannot be killed individually without job control) and the next exec respawns a fresh
@@ -36,11 +37,17 @@ import { randomBytes } from "node:crypto";
 import { basename } from "node:path";
 import { createSilenceWatchdog } from "@caupulican/pi-agent-core/reliability";
 import { spawn } from "child_process";
-import { getShellConfig, getShellEnv } from "../../utils/shell.js";
+import { createPowerShellHostEnvironment, POWERSHELL_ARGS, POWERSHELL_BOOTSTRAP, POWERSHELL_SESSION_READY_MARKER, POWERSHELL_SESSION_STDERR_READY_MARKER, POWERSHELL_STDERR_BARRIER_LABEL, } from "../../utils/powershell-session-protocol.js";
+import { getPowerShellCandidateConfigs, getShellConfig, getShellEnv, POWERSHELL_STARTUP_PROBE_TIMEOUT_MS, } from "../../utils/shell.js";
+import { claimCliPowerShellWarmStart } from "./early-powershell-session.js";
 import { PersistentProcessCoordinator } from "./persistent-process-coordinator.js";
+export { POWERSHELL_SESSION_READY_MARKER, POWERSHELL_SESSION_STDERR_READY_MARKER, } from "../../utils/powershell-session-protocol.js";
 const SENTINEL_BYTE = 0x1e;
 /** Longest possible sentinel: "\n" + 0x1e + 16-hex nonce + ":" + exit code digits + 0x1e. */
 const SENTINEL_HOLDBACK_BYTES = 64;
+const MAX_STARTUP_DIAGNOSTIC_BYTES = 16 * 1024;
+const POWERSHELL_SESSION_READY_BYTES = Buffer.from(POWERSHELL_SESSION_READY_MARKER, "latin1");
+const POWERSHELL_SESSION_STDERR_READY_BYTES = Buffer.from(POWERSHELL_SESSION_STDERR_READY_MARKER, "latin1");
 function escapeSingleQuotesPosix(value) {
     return value.replace(/'/g, "'\\''");
 }
@@ -71,41 +78,6 @@ export function buildPowerShellWire(command, nonce, cdTo) {
         : command;
     return `${nonce} ${Buffer.from(body, "utf8").toString("base64")}\n`;
 }
-/**
- * PowerShell 5.1-compatible REPL bootstrap. Exit code mirrors `-Command` semantics as closely as
- * a loop can: a native command's $LASTEXITCODE wins, a terminating error forces 1, otherwise 0.
- * Passed as one direct `-Command` argument. `-EncodedCommand` makes PowerShell serialize host,
- * warning, and progress records as CLIXML on stderr whenever pipes are attached; Pi then sees
- * duplicate XML mixed into the same command's plain stdout. Node preserves this script as one
- * argv entry without involving cmd.exe quoting.
- *
- * The command runs as a bare `Invoke-Expression` (no `2>&1 | Out-Default` capture pipeline) — see
- * the module doc header for why: a native command's stdio handles are inherited directly by its
- * child process instead of being captured through a PowerShell-internal pipe, so the sentinel is
- * unblocked by the direct child's own exit rather than by any grandchild holding those handles.
- */
-const POWERSHELL_BOOTSTRAP = [
-    "$ProgressPreference = 'SilentlyContinue'",
-    "try { [Console]::OutputEncoding = [System.Text.Encoding]::UTF8 } catch {}",
-    "function global:__pi_complete_status([int]$Code) { $global:LASTEXITCODE = $Code }",
-    "$__pi_in = [Console]::In",
-    "while ($true) {",
-    "\t$__pi_line = $__pi_in.ReadLine()",
-    "\tif ($null -eq $__pi_line) { break }",
-    "\t$__pi_sp = $__pi_line.IndexOf(' ')",
-    "\tif ($__pi_sp -lt 1) { continue }",
-    "\t$__pi_nonce = $__pi_line.Substring(0, $__pi_sp)",
-    "\t$__pi_cmd = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($__pi_line.Substring($__pi_sp + 1)))",
-    "\t$global:LASTEXITCODE = $null",
-    "\t$__pi_thrown = $false",
-    "\t$__pi_succeeded = $false",
-    "\ttry { Invoke-Expression $__pi_cmd; $__pi_succeeded = $? } catch { $__pi_thrown = $true; $__pi_msg = ($_ | Out-String).TrimEnd(); if ($__pi_msg) { [Console]::Out.WriteLine($__pi_msg) } }",
-    "\t$__pi_code = $global:LASTEXITCODE",
-    "\tif ($null -eq $__pi_code) { $__pi_code = if ($__pi_succeeded) { 0 } else { 1 } }",
-    "\tif ($__pi_thrown -and ($__pi_code -eq 0)) { $__pi_code = 1 }",
-    "\t[Console]::Out.Write(('{0}{1}{2}:{3}{1}' -f [char]10, [char]30, $__pi_nonce, $__pi_code))",
-    "}",
-].join("\n");
 function shallowEnvEquals(a, b) {
     const aKeys = Object.keys(a);
     const bKeys = Object.keys(b);
@@ -117,15 +89,38 @@ function shallowEnvEquals(a, b) {
     }
     return true;
 }
+function buildPowerShellEnvironmentPrelude(current, desired) {
+    const currentByName = new Map(Object.entries(current)
+        .filter((entry) => entry[1] !== undefined)
+        .map(([name, value]) => [name.toLowerCase(), { name, value }]));
+    const desiredByName = new Map(Object.entries(desired)
+        .filter((entry) => entry[1] !== undefined)
+        .map(([name, value]) => [name.toLowerCase(), { name, value }]));
+    const setValues = [...desiredByName.entries()].flatMap(([identity, entry]) => currentByName.get(identity)?.value === entry.value ? [] : [entry]);
+    const removeNames = [...currentByName.entries()].flatMap(([identity, entry]) => desiredByName.has(identity) ? [] : [entry.name]);
+    if (setValues.length === 0 && removeNames.length === 0)
+        return null;
+    const encoded = Buffer.from(JSON.stringify({ setValues, removeNames }), "utf8").toString("base64");
+    return [
+        `$__pi_env_delta = ConvertFrom-Json ([System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('${encoded}')))`,
+        "foreach ($__pi_env_item in @($__pi_env_delta.setValues)) { [System.Environment]::SetEnvironmentVariable([string]$__pi_env_item.name, [string]$__pi_env_item.value, 'Process') }",
+        "foreach ($__pi_env_name in @($__pi_env_delta.removeNames)) { [System.Environment]::SetEnvironmentVariable([string]$__pi_env_name, $null, 'Process') }",
+        "Remove-Variable -Name __pi_env_delta,__pi_env_item,__pi_env_name -ErrorAction SilentlyContinue",
+    ].join("\n");
+}
 export class PersistentShellSession {
-    constructor(key, kind) {
+    constructor(key, kind, options = {}) {
         this.coordinator = new PersistentProcessCoordinator();
         this.childEnv = null;
         this.lastRequestedCwd = null;
         this.activeExec = null;
+        this.rejectStartup = null;
         this.disposed = false;
         this.key = key;
         this.kind = kind;
+        this.resolvePowerShellCandidates = options.resolvePowerShellCandidates ?? getPowerShellCandidateConfigs;
+        this.spawnProcess = options.spawn ?? spawn;
+        this.startupTimeoutMs = options.startupTimeoutMs ?? POWERSHELL_STARTUP_PROBE_TIMEOUT_MS;
     }
     get sessionKind() {
         return this.kind;
@@ -134,10 +129,37 @@ export class PersistentShellSession {
     exec(command, cwd, options) {
         return this.coordinator.runSerialized(() => this.execNow(command, cwd, options));
     }
+    /** Start and validate the long-lived shell before the first user command. Idempotent per session. */
+    prewarm(cwd, env = getShellEnv()) {
+        return this.coordinator.runSerialized(async () => {
+            if (this.disposed)
+                throw new Error(`Shell session "${this.key}" is disposed`);
+            const resolvedEnv = this.kind === "powershell" ? createPowerShellHostEnvironment(env) : env;
+            if (this.kind !== "powershell" &&
+                this.coordinator.child &&
+                this.childEnv &&
+                !shallowEnvEquals(this.childEnv, resolvedEnv)) {
+                this.killChild();
+            }
+            if (!this.coordinator.child)
+                await this.spawnChild(cwd, resolvedEnv);
+            if (this.kind === "powershell" &&
+                this.childEnv &&
+                (!shallowEnvEquals(this.childEnv, resolvedEnv) || this.lastRequestedCwd !== cwd)) {
+                const result = await this.execNow("", cwd, { onData: () => { }, env: resolvedEnv });
+                if (result.exitCode !== 0) {
+                    this.killChild();
+                    throw new Error(`PowerShell session reconciliation failed with exit code ${result.exitCode ?? "null"}`);
+                }
+            }
+            this.coordinator.setLoopRef(false);
+        });
+    }
     dispose() {
         if (this.disposed)
             return;
         this.disposed = true;
+        this.rejectStartup?.(new Error(`Shell session "${this.key}" is disposed`));
         this.activeExec?.fail(new Error(`Shell session "${this.key}" is disposed`));
         this.coordinator.dispose();
         this.resetChildState();
@@ -147,35 +169,50 @@ export class PersistentShellSession {
             throw new Error(`Shell session "${this.key}" is disposed`);
         if (signal?.aborted)
             throw new Error("aborted");
-        const resolvedEnv = env ?? getShellEnv();
+        const requestedEnv = env ?? getShellEnv();
+        const resolvedEnv = this.kind === "powershell" ? createPowerShellHostEnvironment(requestedEnv) : requestedEnv;
         // The environment is spawn-time shell config: an env that differs from the running
         // session's (e.g. a spawn hook rewriting it per command) requires a fresh shell.
-        if (this.coordinator.child && this.childEnv && !shallowEnvEquals(this.childEnv, resolvedEnv)) {
+        if (this.kind !== "powershell" &&
+            this.coordinator.child &&
+            this.childEnv &&
+            !shallowEnvEquals(this.childEnv, resolvedEnv)) {
             this.killChild();
         }
         // Re-enter the host-requested cwd only when it CHANGES between calls; an unchanged
         // request preserves the agent's own in-session `cd` (that persistence is the feature).
         let cdTo = null;
-        if (!this.coordinator.child) {
-            this.spawnChild(cwd, resolvedEnv);
-        }
-        else if (this.lastRequestedCwd !== cwd) {
+        if (!this.coordinator.child)
+            await this.spawnChild(cwd, resolvedEnv);
+        if (this.lastRequestedCwd !== cwd)
             cdTo = cwd;
-        }
         this.lastRequestedCwd = cwd;
+        let resolvedCommand = command;
+        if (this.kind === "powershell" && this.childEnv && !shallowEnvEquals(this.childEnv, resolvedEnv)) {
+            const environmentPrelude = buildPowerShellEnvironmentPrelude(this.childEnv, resolvedEnv);
+            if (environmentPrelude)
+                resolvedCommand = `${environmentPrelude}\n${command}`;
+            this.childEnv = { ...resolvedEnv };
+        }
         const child = this.coordinator.child;
         if (!child?.stdin || !child.stdout || !child.stderr) {
             this.killChild();
             throw new Error(`Failed to start ${this.kind} session`);
         }
         const nonce = randomBytes(8).toString("hex");
-        const wire = this.kind === "powershell" ? buildPowerShellWire(command, nonce, cdTo) : buildBashWire(command, nonce, cdTo);
+        const wire = this.kind === "powershell"
+            ? buildPowerShellWire(resolvedCommand, nonce, cdTo)
+            : buildBashWire(resolvedCommand, nonce, cdTo);
         const sentinelPrefix = Buffer.from(`\n\x1e${nonce}:`, "latin1");
+        const stderrBarrier = Buffer.from(`\x1e${nonce}:${POWERSHELL_STDERR_BARRIER_LABEL}\x1e\n`, "latin1");
         this.coordinator.setLoopRef(true);
         try {
             return await new Promise((resolve, reject) => {
                 let settled = false;
-                let pending = Buffer.alloc(0);
+                let stdoutPending = Buffer.alloc(0);
+                let stderrPending = Buffer.alloc(0);
+                let commandExitCode;
+                let stderrBarrierSeen = this.kind !== "powershell";
                 let timeoutTimer;
                 const silenceWatchdog = timeoutSeconds === undefined && silenceMs !== undefined && silenceMs > 0
                     ? createSilenceWatchdog({
@@ -202,51 +239,75 @@ export class PersistentShellSession {
                     this.killChild();
                     settle(() => reject(new Error("aborted")));
                 };
-                const emitPending = (upTo) => {
+                const emitStdoutPending = (upTo) => {
                     if (upTo <= 0)
                         return;
-                    onData(pending.subarray(0, upTo));
-                    pending = pending.subarray(upTo);
+                    onData(stdoutPending.subarray(0, upTo));
+                    stdoutPending = stdoutPending.subarray(upTo);
+                };
+                const emitStderrPending = (upTo) => {
+                    if (upTo <= 0)
+                        return;
+                    onData(stderrPending.subarray(0, upTo));
+                    stderrPending = stderrPending.subarray(upTo);
+                };
+                const resolveWhenComplete = () => {
+                    const exitCode = commandExitCode;
+                    if (exitCode === undefined || !stderrBarrierSeen)
+                        return;
+                    settle(() => resolve({ exitCode }));
                 };
                 this.activeExec = {
                     onStdout: (data) => {
                         silenceWatchdog?.touch();
-                        pending = pending.length === 0 ? data : Buffer.concat([pending, data]);
-                        const prefixIndex = pending.indexOf(sentinelPrefix);
+                        if (commandExitCode !== undefined) {
+                            onData(data);
+                            return;
+                        }
+                        stdoutPending = stdoutPending.length === 0 ? data : Buffer.concat([stdoutPending, data]);
+                        const prefixIndex = stdoutPending.indexOf(sentinelPrefix);
                         if (prefixIndex !== -1) {
-                            const closeIndex = pending.indexOf(SENTINEL_BYTE, prefixIndex + sentinelPrefix.length);
+                            const closeIndex = stdoutPending.indexOf(SENTINEL_BYTE, prefixIndex + sentinelPrefix.length);
                             if (closeIndex !== -1) {
-                                const codeText = pending
+                                const codeText = stdoutPending
                                     .subarray(prefixIndex + sentinelPrefix.length, closeIndex)
                                     .toString("latin1");
-                                emitPending(prefixIndex);
+                                emitStdoutPending(prefixIndex);
+                                stdoutPending = stdoutPending.subarray(closeIndex - prefixIndex + 1);
+                                emitStdoutPending(stdoutPending.length);
                                 const parsed = Number.parseInt(codeText, 10);
-                                // Defer the settle by one microtask turn: with the bare Invoke-Expression
-                                // form a native command's stderr now arrives on the session's OWN stderr
-                                // pipe (see module doc header) instead of being pre-merged into the same
-                                // stdout bytes the sentinel rides on. Node fires already-queued stream
-                                // 'data' events in event-loop order; queueing the resolution behind a
-                                // microtask guarantees any stderr chunk the kernel delivered alongside (or
-                                // just before) this stdout chunk has already run its 'data' handler — and
-                                // thus reached `onData` — before the promise settles, so callers never see a
-                                // truncated stderr tail immediately after resolution.
-                                queueMicrotask(() => settle(() => resolve({ exitCode: Number.isNaN(parsed) ? null : parsed })));
+                                commandExitCode = Number.isNaN(parsed) ? null : parsed;
+                                resolveWhenComplete();
                                 return;
                             }
                         }
                         // Stream promptly but retain a tail large enough to hold any split sentinel.
-                        emitPending(pending.length - SENTINEL_HOLDBACK_BYTES);
+                        emitStdoutPending(stdoutPending.length - SENTINEL_HOLDBACK_BYTES);
                     },
                     onStderr: (data) => {
-                        // The command's stderr is merged into stdout at the shell; this pipe only
-                        // carries the session shell's own diagnostics. Forward for visibility.
                         silenceWatchdog?.touch();
-                        onData(data);
+                        if (this.kind !== "powershell" || stderrBarrierSeen) {
+                            onData(data);
+                            return;
+                        }
+                        stderrPending = stderrPending.length === 0 ? data : Buffer.concat([stderrPending, data]);
+                        const barrierIndex = stderrPending.indexOf(stderrBarrier);
+                        if (barrierIndex !== -1) {
+                            emitStderrPending(barrierIndex);
+                            stderrPending = stderrPending.subarray(stderrBarrier.length);
+                            emitStderrPending(stderrPending.length);
+                            stderrBarrierSeen = true;
+                            resolveWhenComplete();
+                            return;
+                        }
+                        // Preserve enough bytes to recognize a barrier split across chunks.
+                        emitStderrPending(stderrPending.length - stderrBarrier.length + 1);
                     },
                     onChildClose: (code) => {
                         // The command terminated the shell itself (e.g. `exit 3`) or the shell
                         // crashed: report its exit code like the per-command backend would.
-                        emitPending(pending.length);
+                        emitStdoutPending(stdoutPending.length);
+                        emitStderrPending(stderrPending.length);
                         settle(() => resolve({ exitCode: code }));
                     },
                     fail: (error) => {
@@ -274,20 +335,148 @@ export class PersistentShellSession {
             this.coordinator.setLoopRef(false);
         }
     }
-    spawnChild(cwd, env) {
-        const { shell } = getShellConfig(undefined, this.kind);
-        const args = this.kind === "powershell"
-            ? ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", POWERSHELL_BOOTSTRAP]
-            : basename(shell).toLowerCase().includes("bash")
-                ? ["--noprofile", "--norc"]
-                : [];
-        const child = spawn(shell, args, {
-            cwd,
-            env,
-            detached: process.platform !== "win32",
-            stdio: ["pipe", "pipe", "pipe"],
-            windowsHide: true,
+    async spawnChild(cwd, env) {
+        let spawnedCwd = cwd;
+        let spawnedEnv = env;
+        if (this.kind === "powershell") {
+            ({ cwd: spawnedCwd, env: spawnedEnv } = await this.spawnPowerShellChild(cwd, env));
+        }
+        else {
+            const { shell } = getShellConfig(undefined, this.kind);
+            const args = basename(shell).toLowerCase().includes("bash") ? ["--noprofile", "--norc"] : [];
+            const child = this.spawnProcess(shell, args, {
+                cwd,
+                env,
+                detached: process.platform !== "win32",
+                stdio: ["pipe", "pipe", "pipe"],
+                windowsHide: true,
+            });
+            this.attachReadyChild(child);
+        }
+        this.childEnv = { ...spawnedEnv };
+        this.lastRequestedCwd = spawnedCwd;
+    }
+    async spawnPowerShellChild(cwd, env) {
+        const warmStart = await claimCliPowerShellWarmStart();
+        if (warmStart) {
+            try {
+                this.attachReadyChild(warmStart.child);
+            }
+            finally {
+                warmStart.releaseStartupListeners();
+            }
+            return { cwd: warmStart.cwd, env: warmStart.env };
+        }
+        const failures = [];
+        for (const candidate of this.resolvePowerShellCandidates()) {
+            try {
+                await this.spawnPowerShellCandidate(candidate.shell, cwd, env);
+                return { cwd, env };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                failures.push(`${candidate.shell}: ${message}`);
+            }
+        }
+        const detail = failures.length > 0 ? ` Candidate failures: ${failures.join("; ")}` : "";
+        throw new Error(`PowerShell 7 (pwsh) was not found. Install pwsh before using the Windows shell.${detail}`);
+    }
+    spawnPowerShellCandidate(shell, cwd, env) {
+        return new Promise((resolve, reject) => {
+            let startupSettled = false;
+            let startupStdout = Buffer.alloc(0);
+            let startupStderr = Buffer.alloc(0);
+            let stdoutReady = false;
+            let stderrReady = false;
+            let timeoutTimer;
+            const settleStartup = (finish) => {
+                if (startupSettled)
+                    return;
+                startupSettled = true;
+                if (timeoutTimer)
+                    clearTimeout(timeoutTimer);
+                if (this.rejectStartup === rejectStartup)
+                    this.rejectStartup = null;
+                finish();
+            };
+            const startupDiagnostic = () => {
+                const combined = Buffer.concat([startupStdout, startupStderr]).toString("utf8").trim();
+                return combined ? `: ${combined}` : "";
+            };
+            const rejectStartup = (error) => {
+                settleStartup(() => reject(error));
+            };
+            const resolveWhenReady = () => {
+                if (!stdoutReady || !stderrReady)
+                    return;
+                settleStartup(resolve);
+            };
+            let child;
+            try {
+                child = this.spawnProcess(shell, [...POWERSHELL_ARGS, POWERSHELL_BOOTSTRAP], {
+                    cwd,
+                    env,
+                    detached: process.platform !== "win32",
+                    stdio: ["pipe", "pipe", "pipe"],
+                    windowsHide: true,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                rejectStartup(new Error(`spawn failed: ${message}`));
+                return;
+            }
+            this.rejectStartup = rejectStartup;
+            this.coordinator.attach(child, {
+                onStdout: (data) => {
+                    if (startupSettled) {
+                        this.activeExec?.onStdout(data);
+                        return;
+                    }
+                    startupStdout =
+                        startupStdout.length === 0
+                            ? data
+                            : Buffer.concat([startupStdout, data]).subarray(-MAX_STARTUP_DIAGNOSTIC_BYTES);
+                    stdoutReady ||= startupStdout.indexOf(POWERSHELL_SESSION_READY_BYTES) !== -1;
+                    resolveWhenReady();
+                },
+                onStderr: (data) => {
+                    if (startupSettled) {
+                        this.activeExec?.onStderr(data);
+                        return;
+                    }
+                    startupStderr =
+                        startupStderr.length === 0
+                            ? data
+                            : Buffer.concat([startupStderr, data]).subarray(-MAX_STARTUP_DIAGNOSTIC_BYTES);
+                    stderrReady ||= startupStderr.indexOf(POWERSHELL_SESSION_STDERR_READY_BYTES) !== -1;
+                    resolveWhenReady();
+                },
+                onError: (error) => {
+                    this.resetChildState();
+                    if (!startupSettled)
+                        rejectStartup(new Error(`${error.message}${startupDiagnostic()}`));
+                    else
+                        this.activeExec?.fail(error);
+                },
+                onClose: (code) => {
+                    this.resetChildState();
+                    if (!startupSettled) {
+                        rejectStartup(new Error(`exited with code ${code ?? "null"} before readiness${startupDiagnostic()}`));
+                    }
+                    else {
+                        this.activeExec?.onChildClose(code);
+                    }
+                },
+            });
+            timeoutTimer = setTimeout(() => {
+                this.coordinator.kill();
+                this.resetChildState();
+                rejectStartup(new Error(`startup timed out after ${this.startupTimeoutMs}ms${startupDiagnostic()}`));
+            }, this.startupTimeoutMs);
         });
+    }
+    attachReadyChild(child) {
         this.coordinator.attach(child, {
             onStdout: (data) => this.activeExec?.onStdout(data),
             onStderr: (data) => this.activeExec?.onStderr(data),
@@ -300,8 +489,6 @@ export class PersistentShellSession {
                 this.activeExec?.onChildClose(code);
             },
         });
-        this.childEnv = env;
-        this.lastRequestedCwd = cwd;
     }
     resetChildState() {
         this.childEnv = null;