Dryrun Deprecation Notice and Instructions

.gitignore

@@ -31,6 +31,14 @@ src/.vitepress/cache
 src/.vitepress/cache/deps
 src/.vitepress/dist
 
+# Auto-generated LLM documentation files (generated during build)
+src/public/llms.txt
+src/public/llms-full.txt
+src/public/ja/llms.txt
+src/public/ja/llms-full.txt
+src/public/zh/llms.txt
+src/public/zh/llms-full.txt
+
 wallet.json
 
 # Trunk

src/.vitepress/locales.js

@@ -54,6 +54,91 @@ export const localeConfig = (langCode) => ({
           },
         ],
       },
+      {
+        text: "Migrating to HyperBEAM",
+        items: [
+          {
+            text: "Getting Started",
+            collapsed: false,
+            items: [
+              {
+                text: "Why Migrate",
+                link: get_i18n_link(
+                  langCode,
+                  "/migrating-to-hyperbeam/why-migrate",
+                ),
+              },
+              {
+                text: "AOS CLI",
+                link: get_i18n_link(
+                  langCode,
+                  "/migrating-to-hyperbeam/aos-cli",
+                ),
+              },
+            ],
+          },
+          {
+            text: "Reading State",
+            collapsed: false,
+            items: [
+              {
+                text: "State Exposure",
+                link: get_i18n_link(
+                  langCode,
+                  "/migrating-to-hyperbeam/state-exposure",
+                ),
+              },
+              {
+                text: "Dynamic Reads",
+                link: get_i18n_link(
+                  langCode,
+                  "/migrating-to-hyperbeam/dynamic-reads",
+                ),
+              },
+              {
+                text: "User-Owned Processes",
+                link: get_i18n_link(
+                  langCode,
+                  "/migrating-to-hyperbeam/user-owned-processes",
+                ),
+              },
+            ],
+          },
+          {
+            text: "Building Applications",
+            collapsed: true,
+            items: [
+              {
+                text: "Web Serving",
+                link: get_i18n_link(
+                  langCode,
+                  "/migrating-to-hyperbeam/web-serving",
+                ),
+              },
+              {
+                text: "External Data",
+                link: get_i18n_link(
+                  langCode,
+                  "/migrating-to-hyperbeam/external-data",
+                ),
+              },
+            ],
+          },
+          {
+            text: "Developer Tools",
+            collapsed: true,
+            items: [
+              {
+                text: "JavaScript SDK",
+                link: get_i18n_link(
+                  langCode,
+                  "/migrating-to-hyperbeam/javascript-sdk",
+                ),
+              },
+            ],
+          },
+        ],
+      },
       {
         text: get_i18n_str(langCode, "tutorials"),
         link: get_i18n_link(langCode, "/tutorials/index"),
@@ -382,44 +467,6 @@ export const localeConfig = (langCode) => ({
               },
             ],
           },
-          {
-            text: "Migrating to HyperBEAM",
-            link: get_i18n_link(
-              langCode,
-              "/guides/migrating-to-hyperbeam/why-migrate",
-            ),
-            collapsed: true,
-            items: [
-              {
-                text: "Exposing State",
-                link: get_i18n_link(
-                  langCode,
-                  "/guides/migrating-to-hyperbeam/exposing-process-state",
-                ),
-              },
-              {
-                text: "Reading Dynamic State",
-                link: get_i18n_link(
-                  langCode,
-                  "/guides/migrating-to-hyperbeam/reading-dynamic-state",
-                ),
-              },
-              {
-                text: "Connecting with aos",
-                link: get_i18n_link(
-                  langCode,
-                  "/guides/migrating-to-hyperbeam/aos-with-hyperbeam",
-                ),
-              },
-              {
-                text: "ao-connect & HyperBEAM",
-                link: get_i18n_link(
-                  langCode,
-                  "/guides/migrating-to-hyperbeam/ao-connect",
-                ),
-              },
-            ],
-          },
           {
             text: "Additional Technologies",
             collapsed: true,
@@ -556,6 +603,20 @@ export const localeConfig = (langCode) => ({
               },
             ],
           },
