Start to Add WASM Support Again (#14418)

<!--
if this PR closes one or more issues, you can automatically link the PR
with
them by using one of the [*linking
keywords*](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword),
e.g.
- this PR should close #xxxx
- fixes #xxxx

you can also mention related issues, PRs or discussions!
-->

# Description
<!--
Thank you for improving Nushell. Please, check our [contributing
guide](../CONTRIBUTING.md) and talk to the core team before making major
changes.

Description of your pull request goes here. **Provide examples and/or
screenshots** if your changes affect the user experience.
-->
The [nushell/demo](https://github.com/nushell/demo) project successfully
demonstrated running Nushell in the browser using WASM. However, the
current version of Nushell cannot be easily built for the
`wasm32-unknown-unknown` target, the default for `wasm-bindgen`.

This PR introduces initial support for the `wasm32-unknown-unknown`
target by disabling OS-dependent features such as filesystem access, IO,
and platform/system-specific functionality. This separation is achieved
using a new `os` feature in the following crates:

 - `nu-cmd-lang`
 - `nu-command`
 - `nu-engine`
 - `nu-protocol`

The `os` feature includes all functionality that interacts with an
operating system. It is enabled by default, but can be disabled using
`--no-default-features`. All crates that depend on these core crates now
use `--no-default-features` to allow compilation for WASM.

To demonstrate compatibility, the following script builds all crates
expected to work with WASM. Direct user interaction, running external
commands, working with plugins, and features requiring `openssl` are out
of scope for now due to their complexity or reliance on C libraries,
which are difficult to compile and link in a WASM environment.

```nushell
[ # compatible crates
	"nu-cmd-base",
	"nu-cmd-extra",
	"nu-cmd-lang",
	"nu-color-config",
	"nu-command",
	"nu-derive-value",
	"nu-engine",
	"nu-glob",
	"nu-json",
	"nu-parser",
	"nu-path",
	"nu-pretty-hex",
	"nu-protocol",
	"nu-std",
	"nu-system",
	"nu-table",
	"nu-term-grid",
	"nu-utils",
	"nuon"
] | each {cargo build -p $in --target wasm32-unknown-unknown --no-default-features}
```

## Caveats
This PR has a few caveats:
1. **`miette` and `terminal-size` Dependency Issue**
`miette` depends on `terminal-size`, which uses `rustix` when the target
is not Windows. However, `rustix` requires `std::os::unix`, which is
unavailable in WASM. To address this, I opened a
[PR](https://github.com/eminence/terminal-size/pull/68) for
`terminal-size` to conditionally compile `rustix` only when the target
is Unix. For now, the `Cargo.toml` includes patches to:
    - Use my forked version of `terminal-size`.
- ~~Use an unreleased version of `miette` that depends on
`terminal-size@0.4`.~~

These patches are temporary and can be removed once the upstream changes
are merged and released.

2. **Test Output Adjustments**
Due to the slight bump in the `miette` version, one test required
adjustments to accommodate minor formatting changes in the error output,
such as shifted newlines.

# User-Facing Changes
<!-- List of all changes that impact the user experience here. This
helps us keep track of breaking changes. -->
This shouldn't break anything but allows using some crates for targeting
`wasm32-unknown-unknown` to revive the demo page eventually.

# Tests + Formatting
<!--
Don't forget to add tests that cover your changes.

Make sure you've run and fixed any issues with these commands:

- `cargo fmt --all -- --check` to check standard code formatting (`cargo
fmt --all` applies these changes)
- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used` to
check that you're using the standard code style
- `cargo test --workspace` to check that all tests pass (on Windows make
sure to [enable developer
mode](https://learn.microsoft.com/en-us/windows/apps/get-started/developer-mode-features-and-debugging))
- `cargo run -- -c "use toolkit.nu; toolkit test stdlib"` to run the
tests for the standard library

> **Note**
> from `nushell` you can also use the `toolkit` as follows
> ```bash
> use toolkit.nu # or use an `env_change` hook to activate it
automatically
> toolkit check pr
> ```
-->

- 🟢 `toolkit fmt`
- 🟢 `toolkit clippy`
- 🟢 `toolkit test`
- 🟢 `toolkit test stdlib`

I did not add any extra tests, I just checked that compiling works, also
when using the host target but unselecting the `os` feature.

# After Submitting
<!-- If your PR had any user-facing changes, update [the
documentation](https://github.com/nushell/nushell.github.io) after the
PR is merged, if necessary. This will help us keep the docs up to date.
-->
~~Breaking the wasm support can be easily done by adding some `use`s or
by adding a new dependency, we should definitely add some CI that also
at least builds against wasm to make sure that building for it keep
working.~~
I added a job to build wasm.

---------

Co-authored-by: Ian Manske <ian.manske@pm.me>

crates/nu-cmd-lang/src/core_commands/describe.rs

@@ -169,6 +169,7 @@ fn run(
                 let origin = match stream.source() {
                     ByteStreamSource::Read(_) => "unknown",
                     ByteStreamSource::File(_) => "file",
+                    #[cfg(feature = "os")]
                     ByteStreamSource::Child(_) => "external",
                 };
 

crates/nu-cmd-lang/src/core_commands/do_.rs

@@ -1,9 +1,8 @@
 use nu_engine::{command_prelude::*, get_eval_block_with_early_return, redirect_env};
-use nu_protocol::{
-    engine::Closure,
-    process::{ChildPipe, ChildProcess},
-    ByteStream, ByteStreamSource, OutDest,
-};
+#[cfg(feature = "os")]
+use nu_protocol::process::{ChildPipe, ChildProcess};
+use nu_protocol::{engine::Closure, ByteStream, ByteStreamSource, OutDest};
+
 use std::{
     io::{Cursor, Read},
     thread,
@@ -119,6 +118,13 @@ impl Command for Do {
         match result {
             Ok(PipelineData::ByteStream(stream, metadata)) if capture_errors => {
                 let span = stream.span();
+                #[cfg(not(feature = "os"))]
+                return Err(ShellError::DisabledOsSupport {
+                    msg: "Cannot create a thread to receive stdout message.".to_string(),
+                    span: Some(span),
+                });
+
+                #[cfg(feature = "os")]
                 match stream.into_child() {
                     Ok(mut child) => {
                         // Use a thread to receive stdout message.
@@ -196,6 +202,7 @@ impl Command for Do {
                         OutDest::Pipe | OutDest::PipeSeparate | OutDest::Value
                     ) =>
             {
+                #[cfg(feature = "os")]
                 if let ByteStreamSource::Child(child) = stream.source_mut() {
                     child.ignore_error(true);
                 }

crates/nu-cmd-lang/src/core_commands/ignore.rs

@@ -35,6 +35,7 @@ impl Command for Ignore {
         mut input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         if let PipelineData::ByteStream(stream, _) = &mut input {
+            #[cfg(feature = "os")]
             if let ByteStreamSource::Child(child) = stream.source_mut() {
                 child.ignore_error(true);
             }

crates/nu-cmd-lang/src/core_commands/version.rs

@@ -116,24 +116,30 @@ pub fn version(engine_state: &EngineState, span: Span) -> Result<PipelineData, S
         Value::string(features_enabled().join(", "), span),
     );
 
-    // Get a list of plugin names and versions if present
-    let installed_plugins = engine_state
-        .plugins()
-        .iter()
-        .map(|x| {
-            let name = x.identity().name();
-            if let Some(version) = x.metadata().and_then(|m| m.version) {
-                format!("{name} {version}")
-            } else {
-                name.into()
-            }
-        })
-        .collect::<Vec<_>>();
+    #[cfg(not(feature = "plugin"))]
+    let _ = engine_state;
 
-    record.push(
-        "installed_plugins",
-        Value::string(installed_plugins.join(", "), span),
-    );
+    #[cfg(feature = "plugin")]
+    {
+        // Get a list of plugin names and versions if present
+        let installed_plugins = engine_state
+            .plugins()
+            .iter()
+            .map(|x| {
+                let name = x.identity().name();
+                if let Some(version) = x.metadata().and_then(|m| m.version) {
+                    format!("{name} {version}")
+                } else {
+                    name.into()
+                }
+            })
+            .collect::<Vec<_>>();
+
+        record.push(
+            "installed_plugins",
+            Value::string(installed_plugins.join(", "), span),
+        );
+    }
 
     Ok(Value::record(record, span).into_pipeline_data())
 }