ci: binary-compat API baselines, multiplatform matrix CI, module docs

- Commit binary-compatibility-validator .api baselines for core + both modules. - Replace JVM-only CI with a matrix: Ubuntu runs JVM/JS(node)/Wasm(node)/Native + apiCheck; macOS runs the iOS simulator tests. - README: install + usage for tree-structure-serialization and -coroutines. - Update kotlin-js-store/yarn.lock for the new modules' JS test deps. Verified locally: JVM, JS(node), Wasm(node) and iOS-simulator tests pass for core + both modules; native compiles & links (exec runs on the Linux CI runner).
feat: Kotlin 2.x/K2, version catalog, serialization & coroutines modules, docs
2026-06-20 03:10:14 +02:00 · 2026-06-06 13:51:22 +02:00 · 2026-06-06 13:47:20 +02:00 · 2026-06-06 13:35:39 +02:00 · 2026-06-06 13:03:00 +02:00 · 2025-12-25 22:53:43 +01:00
43 changed files with 1845 additions and 968 deletions
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,11 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
-
-version: 2
-updates:
-  - package-ecosystem: "" # See documentation for possible values
-    directory: "/" # Location of package manifests
-    schedule:
-      interval: "weekly"
--- a/.github/workflows/publishRelease.yml
+++ b/.github/workflows/publishRelease.yml
@@ -18,21 +18,19 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Check out code
-        uses: actions/checkout@v2
-      - name: Set up JDK 11
-        uses: actions/setup-java@v2
+        uses: actions/checkout@v4
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4
        with:
-          distribution: adopt
-          java-version: 11
+          distribution: temurin
+          java-version: '21'

        # Runs upload, and then closes & releases the repository
      - name: Publish to MavenCentral
-        run: ./gradlew publish --max-workers 1
+        run: ./gradlew publishToMavenCentral
        env:
-          OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}
-          OSSRH_PASSWORD: ${{ secrets.OSSRH_PASSWORD }}
-          SIGNING_KEY_ID: ${{ secrets.SIGNING_KEY_ID }}
-          SIGNING_PASSWORD: ${{ secrets.SIGNING_PASSWORD }}
-          SIGNING_KEY: ${{ secrets.SIGNING_KEY }}
-          SONATYPE_STAGING_PROFILE_ID: ${{ secrets.SONATYPE_STAGING_PROFILE_ID }}
+          ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.MAVEN_CENTRAL_USERNAME }}
+          ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.MAVEN_CENTRAL_PASSWORD }}
+          ORG_GRADLE_PROJECT_signingInMemoryKey: ${{ secrets.SIGNING_KEY }}
+          ORG_GRADLE_PROJECT_signingInMemoryKeyPassword: ${{ secrets.SIGNING_PASSWORD }}
          SNAPSHOT: false
--- a/.github/workflows/publishSnapshot.yml
+++ b/.github/workflows/publishSnapshot.yml
@@ -1,35 +0,0 @@
-name: Publish Snapshot
-
-on:
-  push:
-    branches: [master]
-
-jobs:
-  test:
-    uses: ./.github/workflows/test.yml
-    secrets: inherit
-
-  publish:
-    needs: test
-    name: Publish Snapshot
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v2
-      - name: Set up JDK 11
-        uses: actions/setup-java@v2
-        with:
-          distribution: adopt
-          java-version: 11
-
-        # Runs upload, and then closes & releases the repository
-      - name: Publish to snapshot to Sonatype
-        run: ./gradlew publish --max-workers 1
-        env:
-          OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}
-          OSSRH_PASSWORD: ${{ secrets.OSSRH_PASSWORD }}
-          SIGNING_KEY_ID: ${{ secrets.SIGNING_KEY_ID }}
-          SIGNING_PASSWORD: ${{ secrets.SIGNING_PASSWORD }}
-          SIGNING_KEY: ${{ secrets.SIGNING_KEY }}
-          SONATYPE_STAGING_PROFILE_ID: ${{ secrets.SONATYPE_STAGING_PROFILE_ID }}
-          SNAPSHOT: true
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -6,18 +6,26 @@ on:
  workflow_call:

 jobs:
-  build:
-    name: Run unit tests
-    runs-on: ubuntu-latest
+  test:
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: JVM / JS / Wasm / Native + API check
+            os: ubuntu-latest
+            tasks: jvmTest jsNodeTest wasmJsNodeTest nativeTest apiCheck
+          - name: iOS
+            os: macos-latest
+            tasks: iosSimulatorArm64Test
    steps:
      - name: Check out code
-        uses: actions/checkout@v2
-      - name: Set up JDK 11
-        uses: actions/setup-java@v2
+        uses: actions/checkout@v4
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4
        with:
-          distribution: adopt
-          java-version: 11
-
-        # Builds the release artifacts of the library
+          distribution: temurin
+          java-version: '21'
      - name: Test
-        run: ./gradlew test
+        run: ./gradlew ${{ matrix.tasks }} --console=plain
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,7 @@
 /.idea/assetWizardSettings.xml
 .DS_Store
 /build
+build/
 /captures
 .externalNativeBuild
 .cxx
@@ -16,3 +17,4 @@
 /.idea/compiler.xml
 /.idea/jarRepositories.xml
 /.idea/deploymentTargetDropDown.xml