+          {
+            text: "Deprecated Features",
+            collapsed: true,
+            items: [
+              {
+                text: "Overview",
+                link: get_i18n_link(langCode, "/references/deprecated/index"),
+              },
+              {
+                text: "Dry Run",
+                link: get_i18n_link(langCode, "/references/deprecated/dry-run"),
+              },
+            ],
+          },
           {
             text: get_i18n_str(langCode, "references-community"),
             link: get_i18n_link(langCode, "/references/community"),

src/guides/aoconnect/calling-dryrun.md

@@ -1,7 +1,17 @@
 # Calling DryRun
 
-::: warning DEPRECATION NOTICE
-This method of reading state is in the process of being deprecated for processes running on HyperBEAM. It is recommended to use the [State Patching mechanism](../migrating-to-hyperbeam/exposing-process-state.md) to expose state via HTTP for better performance, as calling `dryrun` was known to cause severe bottlenecks in web applications on `legacynet`.
+::: danger URGENT DEPRECATION NOTICE
+**Legacynet will stop supporting dry runs on October 10, 2025.** If you are running processes on Legacynet, you must take action now.
+
+This method of reading state is being deprecated for all processes. After deprecation, you have two options:
+
+1. **Recommended: Migrate to State Patching** - Use the [State Patching mechanism](../../migrating-to-hyperbeam/state-exposure.md) to expose state via HTTP for better performance. This is the recommended approach as `dryrun` was known to cause severe bottlenecks in web applications.
+
+2. **Alternative: Run Your Own HyperBEAM Node** - You can continue using dry runs by running your own HyperBEAM node infrastructure.
+
+**Exception for Token Processes**: If you have a token process, HyperBEAM can manage your balance state. You can still patch your token for improved performance.
+
+**Important for User-Owned Processes**: If your application spawns processes owned by users (not your app), users will need to patch their own processes. See the [User-Owned Processes guide](../../migrating-to-hyperbeam/user-owned-processes.md) for implementation strategies.
 :::
 
 DryRun is the process of sending a message object to a specific process and getting the Result object back, but the memory is not saved, it is perfect to create a read message to return the current value of memory. For example, a balance of a token, or a result of a transfer, etc. You can use DryRun to obtain an output without sending an actual message.

src/index.md

@@ -12,13 +12,13 @@ hero:
       link: /welcome/index
 
 features:
-  - title: AO-Core
+  - title: AO Core
     details: Learn about the protocol and standard that powers the AO computer.
     link: /welcome/ao-core-introduction
 
-  - title: AO Processes
+  - title: AO on HyperBEAM
     details: Build smart contracts and autonomous agents using AO Processes.
-    link: /welcome/ao-processes
+    link: /migrating-to-hyperbeam/why-migrate
 
   - title: HyperBEAM
     details: The future of AO, written in Erlang.

src/migrating-to-hyperbeam/aos-cli.md

@@ -0,0 +1,93 @@
+# AOS CLI
+
+Use the `aos` command-line interface to spawn and connect to processes on HyperBEAM mainnet.
+
+## Understanding Legacy vs. HyperBEAM
+
+AO is currently maintaining two networks during the transition to HyperBEAM:
+
+- **Legacy Network (aos)**: The current stable network that most existing processes run on
+- **HyperBEAM Mainnet (hyper-aos)**: The new high-performance network being built out
+
+HyperAOS represents the future direction of AOS on HyperBEAM, offering improved performance and new capabilities.
+
+## Installing `aos`
+
+The primary tool for interacting with AO and developing processes is `aos`, a command-line interface and development environment.
+
+::: code-group
+
+```bash [npm]
+npm i -g https://get_ao.arweave.net
+```
+
+```bash [pnpm]
+pnpm add -g https://get_ao.arweave.net
+```
+
+```bash [bun]
+# Bun is not supported yet
+# bun install -g https://get_ao.arweave.net
+```
+
+:::
+
+## Choosing Your Network
+
+After installing `aos`, when you spawn a new process you'll be presented with a selection menu:
+
+```bash
+aos myProcess
+```
+
+You'll see:
+
+```
+? Please select › - Use arrow-keys. Return to submit.
+❯   aos
+    hyper-aos (experimental - DO NOT USE FOR PRODUCTION)
+```
+
+### Legacy Network Process (aos)
+
+Select `aos` to spawn a process on the legacy network (default). This creates a standard AO process on the existing stable network, compatible with all current tooling and processes.
+
+### HyperBEAM Process (hyper-aos)
+
+Select `hyper-aos` to spawn a process directly on HyperBEAM. This is marked as **experimental** and should not be used for production workloads while HyperBEAM mainnet is being built out.
+
+:::warning Important
+The `hyper-aos` option is experimental and actively under development. Use `aos` (legacy network) for production processes.
+:::
+
+### Connecting to a Specific HyperBEAM Node
+
+You can also connect directly to a specific HyperBEAM node:
+
+```bash
+aos --url "https://forward.computer" myMainnetProcess
+```
+
+This connects you to an interactive Lua environment running within a **process** on the HyperBEAM network at the specified URL.
+
+:::info Running a Local HyperBEAM Node
+If you are running HyperBEAM locally and want to use that node when booting up `aos`, you must first start your local node with the genesis_wasm profile:
+
+```bash
+rebar3 as genesis_wasm shell
+```
+
+Then, you can connect `aos` to it:
+
+```bash
+aos --url "http://localhost:8734" myLocalProcess
+```
+
+Until `aos` is fully HyperBEAM native, the genesis_wasm profile is required to run a local Compute Unit (CU) for executing `aos`.
+:::
+
+## Interacting with Mainnet Processes
+
+:::warning Note on Blocking Calls
+Blocking message patterns, such as `Receive` and `ao.send().receive()`, are not available when running `aos` against a HyperBEAM process. HyperBEAM processes do not support the underlying `wasm` modules required for this functionality. You should rely on asynchronous patterns using handlers instead.
+:::

src/guides/migrating-to-hyperbeam/reading-dynamic-state.md → src/migrating-to-hyperbeam/dynamic-reads.md

@@ -1,14 +1,14 @@
-# Reading Dynamic State
+# Dynamic Reads
 
-Beyond reading static, cached state from your process, HyperBEAM allows you to perform on-the-fly computations on that state using Lua. This guide explains how to create and use "transformation functions" to return dynamic, computed data without altering the underlying state of your process.
+Dynamic reads enable on-the-fly computations on your process state using Lua transformation functions. These functions process cached state and return computed results without modifying the underlying data.
 
-This is a powerful pattern for creating efficient data APIs for your applications, reducing client-side logic, and minimizing data transfer.
+This pattern creates efficient data APIs by moving computation from clients to HyperBEAM nodes, reducing both network traffic and client-side complexity.
 
-This guide assumes you are already familiar with [exposing static process state](./exposing-process-state.md).
+This guide assumes you are already familiar with [state exposure](./state-exposure.md).
 
-## How it Works: The Lua Device
+## How Dynamic Reads Work
 
-The magic behind this is the `lua@5.3a` device, which can execute a Lua script against a message. In this pattern, we use a HyperBEAM URL (hashpath) to construct a pipeline:
+Dynamic reads leverage the `lua@5.3a` device to execute Lua scripts against cached state. The HyperBEAM URL constructs a processing pipeline:
 
 1.  First, we grab the latest state of an AO process.
 2.  Then, we pipe that state as the `base` message into the `lua@5.3a` device.