feat(docs): WIP migrate platform overview to next version

src/styles/index.css

@@ -2,6 +2,7 @@
 @import url('./_base.css');
 @import url('./theme/_navbar.css');
 @import url('./theme/_footer.css');
+@import url('./theme/_sidebar.css');
 @import url('./theme/_badge.css');
 @import url('./theme/_button.css');
 @import url('./theme/_hubspot.css');

src/styles/theme/_sidebar.css

@@ -0,0 +1,35 @@
+/* Sidebar */
+
+.sidebar-divider {
+  border-top: 1px;
+  display: block;
+  margin: 1.25rem 0rem 0rem 0rem;
+}
+
+html[data-theme='dark'] .sidebar-divider {
+  border-top: 1px solid var(--ifm-color-gray-800);
+}
+
+.sidebar-title {
+  font-size: 0.8rem;
+  letter-spacing: 0.05rem;
+  text-transform: uppercase;
+  font-weight: 600;
+  color: var(--ifm-color-gray-600);
+}
+
+.sidebar-submenu {
+  padding-left: 15px;
+}
+
+html[data-theme='dark'] .sidebar-divider {
+  color: var(--ifm-color-gray-200);
+}
+
+@media only screen and (max-width: 998px) {
+  .sidebar-title {
+    margin-left: 1rem;
+  }
+}
+
+/* end sidebar */

versioned_docs/version-next/index.mdx

@@ -0,0 +1,9 @@
+---
+title: "What is wasmCloud?"
+---
+
+import { WhatIsWasmCloudSwitcher } from '@site/src/pages/_index/_components/what-is-wasmcloud';
+
+wasmCloud is an open source project from the Cloud Native Computing Foundation (CNCF) that enables teams to build polyglot applications composed of reusable Wasm components and run them—resiliently and efficiently—across any cloud, Kubernetes, datacenter, or edge.
+
+<WhatIsWasmCloudSwitcher />

versioned_docs/version-next/overview/components.mdx

