docs: replace juno dev with emulator or functions (#522)

* docs: replace juno dev with emulator or functions

Signed-off-by: David Dal Busco <david.dalbusco@outlook.com>

* chore: fmt

Signed-off-by: David Dal Busco <david.dalbusco@outlook.com>

* 📄 Update LLMs.txt snapshot for PR review

---------

Signed-off-by: David Dal Busco <david.dalbusco@outlook.com>
Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>

Author: peterpeterparker

.llms-snapshots/llms-full.txt

@@ -22,7 +22,7 @@ include_satellite!();
 
 ## Feature Selection
 
-When you run `juno dev eject`, all the available hooks and assertions are scaffolded in your `lib.rs` module. However, if you don’t have to implement all of them for example to improve readability or reduce unnecessary logic, you can selectively enable only the features you need.
+When you run `juno functions eject`, all the available hooks and assertions are scaffolded in your `lib.rs` module. However, if you don’t have to implement all of them for example to improve readability or reduce unnecessary logic, you can selectively enable only the features you need.
 
 To do this, disable the default features in your `Cargo.toml` and explicitly specify only the ones you want to use.
 

docs/build/functions/development/rust.mdx

@@ -24,15 +24,15 @@ If you start the emulator (see chapter below) in watch mode, your functions will
 
 ## Local Development
 
-For local development and testing, a sandbox environment is essential. You can establish this environment by running the CLI command `juno dev start`.
+For local development and testing, a sandbox environment is essential. You can establish this environment by running the CLI command `juno emulator start`.
 
 :::info
 
 Find more information about local development in the [documentation](../../guides/local-development.mdx).
 
 :::
 
-The local sandbox environment supports hot reloading. This means that the container will automatically redeploy your local Satellite each time `juno dev build` is executed and a new version is produced.
+The local sandbox environment supports hot reloading. This means that the container will automatically redeploy your local Satellite each time `juno functions build` is executed and a new version is produced.
 
 If you start the emulator with the `--watch` flag, it will also rebuild your functions automatically when changes are detected.
 
@@ -144,7 +144,7 @@ A quick reference for the most common CLI commands and deployment workflows when
 | Command(s)             | Scenario                                                                             |
 | ---------------------- | ------------------------------------------------------------------------------------ |
 | `juno functions eject` | Initializes your project for writing serverless functions.                           |
-| `juno dev start`       | Starts the emulator.                                                                 |
+| `juno emulator start`  | Starts the emulator.                                                                 |
 | `juno functions build` | Compiles your custom Satellite's code. Changes are automatically redeployed locally. |
 
 ### 🚀 Deployment Scenarios

docs/build/functions/lifecycle.md

@@ -15,5 +15,5 @@ Requires the Juno CLI to be available `npm i -g @junobuild/cli`
 :::
 
 ```bash
-juno dev start
+juno emulator start
 ```

docs/examples/components/how-to-start.mdx

@@ -7,7 +7,7 @@ npm i -g @junobuild/cli
 Once installed, start the local emulator:
 
 ```bash
-juno dev start
+juno emulator start
 ```
 
 Open the Console UI at [http://localhost:5866/](http://localhost:5866/).

docs/guides/components/emulator.mdx

@@ -9,5 +9,5 @@ import Cli from "../cli.mdx";
 At the root of your application, eject the Satellite if you haven't already used a template.
 
 ```bash
-juno dev eject
+juno functions eject
 ```

docs/guides/components/functions/setup.mdx

@@ -140,8 +140,8 @@ jobs:
       - name: Run emulator
         run: |
           set -e
-          juno dev start --headless &
-          juno dev wait
+          juno emulator start --headless &
+          juno emulator wait
           juno login --emulator --mode development --headless
           juno config --mode development --headless
 
@@ -176,8 +176,8 @@ So, how it works:
 
 - We start by checking out the code, installing Node.js, and running `npm ci` to install your project dependencies.
 - As mentioned, instead of the Juno GitHub Actions, we install the Juno CLI globally so we can use it in the next steps.
-- We then run the emulator using `juno dev start --headless`, which launches the `junobuild/satellite` Docker image (defined in the `juno.config`) in the background, and follow up with:
-  - `juno dev wait` to ensure the emulator is ready before continuing.
+- We then run the emulator using `juno emulator start --headless`, which launches the `junobuild/satellite` Docker image (defined in the `juno.config`) in the background, and follow up with:
+  - `juno emulator wait` to ensure the emulator is ready before continuing.
   - `juno login` sets up authentication against the emulator in headless mode. This way the CLI can operate the Satellite — required for the next step.
   - `juno config` applies the configuration and sets the collections required by the project.
 - Once everything is ready, we run the end-to-end tests via `npm run e2e:ci`. Replace with the command that runs your tests in headless mode.

docs/guides/e2e.md

@@ -13,8 +13,8 @@ Juno offers something most platforms don’t: a full local development environme
 | What              | How                                            |
 | ----------------- | ---------------------------------------------- |
 | Runtime supported | Docker or Podman                               |
-| Start emulator    | `juno dev start`                               |
-| Stop emulator     | `juno dev stop`                                |
+| Start emulator    | `juno emulator start`                          |
+| Stop emulator     | `juno emulator stop`                           |
 | Console UI URL    | [http://localhost:5866](http://localhost:5866) |
 
 ---
@@ -67,7 +67,7 @@ import Cli from "./components/cli.mdx";
 Then, in your project folder, start the local emulator with:
 
 ```bash
-juno dev start
+juno emulator start
 ```
 
 This will launch the emulator along with all the services needed to develop your project.
@@ -77,7 +77,7 @@ We recommend running this in a dedicated terminal window or tab, while your fron
 To stop the emulator, run:
 
 ```bash
-juno dev stop
+juno emulator stop
 ```
 
 :::note
@@ -137,7 +137,7 @@ When using the `junobuild/skylab` image, the Console UI becomes available by def
 http://localhost:5866/
 ```
 
-Once the emulator is running (`juno dev start`), visit this URL in your browser to explore the Console — where you can create and manage Satellites, and explore features like Datastore, Authentication, Storage, and more.
+Once the emulator is running (`juno emulator start`), visit this URL in your browser to explore the Console — where you can create and manage Satellites, and explore features like Datastore, Authentication, Storage, and more.
 
 ---
 

docs/guides/local-development.mdx

@@ -20,15 +20,15 @@ import Setup from "./components/functions/setup.mdx";
 In a new terminal window, kick off the emulator:
 
 ```bash
-juno dev start
+juno emulator start
 ```
 
 Now, your local development environment is up and running, ready for you to start coding.
 
 Once you're ready to see your changes in action, compile your code:
 
 ```bash
-juno dev build
+juno emulator build
 ```
 
 Changes are detected and automatically deployed, allowing you to test your custom code locally almost immediately.
@@ -99,7 +99,7 @@ async fn on_set_doc(context: OnSetDocContext) -> Result<(), String> {
 include_satellite!();
 ```
 
-As outlined in the [Quickstart](#quickstart) chapter, run `juno dev build` to compile and deploy the code locally.
+As outlined in the [Quickstart](#quickstart) chapter, run `juno emulator build` to compile and deploy the code locally.
 
 When testing this feature, if you wait a bit before calling the getter, unlike in the previous step, you should now receive the modified "hello: world checked" text set by the hook. This delay occurs because serverless Functions run fully asynchronously from the request-response between your frontend and the Satellite.
 

docs/guides/rust.mdx

@@ -20,7 +20,7 @@ import Setup from "./components/functions/setup.mdx";
 In a new terminal window, kick off the emulator:
 
 ```bash
-juno dev start --watch
+juno emulator start --watch
 ```
 
 Now, your local development environment is up and running, ready for you to start coding.