+/.idea/
--- a/.idea/.gitignore
+++ b/.idea/.gitignore
@@ -1,4 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-artifacts
--- a/.idea/AndroidProjectSystem.xml
+++ b/.idea/AndroidProjectSystem.xml
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AndroidProjectSystem">
-    <option name="providerId" value="com.android.tools.idea.GradleProjectSystem" />
-  </component>
-</project>
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -1,10 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <code_scheme name="Project" version="173">
-    <JetCodeStyleSettings>
-      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
-    </JetCodeStyleSettings>
-    <codeStyleSettings language="kotlin">
-      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
-    </codeStyleSettings>
-  </code_scheme>
-</component>
--- a/.idea/codeStyles/codeStyleConfig.xml
+++ b/.idea/codeStyles/codeStyleConfig.xml
@@ -1,5 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <state>
-    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
-  </state>
-</component>
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GradleMigrationSettings" migrationVersion="1" />
-  <component name="GradleSettings">
-    <option name="linkedExternalProjectsSettings">
-      <GradleProjectSettings>
-        <option name="testRunner" value="CHOOSE_PER_TEST" />
-        <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleJvm" value="#GRADLE_LOCAL_JAVA_HOME" />
-        <option name="modules">
-          <set>
-            <option value="$PROJECT_DIR$" />
-          </set>
-        </option>
-      </GradleProjectSettings>
-    </option>
-  </component>
-</project>
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -1,6 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="ReplaceUntilWithRangeUntil" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
-  </profile>
-</component>
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="jbr-21" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/out" />
-  </component>
-</project>
--- a/.idea/runConfigurations.xml
+++ b/.idea/runConfigurations.xml
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RunConfigurationProducerService">
-    <option name="ignoredProducers">
-      <set>
-        <option value="com.intellij.execution.junit.AbstractAllInDirectoryConfigurationProducer" />
-        <option value="com.intellij.execution.junit.AllInPackageConfigurationProducer" />
-        <option value="com.intellij.execution.junit.PatternConfigurationProducer" />
-        <option value="com.intellij.execution.junit.TestInClassConfigurationProducer" />
-        <option value="com.intellij.execution.junit.UniqueIdConfigurationProducer" />
-        <option value="com.intellij.execution.junit.testDiscovery.JUnitTestDiscoveryConfigurationProducer" />
-        <option value="org.jetbrains.kotlin.idea.junit.KotlinJUnitRunConfigurationProducer" />
-        <option value="org.jetbrains.kotlin.idea.junit.KotlinPatternConfigurationProducer" />
-      </set>
-    </option>
-  </component>
-</project>
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-  </component>
-</project>
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -0,0 +1,51 @@
+# Changelog
+
+All notable changes to this project are documented here. The format is based on
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [3.4.0]
+
+### Added
+- Lazy `Sequence` traversal: `asSequence(order)`, `preOrderSequence()`, `postOrderSequence()`,
+  `levelOrderSequence()` — composes with the Kotlin stdlib and short-circuits.
+- Navigation extensions: `isLeaf`, `degree`, `root()`, `ancestors()`, `siblings()`, `leaves()`,
+  `descendants()`.
+- Functional extensions: `findNode`, `filterNodes`, `anyNode`, `allNodes`, `countNodes`,
+  `foldNodes`, `mapValues`, `deepCopy`, `structurallyEquals` (all stack-safe).
+- New optional modules published as separate artifacts:
+  - `tree-structure-serialization` — `kotlinx.serialization` support via a `TreeNodeDto`.
+  - `tree-structure-coroutines` — `Flow` traversal (`asFlow`, `preOrderFlow`, …).
+- `CHANGELOG.md`, expanded README examples, and class-level KDoc (thread-safety / complexity).
+
+### Changed
+- `nodeCount()`, `height()`, `clear()` and the post-order iterator are now iterative — deep or
+  degenerate (linear) trees no longer throw `StackOverflowError`.
+- Migrated to Kotlin 2.x (K2 compiler) and introduced a Gradle version catalog.
+- Build now uses `binary-compatibility-validator` (committed `.api` baselines) and Kover.
+
+## [3.1.5]
+
+### Fixed
+- Removed a stray `println` in `TreeNode.removeChild()` that printed to stdout on every removal.
+
+### Removed
+- Deleted the `Example.ws.kts` worksheet and the `kotlin("script-runtime")` dependency from the
+  published JVM artifact, plus the leftover `ExampleUnitTest` template test.
+
+### Changed
+- Bumped `actions/checkout` v2 → v4 in CI workflows.
+
+## [3.1.4]
+- Updated Kotlin and JS dependencies; added the `wasmJs` target.
+
+## [3.1.3]
+- iOS targets and Maven Central (Sonatype Central Portal) publishing.
+
+[Unreleased]: https://github.com/AdrianKuta/Tree-Data-Structure/compare/v3.4.0...HEAD
+[3.4.0]: https://github.com/AdrianKuta/Tree-Data-Structure/compare/v3.1.5...v3.4.0
+[3.1.5]: https://github.com/AdrianKuta/Tree-Data-Structure/compare/v3.1.3...v3.1.5
+[3.1.4]: https://github.com/AdrianKuta/Tree-Data-Structure/releases/tag/v3.1.4
+[3.1.3]: https://github.com/AdrianKuta/Tree-Data-Structure/releases/tag/v3.1.3
--- a/README.md
+++ b/README.md
@@ -1,9 +1,44 @@
 # Tree (Data Structure)
 [![maven](https://img.shields.io/maven-central/v/com.github.adriankuta/tree-structure?style=plastic)](https://mvnrepository.com/artifact/com.github.adriankuta/tree-structure)
 [![License: MIT](https://img.shields.io/github/license/AdrianKuta/Tree-Data-Structure?style=plastic)](https://github.com/AdrianKuta/Tree-Data-Structure/blob/master/LICENSE)
-[![Publish](https://github.com/AdrianKuta/Tree-Data-Structure/actions/workflows/publishRelease.yml/badge.svg)](https://github.com/AdrianKuta/Tree-Data-Structure/actions/workflows/publish.yml)
+[![Publish](https://github.com/AdrianKuta/Tree-Data-Structure/actions/workflows/publishRelease.yml/badge.svg)](https://github.com/AdrianKuta/Tree-Data-Structure/actions/workflows/publishRelease.yml)

-Simple implementation to store object in tree structure.
+Lightweight Kotlin Multiplatform tree data structure for Kotlin and Java. Includes a small DSL, multiple traversal iterators, and pretty-print support.
+
+- Kotlin Multiplatform (JVM, JS, Wasm, iOS, and Native host)
+- Pre-order, Post-order, and Level-order iteration
+- Lazy `Sequence` traversal that composes with the Kotlin stdlib (`map`/`filter`/`firstOrNull`…)
+- Navigation helpers: `root()`, `ancestors()`, `siblings()`, `leaves()`, `descendants()`, `isLeaf`, `degree`
+- Functional helpers: `findNode`, `filterNodes`, `anyNode`, `allNodes`, `foldNodes`, `mapValues`, `deepCopy`, `structurallyEquals`
+- Stack-safe: traversal and `height()`/`nodeCount()`/`clear()` handle arbitrarily deep trees without `StackOverflowError`
+- Simple DSL: tree { child(...) }
+- Utilities: nodeCount(), height(), depth(), path(), prettyString(), clear(), removeChild()
+
+## Installation
+
+Gradle (Kotlin DSL):
+```kotlin
+// commonMain for KMP projects, or any sourceSet/module where you need it
+dependencies {
+    implementation("com.github.adriankuta:tree-structure:3.1.5") // see badge above for the latest version
+}
+```
+
+Gradle (Groovy):
+```groovy
+dependencies {
+    implementation "com.github.adriankuta:tree-structure:3.1.5" // see badge above for the latest
+}
+```
+
+Maven:
+```xml
+<dependency>
+  <groupId>com.github.adriankuta</groupId>
+  <artifactId>tree-structure</artifactId>
+  <version>3.1.5</version>
+</dependency>
+```

 ## Usage

@@ -25,19 +60,15 @@ europe.addChild(france)
 println(root.prettyString())
 ```

-**Pretty Kotlin**
-
+**Pretty Kotlin (DSL)**
 ```kotlin
-val root =
-    tree("World") {
-        child("North America") {
-            child("USA")
-        }
+val root = tree("World") {
+    child("North America") { child("USA") }
    child("Europe") {
        child("Poland")
        child("Germany")
    }
-    }
+}
 ```

 **Java**
@@ -58,8 +89,7 @@ europe.addChild(france);
 System.out.println(root.prettyString());
 ```

-*Output:*
-
+Output:
 ```
 World
 ├── North America
@@ -69,10 +99,139 @@ World
    └── France
 ```

+### Traversal and utilities
+```kotlin
+val root = TreeNode("root")
+// ... build your tree

-## Download
+// Choose iteration order (default is PreOrder)
+root.treeIterator = TreeNodeIterators.PostOrder
+for (node in root) println(node.value)

-    implementation "com.github.adriankuta:tree-structure:$latest_versions"
+// Utilities
+root.nodeCount()   // number of descendants
+root.height()      // longest path to a leaf (in edges)
+root.depth()       // distance from current node to the root
+val path = root.path(root.children.first()) // nodes from descendant up to root
+
+// Mutations
+val child = root.children.first()
+root.removeChild(child)
+root.clear()       // remove entire subtree
+```
+
+### Lazy traversal with Sequence
+
+Traversal is exposed as a lazy `Sequence`, so it composes with the Kotlin standard library and
+short-circuits (it never materializes the whole tree just to find one node):
+
+```kotlin
+val tree = tree("World") {
+    child("North America") { child("USA") }
+    child("Europe") {
+        child("Poland")
+        child("Germany")
+    }
+}
+
+// Pick an order explicitly — no need to mutate the node's state.
+tree.preOrderSequence().map { it.value }.toList()    // [World, North America, USA, Europe, Poland, Germany]
+tree.levelOrderSequence().first { it.value == "USA" } // stops as soon as it's found
+tree.asSequence(TreeNodeIterators.PostOrder).count()  // 6
+```
+
+### Navigation
+
+```kotlin
+val usa = tree.findNode { it == "USA" }!!
+
+usa.isLeaf           // true
+usa.depth()          // 2
+usa.root().value     // "World"
+usa.ancestors().map { it.value } // [North America, World]
+tree.leaves().map { it.value }   // [USA, Poland, Germany]
+val europe = tree.findNode { it == "Europe" }!!
+europe.children.first().siblings().map { it.value } // [Germany]
+```
+
+### Functional operations
+
+```kotlin
+tree.anyNode { it == "Poland" }            // true
+tree.filterNodes { it.length > 5 }         // nodes whose value is longer than 5 chars
+tree.countNodes { it.startsWith("U") }     // 1
+
+// Transform values into a brand-new tree (the original is untouched); stack-safe.
+val lengths: TreeNode<Int> = tree.mapValues { it.length }
+
+// Deep copy + structural comparison.
+val copy = tree.deepCopy()
+tree.structurallyEquals(copy)              // true (same values, same shape, different nodes)
+```
+
+## Optional modules
+
+The core `tree-structure` artifact has no third-party dependencies. Ecosystem integrations ship as
+separate, opt-in artifacts that depend on the core.
+
+### Serialization — `tree-structure-serialization`
+
+`kotlinx.serialization` support. A `TreeNode` holds a parent back-reference (a cycle), so it cannot
+be `@Serializable` directly — convert to/from the acyclic `TreeNodeDto` instead.
+
+```kotlin
+implementation("com.github.adriankuta:tree-structure-serialization:3.4.0")
+```
+
+```kotlin
+val json = Json.encodeToString(tree.toDto())
+val restored = Json.decodeFromString<TreeNodeDto<String>>(json).toTreeNode()
+```
+
+### Coroutines — `tree-structure-coroutines`
+
+Traverse a tree as a cold `Flow` (handy in coroutine/`ViewModel` pipelines).
+
+```kotlin
+implementation("com.github.adriankuta:tree-structure-coroutines:3.4.0")
+```
+
+```kotlin
+tree.preOrderFlow().collect { println(it.value) }
+tree.asFlow(TreeNodeIterators.LevelOrder).map { it.value }
+```
+
+## Publishing to Maven Central (central.sonatype.com)
+
+This project is configured to publish artifacts to Maven Central via the Sonatype Central Portal.
+
+There are two supported ways to publish:
+
+1) Via GitHub Actions (recommended)
+- Create a GitHub Release (tag) in this repository. When a release is published, the workflow .github/workflows/publishRelease.yml runs automatically.
+- The workflow uses the Gradle task publishToMavenCentral to upload artifacts through the Central Portal.
+- Make sure these repository secrets are configured in GitHub:
+  - MAVEN_CENTRAL_USERNAME — Your Sonatype Central username (not email).
+  - MAVEN_CENTRAL_PASSWORD — Your Sonatype Central password or a token from central.sonatype.com.
+  - SIGNING_KEY — ASCII‑armored GPG private key (exported, single line; for in‑memory signing).
+  - SIGNING_PASSWORD — Passphrase for the key above.
+- The workflow uses JDK 21 and publishes the version defined in build.gradle.kts.
+
+2) Locally via Gradle
+- Ensure you have a Sonatype Central account and that the groupId com.github.adriankuta is verified in central.sonatype.com (Namespace Rules → Verify).
+- Export the same credentials/signing values as environment variables or pass them as Gradle properties:
+  - ORG_GRADLE_PROJECT_mavenCentralUsername
+  - ORG_GRADLE_PROJECT_mavenCentralPassword
+  - ORG_GRADLE_PROJECT_signingInMemoryKey
+  - ORG_GRADLE_PROJECT_signingInMemoryKeyPassword
+- Then run:
+  - ./gradlew publishToMavenCentral
+- For snapshot publishing, set -Psnapshot=true (the version is derived from PUBLISH_VERSION with -SNAPSHOT).
+
+Notes
+- Publishing is powered by the com.vanniktech.maven.publish Gradle plugin and Sonatype Central Portal (no legacy Nexus staging URLs needed).
+- The plugin is configured to sign all publications. Coordinates and POM metadata are defined in build.gradle.kts.
+- If using the combined task is preferred, you can also run publishAndReleaseToMavenCentral when automatic release is enabled; this repository currently uploads with publishToMavenCentral from CI.

 ## License

@@ -99,22 +258,3 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

 ---
-
-## Publishing (Maven Central migration)
-
-This project is configured to publish via Sonatype's s01.oss.sonatype.org (Nexus) which is compatible with the new Central (central.sonatype.com). The old oss.sonatype.org host is no longer used.
-
-Environment variables supported by the build:
- CENTRAL_USERNAME / CENTRAL_PASSWORD — Central Portal user/token (preferred)
- OSSRH_USERNAME / OSSRH_PASSWORD — legacy credentials (fallback)
- SIGNING_KEY_ID / SIGNING_KEY / SIGNING_PASSWORD — PGP signing (ASCII-armored key)
- SNAPSHOT — set to true to append -SNAPSHOT to version
-
-Gradle tasks:
- Publish all publications to Sonatype: `./gradlew publishAllPublicationsToSonatypeS01Repository`
- Or, standard publish (selects snapshots vs releases by version): `./gradlew publish`
-
-Notes:
- Releases are uploaded to: https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/
- Snapshots are uploaded to: https://s01.oss.sonatype.org/content/repositories/snapshots/
- Staging/release close and promote are handled by Sonatype. If you use CI, set the env vars in your secrets.
--- a/api/tree-structure.api
+++ b/api/tree-structure.api
@@ -0,0 +1,100 @@
+public abstract interface class com/github/adriankuta/datastructure/tree/ChildDeclarationInterface {
+	public abstract synthetic fun child (Ljava/lang/Object;Lkotlin/jvm/functions/Function1;)Lcom/github/adriankuta/datastructure/tree/TreeNode;
+}
+
+public final class com/github/adriankuta/datastructure/tree/ChildDeclarationInterface$DefaultImpls {
+	public static synthetic fun child$default (Lcom/github/adriankuta/datastructure/tree/ChildDeclarationInterface;Ljava/lang/Object;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lcom/github/adriankuta/datastructure/tree/TreeNode;
+}
+
+public class com/github/adriankuta/datastructure/tree/TreeNode : com/github/adriankuta/datastructure/tree/ChildDeclarationInterface, java/lang/Iterable, kotlin/jvm/internal/markers/KMappedMarker {
+	public fun <init> (Ljava/lang/Object;Lcom/github/adriankuta/datastructure/tree/iterators/TreeNodeIterators;)V
+	public synthetic fun <init> (Ljava/lang/Object;Lcom/github/adriankuta/datastructure/tree/iterators/TreeNodeIterators;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun addChild (Lcom/github/adriankuta/datastructure/tree/TreeNode;)V
+	public synthetic fun child (Ljava/lang/Object;Lkotlin/jvm/functions/Function1;)Lcom/github/adriankuta/datastructure/tree/TreeNode;
+	public final fun clear ()V
+	public final fun depth ()I
+	public final fun getChildren ()Ljava/util/List;
+	public final fun getParent ()Lcom/github/adriankuta/datastructure/tree/TreeNode;
+	public final fun getTreeIterator ()Lcom/github/adriankuta/datastructure/tree/iterators/TreeNodeIterators;
+	public final fun getValue ()Ljava/lang/Object;
+	public final fun height ()I
+	public final fun isRoot ()Z
+	public fun iterator ()Ljava/util/Iterator;
+	public final fun nodeCount ()I
+	public final fun path (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Ljava/util/List;
+	public final fun prettyString ()Ljava/lang/String;
+	public final fun removeChild (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Z
+	public final fun setTreeIterator (Lcom/github/adriankuta/datastructure/tree/iterators/TreeNodeIterators;)V
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class com/github/adriankuta/datastructure/tree/TreeNodeFunctionalExtKt {
+	public static final fun allNodes (Lcom/github/adriankuta/datastructure/tree/TreeNode;Lkotlin/jvm/functions/Function1;)Z
+	public static final fun anyNode (Lcom/github/adriankuta/datastructure/tree/TreeNode;Lkotlin/jvm/functions/Function1;)Z
+	public static final fun countNodes (Lcom/github/adriankuta/datastructure/tree/TreeNode;Lkotlin/jvm/functions/Function1;)I
+	public static final fun deepCopy (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Lcom/github/adriankuta/datastructure/tree/TreeNode;
+	public static final fun filterNodes (Lcom/github/adriankuta/datastructure/tree/TreeNode;Lkotlin/jvm/functions/Function1;)Ljava/util/List;
+	public static final fun findNode (Lcom/github/adriankuta/datastructure/tree/TreeNode;Lkotlin/jvm/functions/Function1;)Lcom/github/adriankuta/datastructure/tree/TreeNode;
+	public static final fun foldNodes (Lcom/github/adriankuta/datastructure/tree/TreeNode;Ljava/lang/Object;Lkotlin/jvm/functions/Function2;)Ljava/lang/Object;
+	public static final fun mapValues (Lcom/github/adriankuta/datastructure/tree/TreeNode;Lkotlin/jvm/functions/Function1;)Lcom/github/adriankuta/datastructure/tree/TreeNode;
+	public static final fun structurallyEquals (Lcom/github/adriankuta/datastructure/tree/TreeNode;Lcom/github/adriankuta/datastructure/tree/TreeNode;)Z
+}
+
+public final class com/github/adriankuta/datastructure/tree/TreeNodeNavigationExtKt {
+	public static final fun ancestors (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Ljava/util/List;
+	public static final fun descendants (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Ljava/util/List;
+	public static final fun getDegree (Lcom/github/adriankuta/datastructure/tree/TreeNode;)I
+	public static final fun isLeaf (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Z
+	public static final fun leaves (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Ljava/util/List;
+	public static final fun root (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Lcom/github/adriankuta/datastructure/tree/TreeNode;
+	public static final fun siblings (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Ljava/util/List;
+}
+
+public final class com/github/adriankuta/datastructure/tree/TreeNodeSequenceExtKt {
+	public static final fun asSequence (Lcom/github/adriankuta/datastructure/tree/TreeNode;Lcom/github/adriankuta/datastructure/tree/iterators/TreeNodeIterators;)Lkotlin/sequences/Sequence;
+	public static synthetic fun asSequence$default (Lcom/github/adriankuta/datastructure/tree/TreeNode;Lcom/github/adriankuta/datastructure/tree/iterators/TreeNodeIterators;ILjava/lang/Object;)Lkotlin/sequences/Sequence;
+	public static final fun levelOrderSequence (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Lkotlin/sequences/Sequence;
+	public static final fun postOrderSequence (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Lkotlin/sequences/Sequence;
+	public static final fun preOrderSequence (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Lkotlin/sequences/Sequence;
+}
+
+public final class com/github/adriankuta/datastructure/tree/exceptions/TreeNodeException : java/lang/RuntimeException {
+	public fun <init> ()V
+	public fun <init> (Ljava/lang/String;)V
+	public fun <init> (Ljava/lang/String;Ljava/lang/Throwable;)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/Throwable;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+}
+
+public final class com/github/adriankuta/datastructure/tree/iterators/LevelOrderTreeIterator : java/util/Iterator, kotlin/jvm/internal/markers/KMappedMarker {
+	public fun <init> (Lcom/github/adriankuta/datastructure/tree/TreeNode;)V
+	public fun hasNext ()Z
+	public fun next ()Lcom/github/adriankuta/datastructure/tree/TreeNode;
+	public synthetic fun next ()Ljava/lang/Object;
+	public fun remove ()V
+}
+
+public final class com/github/adriankuta/datastructure/tree/iterators/PostOrderTreeIterator : java/util/Iterator, kotlin/jvm/internal/markers/KMappedMarker {
+	public fun <init> (Lcom/github/adriankuta/datastructure/tree/TreeNode;)V
+	public fun hasNext ()Z
+	public fun next ()Lcom/github/adriankuta/datastructure/tree/TreeNode;
+	public synthetic fun next ()Ljava/lang/Object;
+	public fun remove ()V
+}
+
+public final class com/github/adriankuta/datastructure/tree/iterators/PreOrderTreeIterator : java/util/Iterator, kotlin/jvm/internal/markers/KMappedMarker {
+	public fun <init> (Lcom/github/adriankuta/datastructure/tree/TreeNode;)V
+	public fun hasNext ()Z
+	public fun next ()Lcom/github/adriankuta/datastructure/tree/TreeNode;
+	public synthetic fun next ()Ljava/lang/Object;
+	public fun remove ()V
+}
+
+public final class com/github/adriankuta/datastructure/tree/iterators/TreeNodeIterators : java/lang/Enum {
+	public static final field LevelOrder Lcom/github/adriankuta/datastructure/tree/iterators/TreeNodeIterators;
+	public static final field PostOrder Lcom/github/adriankuta/datastructure/tree/iterators/TreeNodeIterators;
+	public static final field PreOrder Lcom/github/adriankuta/datastructure/tree/iterators/TreeNodeIterators;
+	public static fun getEntries ()Lkotlin/enums/EnumEntries;
+	public static fun valueOf (Ljava/lang/String;)Lcom/github/adriankuta/datastructure/tree/iterators/TreeNodeIterators;
+	public static fun values ()[Lcom/github/adriankuta/datastructure/tree/iterators/TreeNodeIterators;
+}
+
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,118 +1,58 @@
-import org.jetbrains.kotlin.konan.properties.Properties
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl

 plugins {
-    kotlin("multiplatform") version "1.7.20"
-    id("org.jetbrains.dokka") version "1.7.20"
-    id("maven-publish")
+    alias(libs.plugins.kotlinMultiplatform)
+    alias(libs.plugins.dokka)
+    alias(libs.plugins.mavenPublish)
+    alias(libs.plugins.binaryCompatibilityValidator)
+    alias(libs.plugins.kover)
    signing
 }

 val PUBLISH_GROUP_ID = "com.github.adriankuta"
-val PUBLISH_ARTIFACT_ID = "tree-structure"
-val PUBLISH_VERSION = "3.1.0"
+val PUBLISH_ARTIFACT_ID = "tree-structure"    // base artifact; KMP will add -jvm, -ios*, etc.
+val PUBLISH_VERSION = "3.4.0"

-val secretFile = File(rootProject.rootDir, "local.properties")
-if (secretFile.exists()) {
-    secretFile.reader().use {
-        Properties().apply {
-            load(it)
-        }
-    }.onEach { (name, value) ->
-        project.ext[name.toString()] = value
-    }
-} else {
-    // Prefer Central Portal credentials via environment variables
-    project.ext["centralUsername"] = System.getenv("CENTRAL_USERNAME")
-    project.ext["centralPassword"] = System.getenv("CENTRAL_PASSWORD")
-    // Fallback legacy OSSRH credentials (still supported on s01)
-    project.ext["ossrhUsername"] = System.getenv("OSSRH_USERNAME")
-    project.ext["ossrhPassword"] = System.getenv("OSSRH_PASSWORD")
-    project.ext["sonatypeStagingProfileId"] = System.getenv("SONATYPE_STAGING_PROFILE_ID")
-    project.ext["signingKeyId"] = System.getenv("SIGNING_KEY_ID")
-    project.ext["signingPassword"] = System.getenv("SIGNING_PASSWORD")
-    project.ext["signingKey"] = System.getenv("SIGNING_KEY")
-    project.ext["snapshot"] = System.getenv("SNAPSHOT")
-}
 val snapshot: String? by project

 group = PUBLISH_GROUP_ID
 version = if (snapshot.toBoolean()) "$PUBLISH_VERSION-SNAPSHOT" else PUBLISH_VERSION

-val dokkaHtml by tasks.getting(org.jetbrains.dokka.gradle.DokkaTask::class)
+mavenPublishing {
+    // Central Portal + auto release when we call publishAndReleaseToMavenCentral
+    publishToMavenCentral(automaticRelease = false)
+    signAllPublications()

-val javadocJar: TaskProvider<Jar> by tasks.registering(Jar::class) {
-    dependsOn(dokkaHtml)
-    archiveClassifier.set("javadoc")
-    from(dokkaHtml.outputDirectory)
-}
+    coordinates(PUBLISH_GROUP_ID, PUBLISH_ARTIFACT_ID, version.toString())

-publishing {
-    publications {
-
-        withType<MavenPublication> {
-            artifact(javadocJar)
    pom {
        name.set("Tree Data Structure")
-                description.set("Simple implementation to store object in tree structure.")
+        description.set(
+            "Lightweight n-ary tree data structure for Kotlin Multiplatform (JVM, JS, Wasm, iOS, " +
+                "Native). DSL, pre/post/level-order traversal, lazy Sequence traversal, and pretty-print.",
+        )
        url.set("https://github.com/AdrianKuta/Tree-Data-Structure")
+
        licenses {
            license {
                name.set("MIT License")
-                        url.set("https://www.mit.edu/~amini/LICENSE.md")
+                url.set("https://opensource.org/licenses/MIT")
+                distribution.set("repo")
            }
        }
        developers {
            developer {
+                id.set("AdrianKuta")
                name.set("Adrian Kuta")
                email.set("adrian.kuta93@gmail.com")
            }
        }
        scm {
-                    connection.set("scm:git:github.com/AdrianKuta/Tree-Data-Structure.git")
-                    developerConnection.set("scm:git:ssh://github.com/AdrianKuta/Tree-Data-Structure.git")
-                    url.set("https://github.com/AdrianKuta/Tree-Data-Structure/tree/master")
+            url.set("https://github.com/AdrianKuta/Tree-Data-Structure")
+            connection.set("scm:git:https://github.com/AdrianKuta/Tree-Data-Structure.git")
+            developerConnection.set("scm:git:ssh://git@github.com/AdrianKuta/Tree-Data-Structure.git")
        }
    }
-        }
-    }
-
-    repositories {
-        maven {
-            name = "SonatypeS01"
-            // s01 is the supported Nexus host for Central publishing via Maven-compatible uploads
-            val releasesRepoUrl = "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/"
-            val snapshotsRepoUrl = "https://s01.oss.sonatype.org/content/repositories/snapshots/"
-            url = uri(if (version.toString().endsWith("SNAPSHOT")) snapshotsRepoUrl else releasesRepoUrl)
-            credentials {
-                // Prefer Central Portal credentials when provided, fallback to legacy OSSRH credentials
-                val centralUsername: String? by project
-                val centralPassword: String? by project
-                val CENTRAL_USERNAME: String? by project
-                val CENTRAL_PASSWORD: String? by project
-                val ossrhUsername: String? by project
-                val ossrhPassword: String? by project
-                username = centralUsername
-                    ?: CENTRAL_USERNAME
-                    ?: ossrhUsername
-                    ?: System.getenv("CENTRAL_USERNAME")
-                    ?: System.getenv("OSSRH_USERNAME")
-                password = centralPassword
-                    ?: CENTRAL_PASSWORD
-                    ?: ossrhPassword
-                    ?: System.getenv("CENTRAL_PASSWORD")
-                    ?: System.getenv("OSSRH_PASSWORD")
-            }
-        }
-    }
-}
-
-signing {
-    val signingKeyId: String? by project
-    val signingPassword: String? by project
-    val signingKey: String? by project
-    useInMemoryPgpKeys(signingKeyId, signingKey, signingPassword)
-
-    sign(publishing.publications)
 }

 repositories {
@@ -120,31 +60,30 @@ repositories {
 }

 kotlin {
-    jvm {
-        compilations.all {
-            kotlinOptions.jvmTarget = "1.8"
-        }
-        withJava()
-        testRuns["test"].executionTask.configure {
-            useJUnitPlatform()
-        }
-    }
-    js(BOTH) {
-        browser {
-            commonWebpackConfig {
-                cssSupport.enabled = true
-            }
-        }
+    jvmToolchain(21)
+
+    jvm()
+
+    js(IR) {
+        browser()
+        nodejs()
    }

-    // Add iOS targets
+    @OptIn(ExperimentalWasmDsl::class)
+    wasmJs {
+        browser()
+        nodejs()
+    }
+
+    // Apple targets
    iosX64()
    iosArm64()
    iosSimulatorArm64()

+    // Native host target
    val hostOs = System.getProperty("os.name")
    val isMingwX64 = hostOs.startsWith("Windows")
-    val nativeTarget = when {
+    when {
        hostOs == "Mac OS X" -> macosX64("native")
        hostOs == "Linux" -> linuxX64("native")
        isMingwX64 -> mingwX64("native")
@@ -152,35 +91,8 @@ kotlin {
    }

    sourceSets {
-        val commonMain by getting
-        val commonTest by getting {
-            dependencies {
+        commonTest.dependencies {
            implementation(kotlin("test"))
        }
    }
-        val jvmMain by getting {
-            dependencies {
-                implementation(kotlin("script-runtime"))
-            }
-        }
-        val jvmTest by getting
-        val jsMain by getting
-        val jsTest by getting
-        val nativeMain by getting
-        val nativeTest by getting
-
-        // Shared iOS source sets
-        val iosMain by creating {
-            dependsOn(commonMain)
-        }
-        val iosTest by creating {
-            dependsOn(commonTest)
-        }
-        val iosX64Main by getting { dependsOn(iosMain) }
-        val iosArm64Main by getting { dependsOn(iosMain) }
-        val iosSimulatorArm64Main by getting { dependsOn(iosMain) }
-        val iosX64Test by getting { dependsOn(iosTest) }
-        val iosArm64Test by getting { dependsOn(iosTest) }
-        val iosSimulatorArm64Test by getting { dependsOn(iosTest) }
-    }
 }
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,2 +1 @@
 kotlin.code.style=official
-kotlin.js.compiler=ir
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -0,0 +1,21 @@
+[versions]
+kotlin = "2.1.0"
+dokka = "1.9.20"
+mavenPublish = "0.34.0"
+binaryCompatibilityValidator = "0.16.3"
+kover = "0.8.3"
+coroutines = "1.9.0"
+kotlinxSerialization = "1.7.3"
+
+[plugins]
+kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
+kotlinSerialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
+dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
+mavenPublish = { id = "com.vanniktech.maven.publish", version.ref = "mavenPublish" }
+binaryCompatibilityValidator = { id = "org.jetbrains.kotlinx.binary-compatibility-validator", version.ref = "binaryCompatibilityValidator" }
+kover = { id = "org.jetbrains.kotlinx.kover", version.ref = "kover" }
+
+[libraries]
+kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
+kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "coroutines" }
+kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinxSerialization" }
--- a/kotlin-js-store/yarn.lock
+++ b/kotlin-js-store/yarn.lock
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -1,3 +1,4 @@
-
 rootProject.name = "tree-structure"

+include(":tree-structure-serialization")
+include(":tree-structure-coroutines")
--- a/src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/TreeNode.kt
+++ b/src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/TreeNode.kt
@@ -9,7 +9,23 @@ import com.github.adriankuta.datastructure.tree.iterators.TreeNodeIterators.*
 import kotlin.jvm.JvmSynthetic

 /**
- * @param treeIterator Choose one of available iterators from [TreeNodeIterators]
+ * A node in a generic, mutable n-ary tree. Each node holds a [value], a reference to its [parent]
+ * and an ordered list of [children].
+ *
+ * Iterating a node (via [iterator], or the lazy [asSequence]/[preOrderSequence] extensions) visits
+ * the node and all of its descendants. Traversal and the [height]/[nodeCount]/[clear] helpers are
+ * implemented iteratively, so they are safe on arbitrarily deep trees.
+ *
+ * **Not thread-safe.** Nodes are mutable ([addChild]/[removeChild]/[clear] mutate the structure and
+ * parent pointers). Sharing a tree across threads requires external synchronization, and the tree
+ * must not be modified while it is being iterated.
+ *
+ * Equality is by reference (identity); use the `structurallyEquals` extension to compare two trees
+ * by value and shape.
+ *
+ * @param value the value stored in this node.
+ * @param treeIterator the default traversal order used by [iterator]. Prefer the
+ *   `asSequence(order)` / `preOrderSequence()` extensions to choose an order without mutating state.
 */
 open class TreeNode<T>(val value: T, var treeIterator: TreeNodeIterators = PreOrder) : Iterable<TreeNode<T>>, ChildDeclarationInterface<T> {

@@ -62,7 +78,6 @@ open class TreeNode<T>(val value: T, var treeIterator: TreeNodeIterators = PreOr
     * @return `true` if the node has been successfully removed; `false` if it was not present in the tree.
     */
    fun removeChild(child: TreeNode<T>): Boolean {
-        println(child.value)
        val removed = child._parent?._children?.remove(child)
        child._parent = null
        return removed ?: false
@@ -73,20 +88,30 @@ open class TreeNode<T>(val value: T, var treeIterator: TreeNodeIterators = PreOr
     * @return All child and nested child count.
     */
    fun nodeCount(): Int {
-        if (_children.isEmpty())
-            return 0
-        return _children.size +
-                _children.sumOf { it.nodeCount() }
+        var count = 0
+        val stack = ArrayDeque<TreeNode<T>>()
+        stack.addAll(_children)
+        while (stack.isNotEmpty()) {
+            val node = stack.removeLast()
+            count++
+            stack.addAll(node._children)
+        }
+        return count
    }

    /**
     * @return The number of edges on the longest path between current node and a descendant leaf.
     */
    fun height(): Int {
-        val childrenMaxDepth = _children.map { it.height() }
-            .maxOrNull()
-            ?: -1 // -1 because this method counts nodes, and edges are always one less then nodes.
-        return childrenMaxDepth + 1
+        var maxDepth = 0
+        val stack = ArrayDeque<Pair<TreeNode<T>, Int>>()
+        stack.addLast(this to 0)
+        while (stack.isNotEmpty()) {
+            val (node, depthSoFar) = stack.removeLast()
+            if (depthSoFar > maxDepth) maxDepth = depthSoFar
+            node._children.forEach { stack.addLast(it to depthSoFar + 1) }
+        }
+        return maxDepth
    }

    /**
@@ -133,9 +158,18 @@ open class TreeNode<T>(val value: T, var treeIterator: TreeNodeIterators = PreOr
     * Remove all children from root and every node in tree.
     */
    fun clear() {
-        _parent = null
-        _children.forEach { it.clear() }
-        _children.clear()
+        val all = ArrayDeque<TreeNode<T>>()
+        val stack = ArrayDeque<TreeNode<T>>()
+        stack.addLast(this)
+        while (stack.isNotEmpty()) {
+            val node = stack.removeLast()
+            all.addLast(node)
+            stack.addAll(node._children)
+        }
+        all.forEach { node ->
+            node._parent = null
+            node._children.clear()
+        }
    }

    override fun toString(): String {
--- a/src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/TreeNodeFunctionalExt.kt
+++ b/src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/TreeNodeFunctionalExt.kt
@@ -0,0 +1,65 @@
+package com.github.adriankuta.datastructure.tree
+
+/** Returns the first node (pre-order) whose value matches [predicate], or `null`. Short-circuits. */
+fun <T> TreeNode<T>.findNode(predicate: (T) -> Boolean): TreeNode<T>? =
+    preOrderSequence().firstOrNull { predicate(it.value) }
+
+/** All nodes (pre-order) whose value matches [predicate]. */
+fun <T> TreeNode<T>.filterNodes(predicate: (T) -> Boolean): List<TreeNode<T>> =
+    preOrderSequence().filter { predicate(it.value) }.toList()
+
+/** `true` if any node's value matches [predicate]. Short-circuits. */
+fun <T> TreeNode<T>.anyNode(predicate: (T) -> Boolean): Boolean =
+    preOrderSequence().any { predicate(it.value) }
+
+/** `true` if every node's value matches [predicate]. Short-circuits. */
+fun <T> TreeNode<T>.allNodes(predicate: (T) -> Boolean): Boolean =
+    preOrderSequence().all { predicate(it.value) }
+
+/** Counts nodes whose value matches [predicate]. */
+fun <T> TreeNode<T>.countNodes(predicate: (T) -> Boolean): Int =
+    preOrderSequence().count { predicate(it.value) }
+
+/** Folds [operation] over all nodes in pre-order, starting from [initial]. */
+fun <T, R> TreeNode<T>.foldNodes(initial: R, operation: (acc: R, node: TreeNode<T>) -> R): R =
+    preOrderSequence().fold(initial) { acc, node -> operation(acc, node) }
+
+/**
+ * Returns a new tree with the same shape whose values are produced by [transform]. The original is
+ * left untouched. Stack-safe (iterative), so it handles arbitrarily deep trees.
+ */
+fun <T, R> TreeNode<T>.mapValues(transform: (T) -> R): TreeNode<R> {
+    val newRoot = TreeNode(transform(value), treeIterator)
+    val stack = ArrayDeque<Pair<TreeNode<T>, TreeNode<R>>>()
+    stack.addLast(this to newRoot)
+    while (stack.isNotEmpty()) {
+        val (source, target) = stack.removeLast()
+        source.children.forEach { child ->
+            val mappedChild = TreeNode(transform(child.value), child.treeIterator)
+            target.addChild(mappedChild)
+            stack.addLast(child to mappedChild)
+        }
+    }
+    return newRoot
+}
+
+/** Returns an independent deep copy of this subtree (same values, same shape, new nodes). */
+fun <T> TreeNode<T>.deepCopy(): TreeNode<T> = mapValues { it }
+
+/**
+ * Structural equality: `true` when [other] holds the same values in the same shape. Unlike
+ * [TreeNode]'s reference equality, this compares the entire subtree. Stack-safe.
+ */
+fun <T> TreeNode<T>.structurallyEquals(other: TreeNode<T>): Boolean {
+    val stack = ArrayDeque<Pair<TreeNode<T>, TreeNode<T>>>()
+    stack.addLast(this to other)
+    while (stack.isNotEmpty()) {
+        val (a, b) = stack.removeLast()
+        if (a.value != b.value) return false
+        if (a.children.size != b.children.size) return false
+        for (i in a.children.indices) {
+            stack.addLast(a.children[i] to b.children[i])
+        }
+    }
+    return true
+}
--- a/src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/TreeNodeNavigationExt.kt
+++ b/src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/TreeNodeNavigationExt.kt
@@ -0,0 +1,41 @@
+package com.github.adriankuta.datastructure.tree
+
+/** `true` when this node has no children. */
+val <T> TreeNode<T>.isLeaf: Boolean get() = children.isEmpty()
+
+/** The number of direct children of this node. */
+val <T> TreeNode<T>.degree: Int get() = children.size
+
+/** Walks up the parent chain and returns the topmost ancestor (the tree root). */
+fun <T> TreeNode<T>.root(): TreeNode<T> {
+    var node = this
+    var parent = node.parent
+    while (parent != null) {
+        node = parent
+        parent = node.parent
+    }
+    return node
+}
+
+/** The chain of ancestors from the immediate [parent] up to (and including) the root. */
+fun <T> TreeNode<T>.ancestors(): List<TreeNode<T>> {
+    val result = mutableListOf<TreeNode<T>>()
+    var parent = this.parent
+    while (parent != null) {
+        result.add(parent)
+        parent = parent.parent
+    }
+    return result
+}
+
+/** The other children of this node's parent (excludes this node). Empty for the root. */
+fun <T> TreeNode<T>.siblings(): List<TreeNode<T>> =
+    parent?.children?.filter { it !== this } ?: emptyList()
+
+/** All leaf nodes in this subtree, in pre-order. */
+fun <T> TreeNode<T>.leaves(): List<TreeNode<T>> =
+    preOrderSequence().filter { it.isLeaf }.toList()
+
+/** All nodes in this subtree except this node, in pre-order. */
+fun <T> TreeNode<T>.descendants(): List<TreeNode<T>> =
+    preOrderSequence().filter { it !== this }.toList()
--- a/src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/TreeNodeSequenceExt.kt
+++ b/src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/TreeNodeSequenceExt.kt
@@ -0,0 +1,31 @@
+package com.github.adriankuta.datastructure.tree
+
+import com.github.adriankuta.datastructure.tree.iterators.LevelOrderTreeIterator
+import com.github.adriankuta.datastructure.tree.iterators.PostOrderTreeIterator
+import com.github.adriankuta.datastructure.tree.iterators.PreOrderTreeIterator
+import com.github.adriankuta.datastructure.tree.iterators.TreeNodeIterators
+
+/**
+ * Lazily traverses this subtree in the given [order] as a [Sequence], without forcing the whole
+ * traversal up front. Pairs with the Kotlin stdlib, e.g.
+ * `root.asSequence().map { it.value }.firstOrNull { it == target }`.
+ */
+fun <T> TreeNode<T>.asSequence(
+    order: TreeNodeIterators = TreeNodeIterators.PreOrder,
+): Sequence<TreeNode<T>> {
+    val self = this
+    return when (order) {
+        TreeNodeIterators.PreOrder -> Sequence { PreOrderTreeIterator(self) }
+        TreeNodeIterators.PostOrder -> Sequence { PostOrderTreeIterator(self) }
+        TreeNodeIterators.LevelOrder -> Sequence { LevelOrderTreeIterator(self) }
+    }
+}
+
+/** Lazy pre-order traversal as a [Sequence]. */
+fun <T> TreeNode<T>.preOrderSequence(): Sequence<TreeNode<T>> = asSequence(TreeNodeIterators.PreOrder)
+
+/** Lazy post-order traversal as a [Sequence]. */
+fun <T> TreeNode<T>.postOrderSequence(): Sequence<TreeNode<T>> = asSequence(TreeNodeIterators.PostOrder)
+
+/** Lazy level-order (breadth-first) traversal as a [Sequence]. */
+fun <T> TreeNode<T>.levelOrderSequence(): Sequence<TreeNode<T>> = asSequence(TreeNodeIterators.LevelOrder)
--- a/src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/iterators/PostOrderTreeIterator.kt
+++ b/src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/iterators/PostOrderTreeIterator.kt
@@ -22,27 +22,22 @@ import com.github.adriankuta.datastructure.tree.TreeNode
 */
 class PostOrderTreeIterator<T>(root: TreeNode<T>) : Iterator<TreeNode<T>> {

-    private val stack = ArrayDeque<TreeNode<T>>()
+    private val result = ArrayDeque<TreeNode<T>>()

    init {
-        stack.addAll(getChildrenStack(root))
-    }
-
-    override fun hasNext(): Boolean = stack.isNotEmpty()
-
-    override fun next(): TreeNode<T> {
-        return stack.removeFirst()
-    }
-
-    private fun getChildrenStack(node: TreeNode<T>): ArrayDeque<TreeNode<T>> {
+        // Iterative post-order: pop a node, prepend it to `result`, then push its children
+        // left-to-right. Reading `result` front-to-back yields post-order — without the deep
+        // recursion that overflowed the stack on degenerate (linear) trees.
        val stack = ArrayDeque<TreeNode<T>>()
-        if(node.children.isEmpty()) {
-            return ArrayDeque(listOf(node))
+        stack.addLast(root)
+        while (stack.isNotEmpty()) {
+            val node = stack.removeLast()
+            result.addFirst(node)
+            node.children.forEach { stack.addLast(it) }
        }
-        node.children.forEach {
-            stack.addAll(getChildrenStack(it))
-        }
-        stack.addLast(node)
-        return stack
    }
+
+    override fun hasNext(): Boolean = result.isNotEmpty()
+
+    override fun next(): TreeNode<T> = result.removeFirst()
 }
--- a/src/commonTest/kotlin/com.github.adriankuta/datastructure.tree/ExampleUnitTest.kt
+++ b/src/commonTest/kotlin/com.github.adriankuta/datastructure.tree/ExampleUnitTest.kt
@@ -1,16 +0,0 @@
-package com.github.adriankuta.datastructure.tree
-
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-/**
- * Example local unit test, which will execute on the development machine (host).
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-class ExampleUnitTest {
-    @Test
-    fun addition_isCorrect() {
-        assertEquals(4, 2 + 2)
-    }
-}
--- a/src/commonTest/kotlin/com.github.adriankuta/datastructure.tree/TreeNodeFunctionalTest.kt
+++ b/src/commonTest/kotlin/com.github.adriankuta/datastructure.tree/TreeNodeFunctionalTest.kt
@@ -0,0 +1,78 @@
+package com.github.adriankuta.datastructure.tree
+
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotSame
+import kotlin.test.assertNull
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+
+class TreeNodeFunctionalTest {
+
+    private fun sample() = tree(1) {
+        child(2) {
+            child(4)
+            child(5)
+        }
+        child(3) {
+            child(6)
+        }
+    }
+
+    @Test
+    fun findNode() {
+        assertEquals(6, sample().findNode { it == 6 }?.value)
+        assertNull(sample().findNode { it == 99 })
+    }
+
+    @Test
+    fun filterNodes() =
+        assertContentEquals(listOf(2, 4, 6), sample().filterNodes { it % 2 == 0 }.map { it.value })
+
+    @Test
+    fun anyNode() {
+        assertTrue(sample().anyNode { it == 6 })
+        assertFalse(sample().anyNode { it == 99 })
+    }
+
+    @Test
+    fun allNodes() {
+        assertTrue(sample().allNodes { it > 0 })
+        assertFalse(sample().allNodes { it < 5 })
+    }
+
+    @Test
+    fun countNodes() = assertEquals(3, sample().countNodes { it > 3 })
+
+    @Test
+    fun foldNodes() = assertEquals(21, sample().foldNodes(0) { acc, node -> acc + node.value })
+
+    @Test
+    fun mapPreservesStructureAndTransformsValues() {
+        val mapped = sample().mapValues { it * 10 }
+        assertContentEquals(
+            listOf(10, 20, 40, 50, 30, 60),
+            mapped.preOrderSequence().map { it.value }.toList(),
+        )
+    }
+
+    @Test
+    fun deepCopyIsStructurallyEqualButDistinct() {
+        val original = sample()
+        val copy = original.deepCopy()
+        assertNotSame(original, copy)
+        assertTrue(original.structurallyEquals(copy))
+    }
+
+    @Test
+    fun structurallyEqualsDistinguishesByValueAndShape() {
+        assertTrue(sample().structurallyEquals(sample()))
+        val different = tree(1) {
+            child(2) { child(4) }
+            child(3) { child(6) }
+        }
+        assertFalse(sample().structurallyEquals(different))
+    }
+}
--- a/src/commonTest/kotlin/com.github.adriankuta/datastructure.tree/TreeNodeNavigationTest.kt
+++ b/src/commonTest/kotlin/com.github.adriankuta/datastructure.tree/TreeNodeNavigationTest.kt
@@ -0,0 +1,66 @@
+package com.github.adriankuta.datastructure.tree
+
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+
+class TreeNodeNavigationTest {
+
+    private val root = TreeNode(1)
+    private val n2 = TreeNode(2)
+    private val n3 = TreeNode(3)
+    private val n4 = TreeNode(4)
+    private val n5 = TreeNode(5)
+    private val n6 = TreeNode(6)
+
+    init {
+        root.addChild(n2)
+        root.addChild(n3)
+        n2.addChild(n4)
+        n2.addChild(n5)
+        n3.addChild(n6)
+    }
+
+    @Test
+    fun isLeaf() {
+        assertTrue(n4.isLeaf)
+        assertFalse(root.isLeaf)
+    }
+
+    @Test
+    fun degree() {
+        assertEquals(2, root.degree)
+        assertEquals(0, n4.degree)
+    }
+
+    @Test
+    fun root() {
+        assertSame(root, n6.root())
+        assertSame(root, root.root())
+    }
+
+    @Test
+    fun ancestors() {
+        assertContentEquals(listOf(n2, root), n4.ancestors())
+        assertContentEquals(emptyList(), root.ancestors())
+    }
+
+    @Test
+    fun siblings() {
+        assertContentEquals(listOf(n5), n4.siblings())
+        assertContentEquals(emptyList(), root.siblings())
+    }
+
+    @Test
+    fun leaves() {
+        assertContentEquals(listOf(n4, n5, n6), root.leaves())
+    }
+
+    @Test
+    fun descendants() {
+        assertContentEquals(listOf(n2, n4, n5, n3, n6), root.descendants())
+    }
+}
--- a/src/commonTest/kotlin/com.github.adriankuta/datastructure.tree/TreeNodeSequenceTest.kt
+++ b/src/commonTest/kotlin/com.github.adriankuta/datastructure.tree/TreeNodeSequenceTest.kt
@@ -0,0 +1,46 @@
+package com.github.adriankuta.datastructure.tree
+
+import com.github.adriankuta.datastructure.tree.iterators.TreeNodeIterators
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+
+class TreeNodeSequenceTest {
+
+    private fun sample() = tree(1) {
+        child(2) {
+            child(4)
+            child(5)
+        }
+        child(3) {
+            child(6)
+        }
+    }
+
+    @Test
+    fun preOrderSequence() =
+        assertContentEquals(listOf(1, 2, 4, 5, 3, 6), sample().preOrderSequence().map { it.value }.toList())
+
+    @Test
+    fun postOrderSequence() =
+        assertContentEquals(listOf(4, 5, 2, 6, 3, 1), sample().postOrderSequence().map { it.value }.toList())
+
+    @Test
+    fun levelOrderSequence() =
+        assertContentEquals(listOf(1, 2, 3, 4, 5, 6), sample().levelOrderSequence().map { it.value }.toList())
+
+    @Test
+    fun asSequenceDefaultsToPreOrder() =
+        assertContentEquals(listOf(1, 2, 4, 5, 3, 6), sample().asSequence().map { it.value }.toList())
+
+    @Test
+    fun asSequenceHonorsExplicitOrder() =
+        assertContentEquals(
+            listOf(1, 2, 3, 4, 5, 6),
+            sample().asSequence(TreeNodeIterators.LevelOrder).map { it.value }.toList(),
+        )
+
+    @Test
+    fun sequenceShortCircuitsLazily() =
+        assertEquals(4, sample().preOrderSequence().map { it.value }.first { it == 4 })
+}
--- a/src/commonTest/kotlin/com.github.adriankuta/datastructure.tree/TreeNodeStackSafetyTest.kt
+++ b/src/commonTest/kotlin/com.github.adriankuta/datastructure.tree/TreeNodeStackSafetyTest.kt
@@ -0,0 +1,49 @@
+package com.github.adriankuta.datastructure.tree
+
+import com.github.adriankuta.datastructure.tree.iterators.TreeNodeIterators
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+/**
+ * A deep, degenerate (linear) tree must not overflow the call stack. These tests build a chain
+ * thousands of nodes deep — recursive implementations of [TreeNode.height], [TreeNode.nodeCount]
+ * and the post-order iterator blow the stack here, so they pin the iterative rewrites.
+ */
+class TreeNodeStackSafetyTest {
+
+    private val depth = 50_000
+
+    private fun deepChain(): TreeNode<Int> {
+        val root = TreeNode(0)
+        var current = root
+        for (i in 1..depth) {
+            val child = TreeNode(i)
+            current.addChild(child)
+            current = child
+        }
+        return root
+    }
+
+    @Test
+    fun heightDoesNotOverflowOnDeepTree() {
+        assertEquals(depth, deepChain().height())
+    }
+
+    @Test
+    fun nodeCountDoesNotOverflowOnDeepTree() {
+        // nodeCount() excludes the root, so a chain of `depth` extra nodes counts as `depth`.
+        assertEquals(depth, deepChain().nodeCount())
+    }
+
+    @Test
+    fun postOrderIterationDoesNotOverflowOnDeepTree() {
+        val tree = deepChain().apply { treeIterator = TreeNodeIterators.PostOrder }
+        assertEquals(depth + 1, tree.toList().size)
+    }
+
+    @Test
+    fun preOrderIterationDoesNotOverflowOnDeepTree() {
+        val tree = deepChain().apply { treeIterator = TreeNodeIterators.PreOrder }
+        assertEquals(depth + 1, tree.toList().size)
+    }
+}
--- a/src/commonTest/kotlin/com.github.adriankuta/datastructure.tree/TreeNodeTest.kt
+++ b/src/commonTest/kotlin/com.github.adriankuta/datastructure.tree/TreeNodeTest.kt
@@ -4,7 +4,9 @@ import com.github.adriankuta.datastructure.tree.iterators.TreeNodeIterators
 import kotlin.test.Test
 import kotlin.test.assertContentEquals
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
 import kotlin.test.assertNull
+import kotlin.test.assertTrue

 class TreeNodeTest {

@@ -62,6 +64,18 @@ class TreeNodeTest {
        )
    }

+    @Test
+    fun removeChildReturnsTrueWhenPresentFalseOtherwise() {
+        val root = TreeNode("Root")
+        val child = TreeNode("Child")
+        root.addChild(child)
+
+        assertTrue(root.removeChild(child), "Removing a present child returns true")
+        assertFalse(root.removeChild(child), "Removing an already-removed child returns false")
+        assertNull(child.parent, "Removed child is detached from its parent")
+        assertEquals(emptyList(), root.children)
+    }
+
    @Test
    fun clearTest() {
        val root = TreeNode("Root")
--- a/src/commonTest/kotlin/com.github.adriankuta/datastructure.tree/TreeNodeUtilitiesTest.kt
+++ b/src/commonTest/kotlin/com.github.adriankuta/datastructure.tree/TreeNodeUtilitiesTest.kt
@@ -0,0 +1,54 @@
+package com.github.adriankuta.datastructure.tree
+
+import com.github.adriankuta.datastructure.tree.exceptions.TreeNodeException
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+
+class TreeNodeUtilitiesTest {
+
+    private val root = TreeNode(1)
+    private val a = TreeNode(2)
+    private val b = TreeNode(3)
+
+    init {
+        root.addChild(a)
+        a.addChild(b)
+    }
+
+    @Test
+    fun nodeCountCountsDescendantsExcludingRoot() {
+        assertEquals(0, TreeNode("solo").nodeCount())
+        assertEquals(2, root.nodeCount())
+    }
+
+    @Test
+    fun heightIsLongestEdgePathToLeaf() {
+        assertEquals(0, TreeNode("solo").height())
+        assertEquals(2, root.height())
+        assertEquals(1, a.height())
+    }
+
+    @Test
+    fun depthIsDistanceToRoot() {
+        assertEquals(0, root.depth())
+        assertEquals(1, a.depth())
+        assertEquals(2, b.depth())
+    }
+
+    @Test
+    fun pathReturnsDescendantToReceiverChain() {
+        assertContentEquals(listOf(b, a, root), root.path(b))
+    }
+
+    @Test
+    fun pathThrowsWhenNotADescendant() {
+        assertFailsWith<TreeNodeException> { root.path(TreeNode(99)) }
+    }
+
+    @Test
+    fun pathThrowsWhenDescendantIsRootItself() {
+        assertFailsWith<TreeNodeException> { root.path(root) }
+    }
+}
--- a/src/jvmMain/kotlin/Example.ws.kts
+++ b/src/jvmMain/kotlin/Example.ws.kts
@@ -1,14 +0,0 @@
-import com.github.adriankuta.datastructure.tree.tree
-
-val root =
-    tree("World") {
-        child("North America") {
-            child("USA")
-        }
-        child("Europe") {
-            child("Poland")
-            child("Germany")
-        }
-    }
-
-print(root.prettyString())
--- a/tree-structure-coroutines/api/tree-structure-coroutines.api
+++ b/tree-structure-coroutines/api/tree-structure-coroutines.api
@@ -0,0 +1,8 @@
+public final class com/github/adriankuta/datastructure/tree/coroutines/TreeNodeFlowExtKt {
+	public static final fun asFlow (Lcom/github/adriankuta/datastructure/tree/TreeNode;Lcom/github/adriankuta/datastructure/tree/iterators/TreeNodeIterators;)Lkotlinx/coroutines/flow/Flow;
+	public static synthetic fun asFlow$default (Lcom/github/adriankuta/datastructure/tree/TreeNode;Lcom/github/adriankuta/datastructure/tree/iterators/TreeNodeIterators;ILjava/lang/Object;)Lkotlinx/coroutines/flow/Flow;
+	public static final fun levelOrderFlow (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Lkotlinx/coroutines/flow/Flow;
+	public static final fun postOrderFlow (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Lkotlinx/coroutines/flow/Flow;
+	public static final fun preOrderFlow (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Lkotlinx/coroutines/flow/Flow;
+}
+
--- a/tree-structure-coroutines/build.gradle.kts
+++ b/tree-structure-coroutines/build.gradle.kts
@@ -0,0 +1,88 @@
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
+
+plugins {
+    alias(libs.plugins.kotlinMultiplatform)
+    alias(libs.plugins.dokka)
+    alias(libs.plugins.mavenPublish)
+    signing
+}
+
+group = "com.github.adriankuta"
+version = rootProject.version
+
+mavenPublishing {
+    publishToMavenCentral(automaticRelease = false)
+    signAllPublications()
+
+    coordinates("com.github.adriankuta", "tree-structure-coroutines", version.toString())
+
+    pom {
+        name.set("Tree Data Structure — coroutines")
+        description.set("kotlinx.coroutines Flow traversal for the tree-structure library.")
+        url.set("https://github.com/AdrianKuta/Tree-Data-Structure")
+        licenses {
+            license {
+                name.set("MIT License")
+                url.set("https://opensource.org/licenses/MIT")
+                distribution.set("repo")
+            }
+        }
+        developers {
+            developer {
+                id.set("AdrianKuta")
+                name.set("Adrian Kuta")
+                email.set("adrian.kuta93@gmail.com")
+            }
+        }
+        scm {
+            url.set("https://github.com/AdrianKuta/Tree-Data-Structure")
+            connection.set("scm:git:https://github.com/AdrianKuta/Tree-Data-Structure.git")
+            developerConnection.set("scm:git:ssh://git@github.com/AdrianKuta/Tree-Data-Structure.git")
+        }
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+kotlin {
+    jvmToolchain(21)
+
+    jvm()
+
+    js(IR) {
+        browser()
+        nodejs()
+    }
+
+    @OptIn(ExperimentalWasmDsl::class)
+    wasmJs {
+        browser()
+        nodejs()
+    }
+
+    iosX64()
+    iosArm64()
+    iosSimulatorArm64()
+
+    val hostOs = System.getProperty("os.name")
+    val isMingwX64 = hostOs.startsWith("Windows")
+    when {
+        hostOs == "Mac OS X" -> macosX64("native")
+        hostOs == "Linux" -> linuxX64("native")
+        isMingwX64 -> mingwX64("native")
+        else -> throw GradleException("Host OS is not supported in Kotlin/Native.")
+    }
+
+    sourceSets {
+        commonMain.dependencies {
+            api(project(":"))
+            api(libs.kotlinx.coroutines.core)
+        }
+        commonTest.dependencies {
+            implementation(kotlin("test"))
+            implementation(libs.kotlinx.coroutines.test)
+        }
+    }
+}
--- a/tree-structure-coroutines/src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/coroutines/TreeNodeFlowExt.kt
+++ b/tree-structure-coroutines/src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/coroutines/TreeNodeFlowExt.kt
@@ -0,0 +1,24 @@
+package com.github.adriankuta.datastructure.tree.coroutines
+
+import com.github.adriankuta.datastructure.tree.TreeNode
+import com.github.adriankuta.datastructure.tree.asSequence
+import com.github.adriankuta.datastructure.tree.iterators.TreeNodeIterators
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.asFlow
+
+/**
+ * Emits this node and all of its descendants as a cold [Flow], traversed in the given [order].
+ * Useful for plugging tree traversal into coroutine/Flow pipelines (e.g. in a ViewModel).
+ */
+public fun <T> TreeNode<T>.asFlow(
+    order: TreeNodeIterators = TreeNodeIterators.PreOrder,
+): Flow<TreeNode<T>> = asSequence(order).asFlow()
+
+/** Pre-order traversal as a cold [Flow]. */
+public fun <T> TreeNode<T>.preOrderFlow(): Flow<TreeNode<T>> = asFlow(TreeNodeIterators.PreOrder)
+
+/** Post-order traversal as a cold [Flow]. */
+public fun <T> TreeNode<T>.postOrderFlow(): Flow<TreeNode<T>> = asFlow(TreeNodeIterators.PostOrder)
+
+/** Level-order (breadth-first) traversal as a cold [Flow]. */
+public fun <T> TreeNode<T>.levelOrderFlow(): Flow<TreeNode<T>> = asFlow(TreeNodeIterators.LevelOrder)
--- a/tree-structure-coroutines/src/commonTest/kotlin/com.github.adriankuta/datastructure/tree/coroutines/TreeNodeFlowTest.kt
+++ b/tree-structure-coroutines/src/commonTest/kotlin/com.github.adriankuta/datastructure/tree/coroutines/TreeNodeFlowTest.kt
@@ -0,0 +1,35 @@
+package com.github.adriankuta.datastructure.tree.coroutines
+
+import com.github.adriankuta.datastructure.tree.iterators.TreeNodeIterators
+import com.github.adriankuta.datastructure.tree.tree
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.toList
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class TreeNodeFlowTest {
+
+    private fun sample() = tree(1) {
+        child(2) {
+            child(4)
+            child(5)
+        }
+        child(3) {
+            child(6)
+        }
+    }
+
+    @Test
+    fun preOrderFlowEmitsInPreOrder() = runTest {
+        assertEquals(listOf(1, 2, 4, 5, 3, 6), sample().preOrderFlow().map { it.value }.toList())
+    }
+
+    @Test
+    fun levelOrderFlowEmitsInLevelOrder() = runTest {
+        assertEquals(
+            listOf(1, 2, 3, 4, 5, 6),
+            sample().asFlow(TreeNodeIterators.LevelOrder).map { it.value }.toList(),
+        )
+    }
+}
--- a/tree-structure-serialization/api/tree-structure-serialization.api
+++ b/tree-structure-serialization/api/tree-structure-serialization.api
@@ -0,0 +1,35 @@
+public final class com/github/adriankuta/datastructure/tree/serialization/TreeNodeDto {
+	public static final field Companion Lcom/github/adriankuta/datastructure/tree/serialization/TreeNodeDto$Companion;
+	public fun <init> (Ljava/lang/Object;Ljava/util/List;)V
+	public synthetic fun <init> (Ljava/lang/Object;Ljava/util/List;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/Object;
+	public final fun component2 ()Ljava/util/List;
+	public final fun copy (Ljava/lang/Object;Ljava/util/List;)Lcom/github/adriankuta/datastructure/tree/serialization/TreeNodeDto;
+	public static synthetic fun copy$default (Lcom/github/adriankuta/datastructure/tree/serialization/TreeNodeDto;Ljava/lang/Object;Ljava/util/List;ILjava/lang/Object;)Lcom/github/adriankuta/datastructure/tree/serialization/TreeNodeDto;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getChildren ()Ljava/util/List;
+	public final fun getValue ()Ljava/lang/Object;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public synthetic class com/github/adriankuta/datastructure/tree/serialization/TreeNodeDto$$serializer : kotlinx/serialization/internal/GeneratedSerializer {
+	public fun <init> (Lkotlinx/serialization/KSerializer;)V
+	public final fun childSerializers ()[Lkotlinx/serialization/KSerializer;
+	public final fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Lcom/github/adriankuta/datastructure/tree/serialization/TreeNodeDto;
+	public synthetic fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ljava/lang/Object;
+	public final fun getDescriptor ()Lkotlinx/serialization/descriptors/SerialDescriptor;
+	public final fun serialize (Lkotlinx/serialization/encoding/Encoder;Lcom/github/adriankuta/datastructure/tree/serialization/TreeNodeDto;)V
+	public synthetic fun serialize (Lkotlinx/serialization/encoding/Encoder;Ljava/lang/Object;)V
+	public final fun typeParametersSerializers ()[Lkotlinx/serialization/KSerializer;
+}
+
+public final class com/github/adriankuta/datastructure/tree/serialization/TreeNodeDto$Companion {
+	public final fun serializer (Lkotlinx/serialization/KSerializer;)Lkotlinx/serialization/KSerializer;
+}
+
+public final class com/github/adriankuta/datastructure/tree/serialization/TreeNodeDtoKt {
+	public static final fun toDto (Lcom/github/adriankuta/datastructure/tree/TreeNode;)Lcom/github/adriankuta/datastructure/tree/serialization/TreeNodeDto;
+	public static final fun toTreeNode (Lcom/github/adriankuta/datastructure/tree/serialization/TreeNodeDto;)Lcom/github/adriankuta/datastructure/tree/TreeNode;
+}
+
--- a/tree-structure-serialization/build.gradle.kts
+++ b/tree-structure-serialization/build.gradle.kts
@@ -0,0 +1,88 @@
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
+
+plugins {
+    alias(libs.plugins.kotlinMultiplatform)
+    alias(libs.plugins.kotlinSerialization)
+    alias(libs.plugins.dokka)
+    alias(libs.plugins.mavenPublish)
+    signing
+}
+
+group = "com.github.adriankuta"
+version = rootProject.version
+
+mavenPublishing {
+    publishToMavenCentral(automaticRelease = false)
+    signAllPublications()
+
+    coordinates("com.github.adriankuta", "tree-structure-serialization", version.toString())
+
+    pom {
+        name.set("Tree Data Structure — kotlinx.serialization")
+        description.set("kotlinx.serialization support (TreeNodeDto round-trip) for the tree-structure library.")
+        url.set("https://github.com/AdrianKuta/Tree-Data-Structure")
+        licenses {
+            license {
+                name.set("MIT License")
+                url.set("https://opensource.org/licenses/MIT")
+                distribution.set("repo")
+            }
+        }
+        developers {
+            developer {
+                id.set("AdrianKuta")
+                name.set("Adrian Kuta")
+                email.set("adrian.kuta93@gmail.com")
+            }
+        }
+        scm {
+            url.set("https://github.com/AdrianKuta/Tree-Data-Structure")
+            connection.set("scm:git:https://github.com/AdrianKuta/Tree-Data-Structure.git")
+            developerConnection.set("scm:git:ssh://git@github.com/AdrianKuta/Tree-Data-Structure.git")
+        }
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+kotlin {
+    jvmToolchain(21)
+
+    jvm()
+
+    js(IR) {
+        browser()
+        nodejs()
+    }
+
+    @OptIn(ExperimentalWasmDsl::class)
+    wasmJs {
+        browser()
+        nodejs()
+    }
+
+    iosX64()
+    iosArm64()
+    iosSimulatorArm64()
+
+    val hostOs = System.getProperty("os.name")
+    val isMingwX64 = hostOs.startsWith("Windows")
+    when {
+        hostOs == "Mac OS X" -> macosX64("native")
+        hostOs == "Linux" -> linuxX64("native")
+        isMingwX64 -> mingwX64("native")
+        else -> throw GradleException("Host OS is not supported in Kotlin/Native.")
+    }
+
+    sourceSets {
+        commonMain.dependencies {
+            api(project(":"))
+            api(libs.kotlinx.serialization.json)
+        }
+        commonTest.dependencies {
+            implementation(kotlin("test"))
+        }
+    }
+}
--- a/tree-structure-serialization/src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/serialization/TreeNodeDto.kt
+++ b/tree-structure-serialization/src/commonMain/kotlin/com.github.adriankuta/datastructure/tree/serialization/TreeNodeDto.kt
@@ -0,0 +1,30 @@
+package com.github.adriankuta.datastructure.tree.serialization
+
+import com.github.adriankuta.datastructure.tree.TreeNode
+import kotlinx.serialization.Serializable
+
+/**
+ * A serializable, acyclic view of a [TreeNode] subtree. [TreeNode] itself holds a back-reference to
+ * its parent (a cycle), so it cannot be `@Serializable` directly — convert to/from this DTO instead.
+ *
+ * ```
+ * val json = Json.encodeToString(tree.toDto())
+ * val restored = Json.decodeFromString<TreeNodeDto<String>>(json).toTreeNode()
+ * ```
+ */
+@Serializable
+public data class TreeNodeDto<T>(
+    val value: T,
+    val children: List<TreeNodeDto<T>> = emptyList(),
+)
+
+/** Converts this subtree into a serializable [TreeNodeDto], preserving values and shape. */
+public fun <T> TreeNode<T>.toDto(): TreeNodeDto<T> =
+    TreeNodeDto(value, children.map { it.toDto() })
+
+/** Rebuilds a mutable [TreeNode] tree from this DTO. */
+public fun <T> TreeNodeDto<T>.toTreeNode(): TreeNode<T> {
+    val node = TreeNode(value)
+    children.forEach { node.addChild(it.toTreeNode()) }
+    return node
+}
--- a/tree-structure-serialization/src/commonTest/kotlin/com.github.adriankuta/datastructure/tree/serialization/TreeNodeSerializationTest.kt
+++ b/tree-structure-serialization/src/commonTest/kotlin/com.github.adriankuta/datastructure/tree/serialization/TreeNodeSerializationTest.kt
@@ -0,0 +1,40 @@
+package com.github.adriankuta.datastructure.tree.serialization
+
+import com.github.adriankuta.datastructure.tree.structurallyEquals
+import com.github.adriankuta.datastructure.tree.tree
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class TreeNodeSerializationTest {
+
+    @Test
+    fun roundTripsThroughJson() {
+        val original = tree("World") {
+            child("North America") { child("USA") }
+            child("Europe") {
+                child("Poland")
+                child("Germany")
+            }
+        }
+
+        val json = Json.encodeToString(original.toDto())
+        val restored = Json.decodeFromString<TreeNodeDto<String>>(json).toTreeNode()
+
+        assertTrue(original.structurallyEquals(restored))
+    }
+
+    @Test
+    fun dtoMirrorsTreeShape() {
+        val dto = tree(1) {
+            child(2)
+            child(3) { child(4) }
+        }.toDto()
+
+        assertEquals(1, dto.value)
+        assertEquals(2, dto.children.size)
+        assertEquals(4, dto.children[1].children[0].value)
+    }
+}
Author	SHA1	Message	Date
Adrian Kuta	c9bbea59b0	ci: binary-compat API baselines, multiplatform matrix CI, module docs - Commit binary-compatibility-validator .api baselines for core + both modules. - Replace JVM-only CI with a matrix: Ubuntu runs JVM/JS(node)/Wasm(node)/Native + apiCheck; macOS runs the iOS simulator tests. - README: install + usage for tree-structure-serialization and -coroutines. - Update kotlin-js-store/yarn.lock for the new modules' JS test deps. Verified locally: JVM, JS(node), Wasm(node) and iOS-simulator tests pass for core + both modules; native compiles & links (exec runs on the Linux CI runner).	2026-06-06 13:51:22 +02:00
Adrian Kuta	e1f01c4e2d	feat: Kotlin 2.x/K2, version catalog, serialization & coroutines modules, docs v3.4 modernization (continued): - Migrate to Kotlin 2.x (K2); introduce gradle/libs.versions.toml version catalog; simplify the JS/Wasm/Node and iOS source-set wiring for the K2 hierarchy template. - Apply binary-compatibility-validator and Kover plugins. - New published module tree-structure-serialization: @Serializable TreeNodeDto with toDto()/toTreeNode() round-trip (kotlinx.serialization). - New published module tree-structure-coroutines: asFlow()/pre/post/levelOrderFlow() (kotlinx.coroutines Flow traversal). - Docs: README examples for Sequence/navigation/functional APIs, class-level KDoc (thread-safety/complexity), and a CHANGELOG.md. - Ignore subproject build/ directories. - Bump version to 3.4.0. All JVM tests green (core + both modules).	2026-06-06 13:47:20 +02:00
Adrian Kuta	c45c5b7afa	feat: stack-safe traversal + lazy Sequence + navigation/functional extensions Core additive work for v3.4 (non-breaking): - Rewrite nodeCount(), height(), clear() and the post-order iterator iteratively so deep/degenerate trees no longer throw StackOverflowError (verified to 50k deep). - Add lazy Sequence traversal: asSequence(order), pre/post/levelOrderSequence(). - Add navigation extensions: isLeaf, degree, root(), ancestors(), siblings(), leaves(), descendants(). - Add functional extensions: findNode, filterNodes, anyNode, allNodes, countNodes, foldNodes, mapValues, deepCopy, structurallyEquals (all stack-safe). - Add tests for stack-safety, the new APIs, and previously-uncovered height/depth/nodeCount/path (incl. exception paths). 40 tests green on JVM.	2026-06-06 13:35:39 +02:00
Adrian Kuta	6de95f7976	Release 3.1.5: remove debug println, drop worksheet leftover, modernize CI - Remove stray println(child.value) from TreeNode.removeChild() - Add regression test for removeChild() return value - Delete leftover ExampleUnitTest.kt template test - Remove Example.ws.kts worksheet and kotlin("script-runtime") from jvmMain - Bump actions/checkout v2 -> v4 in CI workflows - Update README install snippets to 3.1.5 - Bump version to 3.1.5	2026-06-06 13:03:00 +02:00
Adrian Kuta	ea0b4fa95c	Bump version to 3.1.4	2025-12-25 22:53:43 +01:00
Adrian Kuta	9d52b152bd	Merge pull request #31 from AdrianKuta/develop Develop	2025-12-25 22:46:09 +01:00
Adrian Kuta	0fc7b16664	feat: Update Kotlin and JS dependencies and add Wasm target (#30 ) - Upgraded Kotlin from `1.9.20` to `1.9.24`. - Added a new Kotlin/Wasm target (`wasmJs`) for both browser and Node.js environments. - Updated numerous JavaScript dependencies in `yarn.lock`, including major upgrades for `webpack`, `terser`, and various `@webpack-cli`, `@jridgewell`, and `@webassemblyjs` packages. - Configured the Node.js version to `22.0.0` for JS and Wasm targets.	2025-12-25 22:43:29 +01:00
Adrian Kuta	d3086a5ced	chore: Remove Dependabot configuration Removes the `.github/dependabot.yml` file, disabling the Dependabot version update checks for the project.	2025-12-25 22:43:17 +01:00
Adrian Kuta	2071084964	Bump version to 3.1.3	2025-12-25 22:41:48 +01:00
Adrian Kuta	f51964831a	feat: Ignore .idea directory - Adds the entire `.idea/` directory to `.gitignore` to prevent IDE-specific files from being committed.	2025-12-25 22:29:06 +01:00
Adrian Kuta	60c50f078d	Bump version to 3.1.2	2025-10-14 18:47:18 +02:00
Adrian Kuta	54f5074483	26-add-ios-target (#28 ) * Refactor: Modernize build and publishing workflow - Upgraded Kotlin from 1.7.20 to 1.9.20. - Upgraded JDK from 11 to 21 across all GitHub Actions workflows. - Replaced the legacy `maven-publish` plugin with `com.vanniktech.maven.publish` for simplified publishing to Maven Central. - Removed the `publishSnapshot.yml` workflow, as snapshot publishing is now managed by the new plugin. - Updated `publishRelease.yml` to use the `publishToMavenCentral` task and new secrets (`MAVEN_CENTRAL_USERNAME`, `MAVEN_CENTRAL_PASSWORD`). - Simplified `build.gradle.kts` by removing manual publishing and signing logic. - Set the JVM target to "21". - Bumped the project version to `3.1.1`. - Removed `js` targets and related configurations. - Added a new code style configuration file for the project (`.idea/codeStyles/Project.xml`). * fix: Add JavaScript targets - Added JS (IR) targets (`browser` and `nodejs`) to the Kotlin Multiplatform configuration for publishing. * Improve README and document new publishing workflow - Expanded the project description to highlight key features like Kotlin Multiplatform support, traversal iterators, DSL, and utility functions. - Added a new "Installation" section with instructions for Gradle (Kotlin/Groovy) and Maven. - Added a "Traversal and utilities" section to demonstrate usage of iterators and helper functions. - Replaced the old publishing documentation with updated instructions for publishing to Maven Central via the Central Portal. - Detailed the two publishing methods: automatically via GitHub Actions on release and manually via local Gradle commands. - Clarified required secrets and environment variables for the new publishing process.	2025-10-14 18:46:05 +02:00