@@ -0,0 +1,74 @@
+---
+title: 'Components'
+date: 2025-09-24T00:00:00+00:00
+icon: 'ti-anchor' # themify icon pack : https://themify.me/themify-icons
+description: 'Portable, sandboxed, polyglot workloads'
+type: 'docs'
+---
+
+## Overview
+
+**Components** are portable, interoperable WebAssembly binaries (`.wasm` files) that implement stateless logic. In wasmCloud, components typically enact the core logic of an application (for example, the API for a web application), while leaving abstracted, reusable **capabilities** such as key-value storage to [**extensions**](./extensions.mdx).
+
+In wasmCloud usage and documentation, the term **"component"** simply refers to a standard WebAssembly component. The wasmCloud platform provides a way to run components distributedly, while the Wasm Shell (`wash`) CLI helps developers build and publish components.
+
+## Features of components
+
+Components may be compiled from a variety of languages including Rust, Go, Python, JavaScript, and more. Because components can be compiled from many different languages and then interact with one another, they enable developers to break down language silos and utilize libraries and tooling in new ways. 
+
+![Compilation from a variety of languages](../images/compile.png)
+
+*Components can compile from a variety of languages and run across architectures. The [`wash build`](../wash/commands.mdx#wash-build) command can compile components from any language, leveraging language-specific toolchains.*
+
+Components are portable, interoperable, and composable:
+
+* **Portable**: Because WebAssembly binaries execute against a virtual instruction set architecture (essentially a tiny VM), they are agnostic to architecture and operating system kernel; they run anywhere there is a WebAssembly runtime. Component binaries are typically much smaller than analogous container images, as well—often measured in kilobytes—enabling them to run in resource-constrained environments where even containers aren't practical. 
+* **Interoperable**: Components can interact with one another over high-level APIs regardless of their respective languages of origin, so that a component written in Rust can utilize the functionality of a library from Go. 
+* **Composable**: Multiple components can be combined into a single binary (or dynamically linked at runtime in wasmCloud). This enables developers to build applications as if with construction bricks, satisfying dependencies with other components as needed.  
+
+Additionally, components are...
+
+#### Stateless
+
+When a component needs state, it uses an [extension](./extensions.mdx). Leaving state to extensions enables wasmCloud to orchestrate invocations in complex applications without regard to specific instances of components or where they're running.
+
+#### Secure
+
+Components are secure by default. Because WebAssembly components that can't use capabilities without mediation by the host, they are incapable of interacting with any operating system functionality on their own. The only way components can affect their external environment is through an explicitly permitted capability facilitated by a host or extension. 
+
+#### Reactive
+
+Components follow the principles of **[reactive programming](https://en.wikipedia.org/wiki/Reactive_programming)**: they only run when invoked by another entity. An invocation might originate from another component's function call, an extension, or a message from the [wasmCloud host](./hosts.mdx). In turn, components can invoke exposed functions on components, extensions, or the host.
+
+#### Connected by abstractions
+
+wasmCloud components are _loosely coupled_ with the extensions they use for non-functional requirements. A component doesn't communicate with **Redis** or **Cassandra** or **Consul**; instead it communicates with a generalized abstraction over the `keyvalue` interface.
+
+An [interface](./interfaces.mdx) represents an abstracted functionality. As long as an extension implements the correct interface, it's considered compatible with your component. A component written using the `keyvalue` interface should be able to work with _any_ key-value store. This decoupling also enables swapping the store at runtime without requiring a rebuild or redeploy. Learn more about wasmCloud's interface support on the [Interface](./interfaces.mdx) page.
+
+#### Internally single-threaded
+
+The surrounding environment of the [wasmCloud host](./hosts.mdx) may have varying levels of concurrency support. This support may differ depending on whether the host is running in a browser, on a constrained device, or in a VM somewhere. However, the code for components should be independent of these conditions and _never have to change_, even if the surrounding environment adopts a different concurrency model.
+
+:::info[Note]
+While it's nice not worrying about the underlying concurrency model, it's important to understand that single-threaded code has the potential to create bottlenecks. Therefore, when developing _message handlers_ for components, embrace the design of performing small amounts of work in a "get in and get out fast" approach. Divide the work into the smallest bits possible, and perform each bit as fast as possible. This approach maximizes the benefits of _external concurrency_ while still keeping the code simple and synchronous.
+:::
+
+#### Flat in hierarchy
+
+In a zero trust environment, allowing components to spawn others is a security risk. wasmCloud maintains the horizontal scale of components with an entirely flat hierarchy.
+
+## Open standards
+
+The wasmCloud project is committed to supporting a componentized ecosystem and remains up-to-date with the latest versions of the [Wasmtime](https://wasmtime.dev/) WebAssembly runtime and [WASI 0.2](https://github.com/WebAssembly/WASI/blob/main/preview2/README.md), a set of standard APIs designed to allow WebAssembly components to access external resources in a safe and portable way.
+
+Components are defined according to the [Component Model](https://github.com/WebAssembly/component-model), an open standard governed by the [W3C WebAssembly Community Group](https://www.w3.org/community/webassembly/) that describes a layer of specification in addition to that of a core WebAssembly module. 
+
+In principle, any language can compile code to a component; the maturity of compilers varies by language, and component tooling is developing rapidly since the release of WASI 0.2 in January 2024. You can find practical tooling for working with components in [Useful WebAssembly Tooling](../wash/developer-guide/useful-webassembly-tools.mdx).
+
+## Keep reading
+
+[Continue to learn more about extensions](./extensions.mdx), or...
+
+- Build and deploy a component in the [Quickstart](../quickstart/index.mdx).
+- Dig deeper on creating components in the [Developer Guide](../wash/developer-guide/index.mdx).

versioned_docs/version-next/overview/extensions.mdx

@@ -0,0 +1,11 @@
+---
+title: 'Extensions'
+date: 2025-09-24T00:00:00+00:00
+icon: 'ti-anchor' # themify icon pack : https://themify.me/themify-icons
+description: 'Host extensions that facilitate additional capabilities for components'
+type: 'docs'
+---
+
+:::warning[Under construction]
+This page is under active development.
+:::

versioned_docs/version-next/overview/hosts.mdx

@@ -0,0 +1,6 @@
+---
+title: "Hosts"
+---
+:::warning[Under construction]
+This page is under active development.
+:::

versioned_docs/version-next/overview/index.mdx

@@ -0,0 +1,36 @@
+---
+title: "Platform Overview"
+---
+
+**wasmCloud** is a suite of tooling that enables you to write code in your language of choice, compile code into portable, sandboxed WebAssembly (Wasm) components, and run those components anywhere—from your laptop to the edge to the cloud.
+
+## Who uses wasmCloud?
+
+The wasmCloud ecosystem includes tools for platform engineers, developers, and edge engineers who build and run Wasm components:
+
+* **Developers** use the [Wasm Shell (`wash`) CLI](../wash/get-started.mdx) to build Wasm components in languages such as Go, JavaScript (TypeScript), and Rust, and publish those components to OCI registries.
+* **Platform engineers** use standard cloud-native tooling like `kubectl` to build platforms for Wasm applications, leveraging a Kubernetes operator and Custom Resource Definitions (CRDs) that make it easy to run wasmCloud on Kubernetes. 
+* **Edge engineers** use the `wasmcloud` binary to run Wasm applications at the edge.
+
+![system context diagram](../images/wasmcloud-stack.png)
+
+In wasmCloud, workloads are comprised of **components** that make and respond to calls over **interfaces**:
+
+* [Components](./components.mdx) are portable, interoperable WebAssembly binaries that implement stateless logic.
+* [Interfaces](./interfaces.mdx)
+
+{/* ![component using logging and http interfaces]() */}
+
+Workloads run on **hosts** that can be extended with **extensions**:
+
+* [Hosts](./hosts.mdx) 
+* [Extensions](./extensions.mdx) 
+
+{/* ![expand diagram such that logging and http are fulfilled by host, new keyvalue is fulfilled by extension]() */}
+
+**Transport** and **scheduling**:
+
+* Transport
+* Scheduling
+
+{/* ![zoom out diagram to show multiple hosts with workloads scheduled via Kubernetes]() */}

versioned_docs/version-next/overview/interfaces.mdx

@@ -0,0 +1,7 @@
+---
+title: "Interfaces"
+---
+
+:::warning[Under construction]
+This page is under active development.
+:::

versioned_docs/version-next/quickstart/index.mdx

@@ -0,0 +1,7 @@
+---
+title: "Quickstart"
+---
+
+:::warning[Under construction]
+This page is under active development.
+:::

versioned_sidebars/version-next-sidebars.json

@@ -1,8 +1,126 @@
 {
-  "defaultSidebar": [
+    "mySidebar": [
     {
-      "type": "autogenerated",
-      "dirName": "."
-    }
-  ]
-}
+        "type": "html",
+        "className": "sidebar-title",
+        "value": "Get Started",
+        "defaultStyle": true
+    },
+        {
+            "type": "doc",
+            "label": "What is wasmCloud?",
+            "id": "index"
+        },
+        {
+            "type": "doc",
+            "label": "Quickstart",
+            "id": "quickstart/index"
+        },
+    {
+        "type": "html",
+        "value": "<span class='sidebar-divider'></span>"
+    },
+    {
+        "type": "html",
+        "className": "sidebar-title",
+        "value": "Platform",
+        "defaultStyle": true
+    },
+        {
+            "type": "category",
+            "label": "Overview",
+            "collapsible": true,
+            "link": {"type": "doc", "id": "overview/index"},
+            "items": [
+                {
+                    "type": "doc",
+                    "label": "Components",
+                    "id": "overview/components",
+                    "className": "sidebar-submenu"
+                },
+                {
+                    "type": "doc",
+                    "label": "Interfaces",
+                    "id": "overview/interfaces",
+                    "className": "sidebar-submenu"
+                },
+                {
+                    "type": "doc",
+                    "label": "Hosts",
+                    "id": "overview/hosts",
+                    "className": "sidebar-submenu"
+                },
+                {
+                    "type": "doc",
+                    "label": "Extensions",
+                    "id": "overview/extensions",
+                    "className": "sidebar-submenu"
+                }
+            ]
+        },
+        {
+            "type": "category",
+            "label": "Wasm Shell (wash) CLI",
+            "collapsible": true,
+            "items": [
+                {
+                    "type": "doc",
+                    "label": "Get Started",
+                    "id": "wash/get-started",
+                    "className": "sidebar-submenu"
+                },
+                {
+                    "type": "doc",
+                    "label": "Commands",
+                    "id": "wash/commands",
+                    "className": "sidebar-submenu"
+                },
+                {
+                    "type": "category",
+                    "label": "Developer Guide",
+                    "link": {"type": "doc", "id": "wash/developer-guide/index"},
+                    "collapsible": true,
+                    "items": [
+                        {
+                            "type": "doc",
+                            "label": "Building and Publishing WebAssembly Components",
+                            "id": "wash/developer-guide/build-and-publish",
+                            "className": "sidebar-submenu"
+                        },
+                        {
+                            "type": "doc",
+                            "label": "Useful WebAssembly Tools",
+                            "id": "wash/developer-guide/useful-webassembly-tools",
+                            "className": "sidebar-submenu"
+                        }
+            ]
+                },
+                {
+                    "type": "doc",
+                    "label": "Plugins",
+                    "id": "wash/plugins",
+                    "className": "sidebar-submenu"
+                },
+                {
+                    "type": "doc",
+                    "label": "Configuration",
+                    "id": "wash/config",
+                    "className": "sidebar-submenu"
+                },
+                {
+                    "type": "doc",
+                    "label": "Registries",
+                    "id": "wash/registries",
+                    "className": "sidebar-submenu"
+                },
+                {
+                    "type": "doc",
+                    "label": "FAQ",
+                    "id": "wash/faq",
+                    "className": "sidebar-submenu"
+                }
+            ]
+        }
+    ]
+  }
+