diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
index 5a49c050a0..d7bf8ad691 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
@@ -10,16 +10,77 @@ import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
 import org.jetbrains.kotlinx.dataframe.annotations.Refine
 import org.jetbrains.kotlinx.dataframe.annotations.RequiredByIntellijPlugin
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
+import org.jetbrains.kotlinx.dataframe.documentation.DocumentationUrls
+import org.jetbrains.kotlinx.dataframe.documentation.ExcludeFromSources
+import org.jetbrains.kotlinx.dataframe.documentation.NALink
+import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns
 import org.jetbrains.kotlinx.dataframe.impl.nameGenerator
 import org.jetbrains.kotlinx.dataframe.util.DEPRECATED_ACCESS_API
 import kotlin.reflect.KProperty
 import kotlin.reflect.full.withNullability
 import kotlin.reflect.typeOf
 
+// region docs
+
+/**
+ * @param [sort\] If `true` (default), the result is sorted by count.
+ * Otherwise, the counted values keep the order of their first occurrence.
+ * @param [ascending\] The sorting direction. If `false` (default), the most frequent values come first.
+ * Only used when [sort\] is `true`.
+ * @param [dropNA\] If `true` (default), {@include [NALink]} values (`null`s and `NaN`s) are not counted
+ * and are excluded from the result.
+ * @param [resultColumn\] The name of the resulting count column. Default — `"count"`.
+ * If a column with this name is already present, the name is made unique by appending
+ * a number to it (for example, `"count"` becomes `"count1"`).
+ */
+@ExcludeFromSources
+private typealias ValueCountsParams = Nothing
+
+/**
+ * Returns a [DataFrame] containing the counts of unique rows (or combinations of selected values) in this [DataFrame].
+ *
+ * Rows are compared by the values in the selected [columns\]. If no columns are selected, values from
+ * all columns are used.
+ *
+ * {@include [SelectingColumns.ColumnGroupsAndNestedColumnsSnippet]}
+ *
+ * The resulting [DataFrame] contains:
+ * - the distinct combinations of these values,
+ * - a new [Int] column (named [resultColumn\], default is `"count"`) with the number of occurrences of each combination.
+ *
+ * By default, the result is sorted by count in descending order (the most frequent combination first),
+ * and a row is not counted at all if any of its selected values is {@include [NALink]}.
+ *
+ * See also:
+ * - [`valueCounts`][DataColumn.valueCounts] — counts of unique values in a single [DataColumn].
+ * - [`countDistinct`][DataFrame.countDistinct] — the number of distinct rows or selected value combinations,
+ * without their counts.
+ * - [`distinct`][DataFrame.distinct] — the distinct rows themselves, without their counts.
+ * - [`count`][DataFrame.count] — the total number of rows in this [DataFrame].
+ *
+ * For more information: {@include [DocumentationUrls.ValueCounts]}
+ *
+ * All summary statistics: {@include [DocumentationUrls.Statistics]}
+ *
+ * ### This `valueCounts` Overload
+ */
+@ExcludeFromSources
+private typealias CommonValueCountsDocs = Nothing
+
+// endregion
+
 // region DataSchema
 
+/**
+ * A [DataSchema] of the [valueCounts] result. It declares the [count] column
+ * with the number of occurrences of each counted value.
+ *
+ * For more information: {@include [DocumentationUrls.ValueCounts]}
+ */
 @DataSchema
 public interface ValueCount {
+
+    /** The number of occurrences of the value (or combination of values) in this row. */
     public val count: Int
 }
 
@@ -29,6 +90,42 @@ public interface ValueCount {
 
 internal val defaultCountColumnName: String = ValueCount::count.name
 
+/**
+ * Returns a [DataFrame] containing counts of unique values in this [DataColumn].
+ *
+ * The resulting [DataFrame] contains:
+ * - the column with the distinct values of the original [DataColumn]
+ * - a new [Int] column ([resultColumn]) with the number of occurrences of each value.
+ *
+ * By default, the result is sorted by count in descending order (the most frequent value first),
+ * and {@include [NALink]} values (`null`s and `NaN`s) are not counted.
+ *
+ * See also:
+ * - [`valueCounts`][DataFrame.valueCounts] — counts of unique rows in a [DataFrame].
+ * - [`countDistinct`][DataFrame.countDistinct] — the number of distinct rows
+ * or selected value combinations in a [DataFrame].
+ * - [`distinct`][DataColumn.distinct] — the distinct values themselves, without their counts.
+ * - [`count`][DataColumn.count] — the total number of elements in this [DataColumn].
+ *
+ * For more information: {@include [DocumentationUrls.ValueCounts]}
+ *
+ * All summary statistics: {@include [DocumentationUrls.Statistics]}
+ *
+ * ### Example
+ *
+ * ```kotlin
+ * // Counts the unique values in the "city" column,
+ * // starting with the most frequent one
+ * df.city.valueCounts()
+ *
+ * // Counts the unique values in the "city" column, including `null`s,
+ * // in the order of their first occurrence, in a column named "quantity"
+ * df.city.valueCounts(sort = false, dropNA = false, resultColumn = "quantity")
+ * ```
+ *
+ * @include [ValueCountsParams]
+ * @return A [DataFrame] with the distinct values of this [DataColumn] and their counts.
+ */
 @RequiredByIntellijPlugin
 public fun <T> DataColumn<T>.valueCounts(
     sort: Boolean = true,
@@ -56,6 +153,27 @@ public fun <T> DataColumn<T>.valueCounts(
 
 // region DataFrame
 
+/**
+ * {@include [CommonValueCountsDocs]}
+ * {@include [SelectingColumns.ColumnsSelectionDsl]}
+ *
+ * #### Example
+ *
+ * ```kotlin
+ * // Counts the unique combinations of the values in the "name" and "city" columns,
+ * // starting with the most frequent one
+ * df.valueCounts { name and city }
+ *
+ * // Counts the unique rows of the whole dataframe,
+ * // including rows with `NA` values, in the order of their first occurrence
+ * df.valueCounts(sort = false, dropNA = false)
+ * ```
+ *
+ * @include [ValueCountsParams]
+ * @param [columns] The optional [ColumnsSelector] that selects the columns whose distinct value combinations
+ * are counted. If `null` or omitted, all columns are used.
+ * @return A [DataFrame] with the distinct value combinations and their counts.
+ */
 @Refine
 @Interpretable("ValueCounts")
 public fun <T> DataFrame<T>.valueCounts(
@@ -78,6 +196,23 @@ public fun <T> DataFrame<T>.valueCounts(
         .cast()
 }
 
+/**
+ * {@include [CommonValueCountsDocs]}
+ * {@include [SelectingColumns.ColumnNamesApi]}
+ *
+ * #### Example
+ *
+ * ```kotlin
+ * // Counts the unique combinations of the values in the "name" and "city" columns,
+ * // starting with the most frequent one
+ * df.valueCounts("name", "city")
+ * ```
+ *
+ * @param [columns] (optional) The names of the columns whose distinct value combinations are counted. If not supplied,
+ * all columns are selected.
+ * @include [ValueCountsParams]
+ * @return A [DataFrame] with the distinct value combinations and their counts.
+ */
 public fun <T> DataFrame<T>.valueCounts(
     vararg columns: String,
     sort: Boolean = true,
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
index 949e7dc527..c5b5be4077 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/documentation/DocumentationUrls.kt
@@ -140,6 +140,9 @@ public interface DocumentationUrls {
     /** [See `countDistinct` on the documentation website.]({@include [Url]}/countdistinct.html) */
     public typealias CountDistinct = Nothing
 
+    /** [See `valueCounts` on the documentation website.]({@include [Url]}/valuecounts.html) */
+    public typealias ValueCounts = Nothing
+
     /** [See `explode` on the documentation website.]({@include [Url]}/explode.html) */
     public typealias Explode = Nothing
 
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
new file mode 100644
index 0000000000..b0a3fcbfe3
--- /dev/null
+++ b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/valueCounts.kt
@@ -0,0 +1,269 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.junit.Test
+import kotlin.reflect.typeOf
+
+class ValueCountsTests {
+
+    private val df = dataFrameOf(
+        "name" to columnOf("Alice", "Bob", "Alice", "Charlie", "Alice"),
+        "city" to columnOf("London", "London", "London", "Moscow", "Paris"),
+        "age" to columnOf(15, 20, 15, 30, 15),
+    )
+
+    // region DataColumn
+
+    @Test
+    fun `value counts of a column`() {
+        val languages by columnOf("Kotlin", "Kotlin", null, null, "C++")
+        val languageCounts = languages.valueCounts()
+        languageCounts["languages"].values() shouldBe listOf("Kotlin", "C++")
+        languageCounts.count.values() shouldBe listOf(2, 1)
+    }
+
+    @Test
+    fun `value counts of a column keeps the column name and adds an Int count column`() {
+        val result = df["city"].valueCounts()
+
+        result.columnNames() shouldBe listOf("city", "count")
+        result["city"].type() shouldBe typeOf<String>()
+        result["count"].type() shouldBe typeOf<Int>()
+    }
+
+    @Test
+    fun `value counts of a column is sorted by count descending by default`() {
+        val result = df["city"].valueCounts()
+
+        result["city"].values() shouldBe listOf("London", "Moscow", "Paris")
+        result["count"].values() shouldBe listOf(3, 1, 1)
+    }
+
+    @Test
+    fun `value counts of a column with ascending sorting`() {
+        val result = df["city"].valueCounts(ascending = true)
+
+        result["city"].values() shouldBe listOf("Moscow", "Paris", "London")
+        result["count"].values() shouldBe listOf(1, 1, 3)
+    }
+
+    @Test
+    fun `value counts of a column without sorting keeps the order of the first occurrence`() {
+        val result = df["name"].valueCounts(sort = false)
+
+        result["name"].values() shouldBe listOf("Alice", "Bob", "Charlie")
+        result["count"].values() shouldBe listOf(3, 1, 1)
+    }
+
+    @Test
+    fun `value counts of a column drops NA values by default`() {
+        val values by columnOf(1.0, null, Double.NaN, 1.0, null, 2.0)
+        val result = values.valueCounts()
+
+        result["values"].values() shouldBe listOf(1.0, 2.0)
+        result["values"].type() shouldBe typeOf<Double>()
+        result.count.values() shouldBe listOf(2, 1)
+    }
+
+    @Test
+    fun `value counts of a column with dropNA false counts nulls`() {
+        val values by columnOf(1.0, null, 1.0, 2.0, null)
+        val result = values.valueCounts(dropNA = false, sort = false)
+
+        result["values"].values() shouldBe listOf(1.0, null, 2.0)
+        result["values"].type() shouldBe typeOf<Double?>()
+        result.count.values() shouldBe listOf(2, 2, 1)
+    }
+
+    @Test
+    fun `value counts of a column with dropNA false counts NaNs`() {
+        val values by columnOf(1.0, Double.NaN, 1.0, Double.NaN, 2.0)
+        val result = values.valueCounts(dropNA = false, sort = false)
+        val resultValues = result["values"].values().toList()
+
+        resultValues[0] shouldBe 1.0
+        (resultValues[1] as Double).isNaN() shouldBe true
+        resultValues[2] shouldBe 2.0
+        result.count.values() shouldBe listOf(2, 2, 1)
+    }
+
+    @Test
+    fun `value counts of a column with a custom result column name`() {
+        val result = df["city"].valueCounts(resultColumn = "number")
+
+        result.columnNames() shouldBe listOf("city", "number")
+        result["number"].values() shouldBe listOf(3, 1, 1)
+    }
+
+    @Test
+    fun `value counts of an empty column`() {
+        val result = df["city"].filter { false }.valueCounts()
+
+        result.columnNames() shouldBe listOf("city", "count")
+        result.rowsCount() shouldBe 0
+    }
+
+    @Test
+    fun `value counts of a column with a result column name clashing with the column name`() {
+        val count by columnOf("a", "b", "a")
+        val result = count.valueCounts()
+
+        result.columnNames() shouldBe listOf("count", "count1")
+        result["count"].values() shouldBe listOf("a", "b")
+        result["count1"].values() shouldBe listOf(2, 1)
+    }
+
+    // endregion
+
+    // region DataFrame
+
+    @Test
+    fun `value counts of a DataFrame counts distinct rows`() {
+        val result = df.valueCounts()
+
+        result shouldBe dataFrameOf(
+            "name" to columnOf("Alice", "Bob", "Charlie", "Alice"),
+            "city" to columnOf("London", "London", "Moscow", "Paris"),
+            "age" to columnOf(15, 20, 30, 15),
+            "count" to columnOf(2, 1, 1, 1),
+        )
+    }
+
+    @Test
+    fun `value counts of a DataFrame with a columns selector`() {
+        val result = df.valueCounts { "name"<String>() and "city"<String>() }
+
+        result shouldBe dataFrameOf(
+            "name" to columnOf("Alice", "Bob", "Charlie", "Alice"),
+            "city" to columnOf("London", "London", "Moscow", "Paris"),
+            "count" to columnOf(2, 1, 1, 1),
+        )
+    }
+
+    @Test
+    fun `value counts of a DataFrame with a single selected column`() {
+        val result = df.valueCounts { "city"<String>() }
+
+        result shouldBe dataFrameOf(
+            "city" to columnOf("London", "Moscow", "Paris"),
+            "count" to columnOf(3, 1, 1),
+        )
+    }
+
+    @Test
+    fun `value counts of a DataFrame by column names`() {
+        df.valueCounts("name", "city") shouldBe df.valueCounts { "name"<String>() and "city"<String>() }
+    }
+
+    @Test
+    fun `value counts of a DataFrame without sorting keeps the order of the first occurrence`() {
+        val result = df.valueCounts(sort = false) { "city"<String>() }
+
+        result["city"].values() shouldBe listOf("London", "Moscow", "Paris")
+        result["count"].values() shouldBe listOf(3, 1, 1)
+    }
+
+    @Test
+    fun `value counts of a DataFrame with ascending sorting`() {
+        val result = df.valueCounts(ascending = true) { "city"<String>() }
+
+        result["city"].values() shouldBe listOf("Moscow", "Paris", "London")
+        result["count"].values() shouldBe listOf(1, 1, 3)
+    }
+
+    @Test
+    fun `value counts of a DataFrame drops rows with NA in any selected column by default`() {
+        val dfWithNulls = dataFrameOf(
+            "name" to columnOf("Alice", "Bob", null, "Alice"),
+            "city" to columnOf("London", null, "Moscow", "London"),
+            "weight" to columnOf(50.0, 60.0, null, Double.NaN),
+        )
+        val result = dfWithNulls.valueCounts()
+
+        result.columnNames() shouldBe listOf("name", "city", "weight", "count")
+        result["name"].values() shouldBe listOf("Alice")
+        result["city"].values() shouldBe listOf("London")
+        result["count"].values() shouldBe listOf(1)
+    }
+
+    @Test
+    fun `value counts of a DataFrame ignores NA in columns that are not selected`() {
+        val dfWithNulls = dataFrameOf(
+            "name" to columnOf("Alice", "Bob", "Alice"),
+            "city" to columnOf("London", null, "London"),
+            "weight" to columnOf(50.0, 60.0, Double.NaN),
+        )
+        val result = dfWithNulls.valueCounts { "name"<String>() }
+
+        result.columnNames() shouldBe listOf("name", "count")
+        result["name"].values() shouldBe listOf("Alice", "Bob")
+        result["count"].values() shouldBe listOf(2, 1)
+    }
+
+    @Test
+    fun `value counts of a DataFrame with dropNA false counts rows with NA`() {
+        val dfWithNulls = dataFrameOf(
+            "name" to columnOf("Alice", "Bob", null, "Alice"),
+            "city" to columnOf("London", null, "Moscow", "London"),
+            "weight" to columnOf(50.0, 60.0, null, Double.NaN),
+        )
+        val result = dfWithNulls.valueCounts(dropNA = false, sort = false)
+        val weightValues = result["weight"].values().toList()
+
+        result["name"].values() shouldBe listOf("Alice", "Bob", null, "Alice")
+        result["city"].values() shouldBe listOf("London", null, "Moscow", "London")
+        result["count"].values() shouldBe listOf(1, 1, 1, 1)
+        weightValues[0] shouldBe 50.0
+        weightValues[1] shouldBe 60.0
+        weightValues[2] shouldBe null
+        (weightValues[3] as Double).isNaN() shouldBe true
+    }
+
+    @Test
+    fun `value counts of a DataFrame with a custom result column name`() {
+        val result = df.valueCounts(resultColumn = "occurrences") { "city"<String>() }
+
+        result.columnNames() shouldBe listOf("city", "occurrences")
+        result["city"].values() shouldBe listOf("London", "Moscow", "Paris")
+        result["occurrences"].values() shouldBe listOf(3, 1, 1)
+    }
+
+    @Test
+    fun `value counts of a DataFrame with a result column name clashing with a selected column`() {
+        val result = df.valueCounts(resultColumn = "city") { "city"<String>() }
+
+        result.columnNames() shouldBe listOf("city", "city1")
+        result["city"].values() shouldBe listOf("London", "Moscow", "Paris")
+        result["city1"].values() shouldBe listOf(3, 1, 1)
+    }
+
+    @Test
+    fun `value counts of a DataFrame with a result column name clashing with a column that is not selected`() {
+        val result = df.valueCounts(resultColumn = "age") { "city"<String>() }
+
+        result.columnNames() shouldBe listOf("city", "age1")
+        result["age1"].values() shouldBe listOf(3, 1, 1)
+    }
+
+    @Test
+    fun `value counts of a DataFrame with a default result column name clashing with an existing column`() {
+        val dfWithCount = df.add("count") { 1 }
+        val result = dfWithCount.valueCounts { "city"<String>() }
+
+        result.columnNames() shouldBe listOf("city", "count1")
+        result["count1"].values() shouldBe listOf(3, 1, 1)
+    }
+
+    @Test
+    fun `count column of a DataFrame result is of type Int`() {
+        df.valueCounts()["count"].type() shouldBe typeOf<Int>()
+    }
+
+    @Test
+    fun `value counts of an empty DataFrame`() {
+        df.drop(df.nrow).valueCounts().count() shouldBe 0
+    }
+
+    // endregion
+}
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt
index 78eabd1161..2625bc6243 100644
--- a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt
+++ b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Analyze.kt
@@ -39,7 +39,6 @@ import org.jetbrains.kotlinx.dataframe.api.stdOf
 import org.jetbrains.kotlinx.dataframe.api.sum
 import org.jetbrains.kotlinx.dataframe.api.sumFor
 import org.jetbrains.kotlinx.dataframe.api.sumOf
-import org.jetbrains.kotlinx.dataframe.api.valueCounts
 import org.jetbrains.kotlinx.dataframe.explainer.TransformDataFrameExpressions
 import org.junit.Test
 import kotlin.math.ln
@@ -475,14 +474,4 @@ class Analyze : TestBase() {
         df.groupBy { city }.cumSum { weight }.concat()
         // SampleEnd
     }
-
-    @Test
-    @TransformDataFrameExpressions
-    fun valueCounts() {
-        // SampleStart
-        df.city.valueCounts()
-
-        df.valueCounts { name and city }
-        // SampleEnd
-    }
 }
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataColumnTests.kt b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataColumnTests.kt
index 9e97978e5d..83ae9780c1 100644
--- a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataColumnTests.kt
+++ b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/testSets/person/DataColumnTests.kt
@@ -1,13 +1,10 @@
 package org.jetbrains.kotlinx.dataframe.testSets.person
 
 import io.kotest.matchers.shouldBe
-import org.jetbrains.kotlinx.dataframe.api.columnOf
-import org.jetbrains.kotlinx.dataframe.api.count
 import org.jetbrains.kotlinx.dataframe.api.sort
 import org.jetbrains.kotlinx.dataframe.api.sortBy
 import org.jetbrains.kotlinx.dataframe.api.sortByDesc
 import org.jetbrains.kotlinx.dataframe.api.sortDesc
-import org.jetbrains.kotlinx.dataframe.api.valueCounts
 import org.junit.Test
 
 class DataColumnTests : BaseTest() {
@@ -17,12 +14,4 @@ class DataColumnTests : BaseTest() {
         typed.age.sort() shouldBe typed.sortBy { age }.age
         typed.age.sortDesc() shouldBe typed.sortByDesc { age }.age
     }
-
-    @Test
-    fun `value counts`() {
-        val languages by columnOf("Kotlin", "Kotlin", null, null, "C++")
-        val languageCounts = languages.valueCounts()
-        languageCounts[languages].values() shouldBe listOf("Kotlin", "C++")
-        languageCounts.count.values() shouldBe listOf(2, 1)
-    }
 }
diff --git a/docs/StardustDocs/resources/api/pivot/pivotInward_properties.html b/docs/StardustDocs/resources/api/pivot/pivotInward_properties.html
index 711be6bb1c..ab330b21f4 100644
--- a/docs/StardustDocs/resources/api/pivot/pivotInward_properties.html
+++ b/docs/StardustDocs/resources/api/pivot/pivotInward_properties.html
@@ -459,7 +459,7 @@
 /*<!--*/
 call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"true: api.FormattedFrame<Any?>\" style=\"color:#f44336;font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace\">true</span>", children: [], rightAlign: false, values: [{ frameId: 1, value: "<b>DataFrame 5 x 5</b>" }] }, 
 { name: "<span title=\"false: api.FormattedFrame<Any?>\" style=\"color:#f44336;font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace\">false</span>", children: [], rightAlign: false, values: [{ frameId: 2, value: "<b>DataFrame 5 x 5</b>" }] }, 
-{ name: "<span title=\"isHappy: DataRow<*>\" style=\"color:#f44336;font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace\">isHappy</span>", children: [0, 1], rightAlign: false, values: ["<span class=\"formatted\" title=\"true: org.jetbrains.kotlinx.dataframe.api.FormattedFrame@2d22d3b1\nfalse: org.jetbrains.kotlinx.dataframe.api.FormattedFrame@5f5297e3\"><span class=\"structural\">{ </span><span class=\"structural\">true: </span>org.jetbrains.kotlinx<span class=\"structural\">...</span><span class=\"structural\">, </span><span class=\"structural\">f...</span><span class=\"structural\"> }</span></span>"] }, 
+{ name: "<span title=\"isHappy: DataRow<*>\" style=\"color:#f44336;font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace\">isHappy</span>", children: [0, 1], rightAlign: false, values: ["<span class=\"formatted\" title=\"true: org.jetbrains.kotlinx.dataframe.api.FormattedFrame@2d22d3b1\nfalse: org.jetbrains.kotlinx.dataframe.api.FormattedFrame@5f5297e3\"><span class=\"structural\">{ </span><span class=\"structural\">true: </span>org.jetbrains.kotlinx<span class=\"structural\">...</span><span class=\"structural\">, </span><span class=\"structural\">f...</span><span class=\"structural\"> }</span></span>"] },
 ], id: 0, rootId: 0, totalRows: 1 } ) });
 /*-->*/
 
diff --git a/docs/StardustDocs/resources/api/valueCounts/valueCounts.html b/docs/StardustDocs/resources/api/valueCounts/valueCounts.html
new file mode 100644
index 0000000000..83913641e1
--- /dev/null
+++ b/docs/StardustDocs/resources/api/valueCounts/valueCounts.html
@@ -0,0 +1,512 @@
+<html>
+<head>
+<style type="text/css">
+:root {
+    --background: #fff;
+    --background-odd: #f5f5f5;
+    --background-hover: #d9edfd;
+    --header-text-color: #474747;
+    --text-color: #848484;
+    --text-color-dark: #000;
+    --text-color-medium: #737373;
+    --text-color-pale: #b3b3b3;
+    --inner-border-color: #aaa;
+    --bold-border-color: #000;
+    --link-color: #296eaa;
+    --link-color-pale: #296eaa;
+    --link-hover: #1a466c;
+}
+
+:root[theme="dark"], :root [data-jp-theme-light="false"], .dataframe_dark{
+    --background: #303030;
+    --background-odd: #3c3c3c;
+    --background-hover: #464646;
+    --header-text-color: #dddddd;
+    --text-color: #b3b3b3;
+    --text-color-dark: #dddddd;
+    --text-color-medium: #b2b2b2;
+    --text-color-pale: #737373;
+    --inner-border-color: #707070;
+    --bold-border-color: #777777;
+    --link-color: #008dc0;
+    --link-color-pale: #97e1fb;
+    --link-hover: #00688e;
+}
+
+p.dataframe_description {
+    color: var(--text-color-dark);
+}
+
+table.dataframe {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 12px;
+    background-color: var(--background);
+    color: var(--text-color-dark);
+    border: none;
+    border-collapse: collapse;
+}
+
+table.dataframe th, td {
+    padding: 6px;
+    border: 1px solid transparent;
+    text-align: left;
+}
+
+table.dataframe th {
+    background-color: var(--background);
+    color: var(--header-text-color);
+}
+
+table.dataframe td {
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+table.dataframe th.bottomBorder {
+    border-bottom-color: var(--bold-border-color);
+}
+
+table.dataframe tbody > tr:nth-child(odd) {
+    background: var(--background-odd);
+}
+
+table.dataframe tbody > tr:nth-child(even) {
+    background: var(--background);
+}
+
+table.dataframe tbody > tr:hover {
+    background: var(--background-hover);
+}
+
+table.dataframe a {
+    cursor: pointer;
+    color: var(--link-color);
+    text-decoration: none;
+}
+
+table.dataframe tr:hover > td a {
+    color: var(--link-color-pale);
+}
+
+table.dataframe a:hover {
+    color: var(--link-hover);
+    text-decoration: underline;
+}
+
+table.dataframe img {
+    max-width: fit-content;
+}
+
+table.dataframe th.complex {
+    background-color: var(--background);
+    border: 1px solid var(--background);
+}
+
+table.dataframe .leftBorder {
+    border-left-color: var(--inner-border-color);
+}
+
+table.dataframe .rightBorder {
+    border-right-color: var(--inner-border-color);
+}
+
+table.dataframe .rightAlign {
+    text-align: right;
+}
+
+table.dataframe .expanderSvg {
+    width: 8px;
+    height: 8px;
+    margin-right: 3px;
+}
+
+table.dataframe .expander {
+    display: flex;
+    align-items: center;
+}
+
+/* formatting */
+
+table.dataframe .null {
+    color: var(--text-color-pale);
+}
+
+table.dataframe .structural {
+    color: var(--text-color-medium);
+    font-weight: bold;
+}
+
+table.dataframe .dataFrameCaption {
+    font-weight: bold;
+}
+
+table.dataframe .numbers {
+    color: var(--text-color-dark);
+}
+
+table.dataframe td:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+table.dataframe tr:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+
+body {
+    font-family: "JetBrains Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;
+}       
+
+:root {
+    color: #19191C;
+    background-color: #fff;
+}
+
+:root[theme="dark"] {
+    background-color: #19191C;
+    color: #FFFFFFCC
+}
+
+details details {
+    margin-left: 20px; 
+}
+
+summary {
+    padding: 6px;
+}
+</style>
+</head>
+<body>
+<table class="dataframe" id="df_0"></table>
+
+<p class="dataframe_description"></p>
+</body>
+<script>
+(function () {
+    window.DataFrame = window.DataFrame || new (function () {
+        this.addTable = function (df) {
+            let cols = df.cols;
+            for (let i = 0; i < cols.length; i++) {
+                for (let c of cols[i].children) {
+                    cols[c].parent = i;
+                }
+            }
+            df.nrow = 0
+            for (let i = 0; i < df.cols.length; i++) {
+                if (df.cols[i].values.length > df.nrow) df.nrow = df.cols[i].values.length
+            }
+            if (df.id === df.rootId) {
+                df.expandedFrames = new Set()
+                df.childFrames = {}
+                const table = this.getTableElement(df.id)
+                table.df = df
+                for (let i = 0; i < df.cols.length; i++) {
+                    let col = df.cols[i]
+                    if (col.parent === undefined && col.children.length > 0) col.expanded = true
+                }
+            } else {
+                const rootDf = this.getTableData(df.rootId)
+                rootDf.childFrames[df.id] = df
+            }
+        }
+
+        this.computeRenderData = function (df) {
+            let result = []
+            let pos = 0
+            for (let col = 0; col < df.cols.length; col++) {
+                if (df.cols[col].parent === undefined)
+                    pos += this.computeRenderDataRec(df.cols, col, pos, 0, result, false, false)
+            }
+            for (let i = 0; i < result.length; i++) {
+                let row = result[i]
+                for (let j = 0; j < row.length; j++) {
+                    let cell = row[j]
+                    if (j === 0)
+                        cell.leftBd = false
+                    if (j < row.length - 1) {
+                        let nextData = row[j + 1]
+                        if (nextData.leftBd) cell.rightBd = true
+                        else if (cell.rightBd) nextData.leftBd = true
+                    } else cell.rightBd = false
+                }
+            }
+            return result
+        }
+
+        this.computeRenderDataRec = function (cols, colId, pos, depth, result, leftBorder, rightBorder) {
+            if (result.length === depth) {
+                const array = [];
+                if (pos > 0) {
+                    let j = 0
+                    for (let i = 0; j < pos; i++) {
+                        let c = result[depth - 1][i]
+                        j += c.span
+                        let copy = Object.assign({empty: true}, c)
+                        array.push(copy)
+                    }
+                }
+                result.push(array)
+            }
+            const col = cols[colId];
+            let size = 0;
+            if (col.expanded) {
+                let childPos = pos
+                for (let i = 0; i < col.children.length; i++) {
+                    let child = col.children[i]
+                    let childLeft = i === 0 && (col.children.length > 1 || leftBorder)
+                    let childRight = i === col.children.length - 1 && (col.children.length > 1 || rightBorder)
+                    let childSize = this.computeRenderDataRec(cols, child, childPos, depth + 1, result, childLeft, childRight)
+                    childPos += childSize
+                    size += childSize
+                }
+            } else {
+                for (let i = depth + 1; i < result.length; i++)
+                    result[i].push({id: colId, span: 1, leftBd: leftBorder, rightBd: rightBorder, empty: true})
+                size = 1
+            }
+            let left = leftBorder
+            let right = rightBorder
+            if (size > 1) {
+                left = true
+                right = true
+            }
+            result[depth].push({id: colId, span: size, leftBd: left, rightBd: right})
+            return size
+        }
+
+        this.getTableElement = function (id) {
+            return document.getElementById("df_" + id)
+        }
+
+        this.getTableData = function (id) {
+            return this.getTableElement(id).df
+        }
+
+        this.createExpander = function (isExpanded) {
+            const svgNs = "http://www.w3.org/2000/svg"
+            let svg = document.createElementNS(svgNs, "svg")
+            svg.classList.add("expanderSvg")
+            let path = document.createElementNS(svgNs, "path")
+            if (isExpanded) {
+                svg.setAttribute("viewBox", "0 -2 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 4 4 4 -4 -1 -1 -3 3Z")
+            } else {
+                svg.setAttribute("viewBox", "-2 0 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 3 3 -3 3 1 1 4 -4Z")
+            }
+            path.setAttribute("fill", "currentColor")
+            svg.appendChild(path)
+            return svg
+        }
+
+        this.renderTable = function (id) {
+
+            let table = this.getTableElement(id)
+
+            if (table === null) return
+
+            table.innerHTML = ""
+
+            let df = table.df
+            let rootDf = df.rootId === df.id ? df : this.getTableData(df.rootId)
+
+            // header
+            let header = document.createElement("thead")
+            table.appendChild(header)
+
+            let renderData = this.computeRenderData(df)
+            for (let j = 0; j < renderData.length; j++) {
+                let rowData = renderData[j]
+                let tr = document.createElement("tr");
+                let isLastRow = j === renderData.length - 1
+                header.appendChild(tr);
+                for (let i = 0; i < rowData.length; i++) {
+                    let cell = rowData[i]
+                    let th = document.createElement("th");
+                    th.setAttribute("colspan", cell.span)
+                    let colId = cell.id
+                    let col = df.cols[colId];
+                    if (!cell.empty) {
+                        if (col.children.length === 0) {
+                            th.innerHTML = col.name
+                        } else {
+                            let link = document.createElement("a")
+                            link.className = "expander"
+                            let that = this
+                            link.onclick = function () {
+                                col.expanded = !col.expanded
+                                that.renderTable(id)
+                            }
+                            link.appendChild(this.createExpander(col.expanded))
+                            link.innerHTML += col.name
+                            th.appendChild(link)
+                        }
+                    }
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (isLastRow)
+                        classes += " bottomBorder"
+                    if (classes.length > 0)
+                        th.setAttribute("class", classes)
+                    tr.appendChild(th)
+                }
+            }
+
+            // body
+            let body = document.createElement("tbody")
+            table.appendChild(body)
+
+            let columns = renderData.pop()
+            for (let row = 0; row < df.nrow; row++) {
+                let tr = document.createElement("tr");
+                body.appendChild(tr)
+                for (let i = 0; i < columns.length; i++) {
+                    let cell = columns[i]
+                    let td = document.createElement("td");
+                    let colId = cell.id
+                    let col = df.cols[colId]
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (classes.length > 0)
+                        td.setAttribute("class", classes)
+                    tr.appendChild(td)
+                    let value = col.values[row]
+                    if (value.frameId !== undefined) {
+                        let frameId = value.frameId
+                        let expanded = rootDf.expandedFrames.has(frameId)
+                        let link = document.createElement("a")
+                        link.className = "expander"
+                        let that = this
+                        link.onclick = function () {
+                            if (rootDf.expandedFrames.has(frameId))
+                                rootDf.expandedFrames.delete(frameId)
+                            else rootDf.expandedFrames.add(frameId)
+                            that.renderTable(id)
+                        }
+                        link.appendChild(this.createExpander(expanded))
+                        link.innerHTML += value.value
+                        if (expanded) {
+                            td.appendChild(link)
+                            td.appendChild(document.createElement("p"))
+                            const childTable = document.createElement("table")
+                            childTable.className = "dataframe"
+                            childTable.id = "df_" + frameId
+                            let childDf = rootDf.childFrames[frameId]
+                            childTable.df = childDf
+                            td.appendChild(childTable)
+                            this.renderTable(frameId)
+                            if (childDf.nrow !== childDf.totalRows) {
+                                const footer = document.createElement("p")
+                                footer.innerText = `... showing only top ${childDf.nrow} of ${childDf.totalRows} rows`
+                                td.appendChild(footer)
+                            }
+                        } else {
+                            td.appendChild(link)
+                        }
+                    } else if (value.style !== undefined) {
+                        td.innerHTML = value.value
+                        td.setAttribute("style", value.style)
+                    } else td.innerHTML = value
+                    this.nodeScriptReplace(td)
+                }
+            }
+        }
+
+        this.nodeScriptReplace = function (node) {
+            if (this.nodeScriptIs(node) === true) {
+                node.parentNode.replaceChild(this.nodeScriptClone(node), node);
+            } else {
+                let i = -1, children = node.childNodes;
+                while (++i < children.length) {
+                    this.nodeScriptReplace(children[i]);
+                }
+            }
+
+            return node;
+        }
+
+        this.nodeScriptClone = function (node) {
+            let script = document.createElement("script");
+            script.text = node.innerHTML;
+
+            let i = -1, attrs = node.attributes, attr;
+            while (++i < attrs.length) {
+                script.setAttribute((attr = attrs[i]).name, attr.value);
+            }
+            return script;
+        }
+
+        this.nodeScriptIs = function (node) {
+            return node.tagName === 'SCRIPT';
+        }
+    })()
+
+    window.call_DataFrame = function (f) {
+        return f();
+    };
+
+    let funQueue = window["kotlinQueues"] && window["kotlinQueues"]["DataFrame"];
+    if (funQueue) {
+        funQueue.forEach(function (f) {
+            f();
+        });
+        funQueue = [];
+    }
+})()
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"name: String\">name</span>", children: [], rightAlign: false, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Alice"},"Bob","Charlie"] }, 
+{ name: "<span title=\"age: Int\">age</span>", children: [], rightAlign: true, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">15</span></span>"},"<span class=\"formatted\" title=\"\"><span class=\"numbers\">20</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">25</span></span>"] }, 
+{ name: "<span title=\"count: Int\">count</span>", children: [], rightAlign: true, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">2</span></span>"},"<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>"] }, 
+], id: 0, rootId: 0, totalRows: 3 } ) });
+/*-->*/
+
+call_DataFrame(function() { DataFrame.renderTable(0) });
+
+function sendHeight() {
+    const table = document.querySelector('table.dataframe');
+    if (!table) return;
+
+    let height = 0;
+    
+    const thead = table.querySelector('thead');
+    if (thead) height += thead.offsetHeight;
+    
+    const rows = table.querySelectorAll(':scope > tbody > tr');
+    rows.forEach(row => {
+        height += row.offsetHeight;
+    });
+    
+    height += getVerticalMargins(table) + 10;
+
+    window.parent.postMessage({ type: 'iframeHeight', height: Math.ceil(height) }, '*');
+}
+
+function getVerticalMargins(element) {
+    const style = getComputedStyle(element);
+    return parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+}
+
+function repeatHeightCalculation(maxRetries = 10, interval = 100) {
+    let retries = 0;
+    const intervalId = setInterval(() => {
+        sendHeight();
+        retries++;
+        if (retries >= maxRetries) clearInterval(intervalId);
+    }, interval);
+}
+
+window.addEventListener('load', repeatHeightCalculation);
+
+const observer = new MutationObserver(() => repeatHeightCalculation(5, 50));
+observer.observe(document.querySelector('.dataframe'), {
+    childList: true,
+    subtree: true,
+    characterData: true,
+});
+
+
+</script>
+</html>
diff --git a/docs/StardustDocs/resources/api/valueCounts/valueCountsColumn.html b/docs/StardustDocs/resources/api/valueCounts/valueCountsColumn.html
new file mode 100644
index 0000000000..fbf0429038
--- /dev/null
+++ b/docs/StardustDocs/resources/api/valueCounts/valueCountsColumn.html
@@ -0,0 +1,511 @@
+<html>
+<head>
+<style type="text/css">
+:root {
+    --background: #fff;
+    --background-odd: #f5f5f5;
+    --background-hover: #d9edfd;
+    --header-text-color: #474747;
+    --text-color: #848484;
+    --text-color-dark: #000;
+    --text-color-medium: #737373;
+    --text-color-pale: #b3b3b3;
+    --inner-border-color: #aaa;
+    --bold-border-color: #000;
+    --link-color: #296eaa;
+    --link-color-pale: #296eaa;
+    --link-hover: #1a466c;
+}
+
+:root[theme="dark"], :root [data-jp-theme-light="false"], .dataframe_dark{
+    --background: #303030;
+    --background-odd: #3c3c3c;
+    --background-hover: #464646;
+    --header-text-color: #dddddd;
+    --text-color: #b3b3b3;
+    --text-color-dark: #dddddd;
+    --text-color-medium: #b2b2b2;
+    --text-color-pale: #737373;
+    --inner-border-color: #707070;
+    --bold-border-color: #777777;
+    --link-color: #008dc0;
+    --link-color-pale: #97e1fb;
+    --link-hover: #00688e;
+}
+
+p.dataframe_description {
+    color: var(--text-color-dark);
+}
+
+table.dataframe {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 12px;
+    background-color: var(--background);
+    color: var(--text-color-dark);
+    border: none;
+    border-collapse: collapse;
+}
+
+table.dataframe th, td {
+    padding: 6px;
+    border: 1px solid transparent;
+    text-align: left;
+}
+
+table.dataframe th {
+    background-color: var(--background);
+    color: var(--header-text-color);
+}
+
+table.dataframe td {
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+table.dataframe th.bottomBorder {
+    border-bottom-color: var(--bold-border-color);
+}
+
+table.dataframe tbody > tr:nth-child(odd) {
+    background: var(--background-odd);
+}
+
+table.dataframe tbody > tr:nth-child(even) {
+    background: var(--background);
+}
+
+table.dataframe tbody > tr:hover {
+    background: var(--background-hover);
+}
+
+table.dataframe a {
+    cursor: pointer;
+    color: var(--link-color);
+    text-decoration: none;
+}
+
+table.dataframe tr:hover > td a {
+    color: var(--link-color-pale);
+}
+
+table.dataframe a:hover {
+    color: var(--link-hover);
+    text-decoration: underline;
+}
+
+table.dataframe img {
+    max-width: fit-content;
+}
+
+table.dataframe th.complex {
+    background-color: var(--background);
+    border: 1px solid var(--background);
+}
+
+table.dataframe .leftBorder {
+    border-left-color: var(--inner-border-color);
+}
+
+table.dataframe .rightBorder {
+    border-right-color: var(--inner-border-color);
+}
+
+table.dataframe .rightAlign {
+    text-align: right;
+}
+
+table.dataframe .expanderSvg {
+    width: 8px;
+    height: 8px;
+    margin-right: 3px;
+}
+
+table.dataframe .expander {
+    display: flex;
+    align-items: center;
+}
+
+/* formatting */
+
+table.dataframe .null {
+    color: var(--text-color-pale);
+}
+
+table.dataframe .structural {
+    color: var(--text-color-medium);
+    font-weight: bold;
+}
+
+table.dataframe .dataFrameCaption {
+    font-weight: bold;
+}
+
+table.dataframe .numbers {
+    color: var(--text-color-dark);
+}
+
+table.dataframe td:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+table.dataframe tr:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+
+body {
+    font-family: "JetBrains Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;
+}       
+
+:root {
+    color: #19191C;
+    background-color: #fff;
+}
+
+:root[theme="dark"] {
+    background-color: #19191C;
+    color: #FFFFFFCC
+}
+
+details details {
+    margin-left: 20px; 
+}
+
+summary {
+    padding: 6px;
+}
+</style>
+</head>
+<body>
+<table class="dataframe" id="df_0"></table>
+
+<p class="dataframe_description"></p>
+</body>
+<script>
+(function () {
+    window.DataFrame = window.DataFrame || new (function () {
+        this.addTable = function (df) {
+            let cols = df.cols;
+            for (let i = 0; i < cols.length; i++) {
+                for (let c of cols[i].children) {
+                    cols[c].parent = i;
+                }
+            }
+            df.nrow = 0
+            for (let i = 0; i < df.cols.length; i++) {
+                if (df.cols[i].values.length > df.nrow) df.nrow = df.cols[i].values.length
+            }
+            if (df.id === df.rootId) {
+                df.expandedFrames = new Set()
+                df.childFrames = {}
+                const table = this.getTableElement(df.id)
+                table.df = df
+                for (let i = 0; i < df.cols.length; i++) {
+                    let col = df.cols[i]
+                    if (col.parent === undefined && col.children.length > 0) col.expanded = true
+                }
+            } else {
+                const rootDf = this.getTableData(df.rootId)
+                rootDf.childFrames[df.id] = df
+            }
+        }
+
+        this.computeRenderData = function (df) {
+            let result = []
+            let pos = 0
+            for (let col = 0; col < df.cols.length; col++) {
+                if (df.cols[col].parent === undefined)
+                    pos += this.computeRenderDataRec(df.cols, col, pos, 0, result, false, false)
+            }
+            for (let i = 0; i < result.length; i++) {
+                let row = result[i]
+                for (let j = 0; j < row.length; j++) {
+                    let cell = row[j]
+                    if (j === 0)
+                        cell.leftBd = false
+                    if (j < row.length - 1) {
+                        let nextData = row[j + 1]
+                        if (nextData.leftBd) cell.rightBd = true
+                        else if (cell.rightBd) nextData.leftBd = true
+                    } else cell.rightBd = false
+                }
+            }
+            return result
+        }
+
+        this.computeRenderDataRec = function (cols, colId, pos, depth, result, leftBorder, rightBorder) {
+            if (result.length === depth) {
+                const array = [];
+                if (pos > 0) {
+                    let j = 0
+                    for (let i = 0; j < pos; i++) {
+                        let c = result[depth - 1][i]
+                        j += c.span
+                        let copy = Object.assign({empty: true}, c)
+                        array.push(copy)
+                    }
+                }
+                result.push(array)
+            }
+            const col = cols[colId];
+            let size = 0;
+            if (col.expanded) {
+                let childPos = pos
+                for (let i = 0; i < col.children.length; i++) {
+                    let child = col.children[i]
+                    let childLeft = i === 0 && (col.children.length > 1 || leftBorder)
+                    let childRight = i === col.children.length - 1 && (col.children.length > 1 || rightBorder)
+                    let childSize = this.computeRenderDataRec(cols, child, childPos, depth + 1, result, childLeft, childRight)
+                    childPos += childSize
+                    size += childSize
+                }
+            } else {
+                for (let i = depth + 1; i < result.length; i++)
+                    result[i].push({id: colId, span: 1, leftBd: leftBorder, rightBd: rightBorder, empty: true})
+                size = 1
+            }
+            let left = leftBorder
+            let right = rightBorder
+            if (size > 1) {
+                left = true
+                right = true
+            }
+            result[depth].push({id: colId, span: size, leftBd: left, rightBd: right})
+            return size
+        }
+
+        this.getTableElement = function (id) {
+            return document.getElementById("df_" + id)
+        }
+
+        this.getTableData = function (id) {
+            return this.getTableElement(id).df
+        }
+
+        this.createExpander = function (isExpanded) {
+            const svgNs = "http://www.w3.org/2000/svg"
+            let svg = document.createElementNS(svgNs, "svg")
+            svg.classList.add("expanderSvg")
+            let path = document.createElementNS(svgNs, "path")
+            if (isExpanded) {
+                svg.setAttribute("viewBox", "0 -2 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 4 4 4 -4 -1 -1 -3 3Z")
+            } else {
+                svg.setAttribute("viewBox", "-2 0 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 3 3 -3 3 1 1 4 -4Z")
+            }
+            path.setAttribute("fill", "currentColor")
+            svg.appendChild(path)
+            return svg
+        }
+
+        this.renderTable = function (id) {
+
+            let table = this.getTableElement(id)
+
+            if (table === null) return
+
+            table.innerHTML = ""
+
+            let df = table.df
+            let rootDf = df.rootId === df.id ? df : this.getTableData(df.rootId)
+
+            // header
+            let header = document.createElement("thead")
+            table.appendChild(header)
+
+            let renderData = this.computeRenderData(df)
+            for (let j = 0; j < renderData.length; j++) {
+                let rowData = renderData[j]
+                let tr = document.createElement("tr");
+                let isLastRow = j === renderData.length - 1
+                header.appendChild(tr);
+                for (let i = 0; i < rowData.length; i++) {
+                    let cell = rowData[i]
+                    let th = document.createElement("th");
+                    th.setAttribute("colspan", cell.span)
+                    let colId = cell.id
+                    let col = df.cols[colId];
+                    if (!cell.empty) {
+                        if (col.children.length === 0) {
+                            th.innerHTML = col.name
+                        } else {
+                            let link = document.createElement("a")
+                            link.className = "expander"
+                            let that = this
+                            link.onclick = function () {
+                                col.expanded = !col.expanded
+                                that.renderTable(id)
+                            }
+                            link.appendChild(this.createExpander(col.expanded))
+                            link.innerHTML += col.name
+                            th.appendChild(link)
+                        }
+                    }
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (isLastRow)
+                        classes += " bottomBorder"
+                    if (classes.length > 0)
+                        th.setAttribute("class", classes)
+                    tr.appendChild(th)
+                }
+            }
+
+            // body
+            let body = document.createElement("tbody")
+            table.appendChild(body)
+
+            let columns = renderData.pop()
+            for (let row = 0; row < df.nrow; row++) {
+                let tr = document.createElement("tr");
+                body.appendChild(tr)
+                for (let i = 0; i < columns.length; i++) {
+                    let cell = columns[i]
+                    let td = document.createElement("td");
+                    let colId = cell.id
+                    let col = df.cols[colId]
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (classes.length > 0)
+                        td.setAttribute("class", classes)
+                    tr.appendChild(td)
+                    let value = col.values[row]
+                    if (value.frameId !== undefined) {
+                        let frameId = value.frameId
+                        let expanded = rootDf.expandedFrames.has(frameId)
+                        let link = document.createElement("a")
+                        link.className = "expander"
+                        let that = this
+                        link.onclick = function () {
+                            if (rootDf.expandedFrames.has(frameId))
+                                rootDf.expandedFrames.delete(frameId)
+                            else rootDf.expandedFrames.add(frameId)
+                            that.renderTable(id)
+                        }
+                        link.appendChild(this.createExpander(expanded))
+                        link.innerHTML += value.value
+                        if (expanded) {
+                            td.appendChild(link)
+                            td.appendChild(document.createElement("p"))
+                            const childTable = document.createElement("table")
+                            childTable.className = "dataframe"
+                            childTable.id = "df_" + frameId
+                            let childDf = rootDf.childFrames[frameId]
+                            childTable.df = childDf
+                            td.appendChild(childTable)
+                            this.renderTable(frameId)
+                            if (childDf.nrow !== childDf.totalRows) {
+                                const footer = document.createElement("p")
+                                footer.innerText = `... showing only top ${childDf.nrow} of ${childDf.totalRows} rows`
+                                td.appendChild(footer)
+                            }
+                        } else {
+                            td.appendChild(link)
+                        }
+                    } else if (value.style !== undefined) {
+                        td.innerHTML = value.value
+                        td.setAttribute("style", value.style)
+                    } else td.innerHTML = value
+                    this.nodeScriptReplace(td)
+                }
+            }
+        }
+
+        this.nodeScriptReplace = function (node) {
+            if (this.nodeScriptIs(node) === true) {
+                node.parentNode.replaceChild(this.nodeScriptClone(node), node);
+            } else {
+                let i = -1, children = node.childNodes;
+                while (++i < children.length) {
+                    this.nodeScriptReplace(children[i]);
+                }
+            }
+
+            return node;
+        }
+
+        this.nodeScriptClone = function (node) {
+            let script = document.createElement("script");
+            script.text = node.innerHTML;
+
+            let i = -1, attrs = node.attributes, attr;
+            while (++i < attrs.length) {
+                script.setAttribute((attr = attrs[i]).name, attr.value);
+            }
+            return script;
+        }
+
+        this.nodeScriptIs = function (node) {
+            return node.tagName === 'SCRIPT';
+        }
+    })()
+
+    window.call_DataFrame = function (f) {
+        return f();
+    };
+
+    let funQueue = window["kotlinQueues"] && window["kotlinQueues"]["DataFrame"];
+    if (funQueue) {
+        funQueue.forEach(function (f) {
+            f();
+        });
+        funQueue = [];
+    }
+})()
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"age: Int\" style=\"color:#f44336;font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace\">age</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">15</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">20</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">25</span></span>"] }, 
+{ name: "<span title=\"count: Int\">count</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">2</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>"] }, 
+], id: 0, rootId: 0, totalRows: 3 } ) });
+/*-->*/
+
+call_DataFrame(function() { DataFrame.renderTable(0) });
+
+function sendHeight() {
+    const table = document.querySelector('table.dataframe');
+    if (!table) return;
+
+    let height = 0;
+    
+    const thead = table.querySelector('thead');
+    if (thead) height += thead.offsetHeight;
+    
+    const rows = table.querySelectorAll(':scope > tbody > tr');
+    rows.forEach(row => {
+        height += row.offsetHeight;
+    });
+    
+    height += getVerticalMargins(table) + 10;
+
+    window.parent.postMessage({ type: 'iframeHeight', height: Math.ceil(height) }, '*');
+}
+
+function getVerticalMargins(element) {
+    const style = getComputedStyle(element);
+    return parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+}
+
+function repeatHeightCalculation(maxRetries = 10, interval = 100) {
+    let retries = 0;
+    const intervalId = setInterval(() => {
+        sendHeight();
+        retries++;
+        if (retries >= maxRetries) clearInterval(intervalId);
+    }, interval);
+}
+
+window.addEventListener('load', repeatHeightCalculation);
+
+const observer = new MutationObserver(() => repeatHeightCalculation(5, 50));
+observer.observe(document.querySelector('.dataframe'), {
+    childList: true,
+    subtree: true,
+    characterData: true,
+});
+
+
+</script>
+</html>
diff --git a/docs/StardustDocs/resources/api/valueCounts/valueCountsDf.html b/docs/StardustDocs/resources/api/valueCounts/valueCountsDf.html
new file mode 100644
index 0000000000..770a76f736
--- /dev/null
+++ b/docs/StardustDocs/resources/api/valueCounts/valueCountsDf.html
@@ -0,0 +1,511 @@
+<html>
+<head>
+<style type="text/css">
+:root {
+    --background: #fff;
+    --background-odd: #f5f5f5;
+    --background-hover: #d9edfd;
+    --header-text-color: #474747;
+    --text-color: #848484;
+    --text-color-dark: #000;
+    --text-color-medium: #737373;
+    --text-color-pale: #b3b3b3;
+    --inner-border-color: #aaa;
+    --bold-border-color: #000;
+    --link-color: #296eaa;
+    --link-color-pale: #296eaa;
+    --link-hover: #1a466c;
+}
+
+:root[theme="dark"], :root [data-jp-theme-light="false"], .dataframe_dark{
+    --background: #303030;
+    --background-odd: #3c3c3c;
+    --background-hover: #464646;
+    --header-text-color: #dddddd;
+    --text-color: #b3b3b3;
+    --text-color-dark: #dddddd;
+    --text-color-medium: #b2b2b2;
+    --text-color-pale: #737373;
+    --inner-border-color: #707070;
+    --bold-border-color: #777777;
+    --link-color: #008dc0;
+    --link-color-pale: #97e1fb;
+    --link-hover: #00688e;
+}
+
+p.dataframe_description {
+    color: var(--text-color-dark);
+}
+
+table.dataframe {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 12px;
+    background-color: var(--background);
+    color: var(--text-color-dark);
+    border: none;
+    border-collapse: collapse;
+}
+
+table.dataframe th, td {
+    padding: 6px;
+    border: 1px solid transparent;
+    text-align: left;
+}
+
+table.dataframe th {
+    background-color: var(--background);
+    color: var(--header-text-color);
+}
+
+table.dataframe td {
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+table.dataframe th.bottomBorder {
+    border-bottom-color: var(--bold-border-color);
+}
+
+table.dataframe tbody > tr:nth-child(odd) {
+    background: var(--background-odd);
+}
+
+table.dataframe tbody > tr:nth-child(even) {
+    background: var(--background);
+}
+
+table.dataframe tbody > tr:hover {
+    background: var(--background-hover);
+}
+
+table.dataframe a {
+    cursor: pointer;
+    color: var(--link-color);
+    text-decoration: none;
+}
+
+table.dataframe tr:hover > td a {
+    color: var(--link-color-pale);
+}
+
+table.dataframe a:hover {
+    color: var(--link-hover);
+    text-decoration: underline;
+}
+
+table.dataframe img {
+    max-width: fit-content;
+}
+
+table.dataframe th.complex {
+    background-color: var(--background);
+    border: 1px solid var(--background);
+}
+
+table.dataframe .leftBorder {
+    border-left-color: var(--inner-border-color);
+}
+
+table.dataframe .rightBorder {
+    border-right-color: var(--inner-border-color);
+}
+
+table.dataframe .rightAlign {
+    text-align: right;
+}
+
+table.dataframe .expanderSvg {
+    width: 8px;
+    height: 8px;
+    margin-right: 3px;
+}
+
+table.dataframe .expander {
+    display: flex;
+    align-items: center;
+}
+
+/* formatting */
+
+table.dataframe .null {
+    color: var(--text-color-pale);
+}
+
+table.dataframe .structural {
+    color: var(--text-color-medium);
+    font-weight: bold;
+}
+
+table.dataframe .dataFrameCaption {
+    font-weight: bold;
+}
+
+table.dataframe .numbers {
+    color: var(--text-color-dark);
+}
+
+table.dataframe td:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+table.dataframe tr:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+
+body {
+    font-family: "JetBrains Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;
+}       
+
+:root {
+    color: #19191C;
+    background-color: #fff;
+}
+
+:root[theme="dark"] {
+    background-color: #19191C;
+    color: #FFFFFFCC
+}
+
+details details {
+    margin-left: 20px; 
+}
+
+summary {
+    padding: 6px;
+}
+</style>
+</head>
+<body>
+<table class="dataframe" id="df_0"></table>
+
+<p class="dataframe_description"></p>
+</body>
+<script>
+(function () {
+    window.DataFrame = window.DataFrame || new (function () {
+        this.addTable = function (df) {
+            let cols = df.cols;
+            for (let i = 0; i < cols.length; i++) {
+                for (let c of cols[i].children) {
+                    cols[c].parent = i;
+                }
+            }
+            df.nrow = 0
+            for (let i = 0; i < df.cols.length; i++) {
+                if (df.cols[i].values.length > df.nrow) df.nrow = df.cols[i].values.length
+            }
+            if (df.id === df.rootId) {
+                df.expandedFrames = new Set()
+                df.childFrames = {}
+                const table = this.getTableElement(df.id)
+                table.df = df
+                for (let i = 0; i < df.cols.length; i++) {
+                    let col = df.cols[i]
+                    if (col.parent === undefined && col.children.length > 0) col.expanded = true
+                }
+            } else {
+                const rootDf = this.getTableData(df.rootId)
+                rootDf.childFrames[df.id] = df
+            }
+        }
+
+        this.computeRenderData = function (df) {
+            let result = []
+            let pos = 0
+            for (let col = 0; col < df.cols.length; col++) {
+                if (df.cols[col].parent === undefined)
+                    pos += this.computeRenderDataRec(df.cols, col, pos, 0, result, false, false)
+            }
+            for (let i = 0; i < result.length; i++) {
+                let row = result[i]
+                for (let j = 0; j < row.length; j++) {
+                    let cell = row[j]
+                    if (j === 0)
+                        cell.leftBd = false
+                    if (j < row.length - 1) {
+                        let nextData = row[j + 1]
+                        if (nextData.leftBd) cell.rightBd = true
+                        else if (cell.rightBd) nextData.leftBd = true
+                    } else cell.rightBd = false
+                }
+            }
+            return result
+        }
+
+        this.computeRenderDataRec = function (cols, colId, pos, depth, result, leftBorder, rightBorder) {
+            if (result.length === depth) {
+                const array = [];
+                if (pos > 0) {
+                    let j = 0
+                    for (let i = 0; j < pos; i++) {
+                        let c = result[depth - 1][i]
+                        j += c.span
+                        let copy = Object.assign({empty: true}, c)
+                        array.push(copy)
+                    }
+                }
+                result.push(array)
+            }
+            const col = cols[colId];
+            let size = 0;
+            if (col.expanded) {
+                let childPos = pos
+                for (let i = 0; i < col.children.length; i++) {
+                    let child = col.children[i]
+                    let childLeft = i === 0 && (col.children.length > 1 || leftBorder)
+                    let childRight = i === col.children.length - 1 && (col.children.length > 1 || rightBorder)
+                    let childSize = this.computeRenderDataRec(cols, child, childPos, depth + 1, result, childLeft, childRight)
+                    childPos += childSize
+                    size += childSize
+                }
+            } else {
+                for (let i = depth + 1; i < result.length; i++)
+                    result[i].push({id: colId, span: 1, leftBd: leftBorder, rightBd: rightBorder, empty: true})
+                size = 1
+            }
+            let left = leftBorder
+            let right = rightBorder
+            if (size > 1) {
+                left = true
+                right = true
+            }
+            result[depth].push({id: colId, span: size, leftBd: left, rightBd: right})
+            return size
+        }
+
+        this.getTableElement = function (id) {
+            return document.getElementById("df_" + id)
+        }
+
+        this.getTableData = function (id) {
+            return this.getTableElement(id).df
+        }
+
+        this.createExpander = function (isExpanded) {
+            const svgNs = "http://www.w3.org/2000/svg"
+            let svg = document.createElementNS(svgNs, "svg")
+            svg.classList.add("expanderSvg")
+            let path = document.createElementNS(svgNs, "path")
+            if (isExpanded) {
+                svg.setAttribute("viewBox", "0 -2 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 4 4 4 -4 -1 -1 -3 3Z")
+            } else {
+                svg.setAttribute("viewBox", "-2 0 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 3 3 -3 3 1 1 4 -4Z")
+            }
+            path.setAttribute("fill", "currentColor")
+            svg.appendChild(path)
+            return svg
+        }
+
+        this.renderTable = function (id) {
+
+            let table = this.getTableElement(id)
+
+            if (table === null) return
+
+            table.innerHTML = ""
+
+            let df = table.df
+            let rootDf = df.rootId === df.id ? df : this.getTableData(df.rootId)
+
+            // header
+            let header = document.createElement("thead")
+            table.appendChild(header)
+
+            let renderData = this.computeRenderData(df)
+            for (let j = 0; j < renderData.length; j++) {
+                let rowData = renderData[j]
+                let tr = document.createElement("tr");
+                let isLastRow = j === renderData.length - 1
+                header.appendChild(tr);
+                for (let i = 0; i < rowData.length; i++) {
+                    let cell = rowData[i]
+                    let th = document.createElement("th");
+                    th.setAttribute("colspan", cell.span)
+                    let colId = cell.id
+                    let col = df.cols[colId];
+                    if (!cell.empty) {
+                        if (col.children.length === 0) {
+                            th.innerHTML = col.name
+                        } else {
+                            let link = document.createElement("a")
+                            link.className = "expander"
+                            let that = this
+                            link.onclick = function () {
+                                col.expanded = !col.expanded
+                                that.renderTable(id)
+                            }
+                            link.appendChild(this.createExpander(col.expanded))
+                            link.innerHTML += col.name
+                            th.appendChild(link)
+                        }
+                    }
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (isLastRow)
+                        classes += " bottomBorder"
+                    if (classes.length > 0)
+                        th.setAttribute("class", classes)
+                    tr.appendChild(th)
+                }
+            }
+
+            // body
+            let body = document.createElement("tbody")
+            table.appendChild(body)
+
+            let columns = renderData.pop()
+            for (let row = 0; row < df.nrow; row++) {
+                let tr = document.createElement("tr");
+                body.appendChild(tr)
+                for (let i = 0; i < columns.length; i++) {
+                    let cell = columns[i]
+                    let td = document.createElement("td");
+                    let colId = cell.id
+                    let col = df.cols[colId]
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (classes.length > 0)
+                        td.setAttribute("class", classes)
+                    tr.appendChild(td)
+                    let value = col.values[row]
+                    if (value.frameId !== undefined) {
+                        let frameId = value.frameId
+                        let expanded = rootDf.expandedFrames.has(frameId)
+                        let link = document.createElement("a")
+                        link.className = "expander"
+                        let that = this
+                        link.onclick = function () {
+                            if (rootDf.expandedFrames.has(frameId))
+                                rootDf.expandedFrames.delete(frameId)
+                            else rootDf.expandedFrames.add(frameId)
+                            that.renderTable(id)
+                        }
+                        link.appendChild(this.createExpander(expanded))
+                        link.innerHTML += value.value
+                        if (expanded) {
+                            td.appendChild(link)
+                            td.appendChild(document.createElement("p"))
+                            const childTable = document.createElement("table")
+                            childTable.className = "dataframe"
+                            childTable.id = "df_" + frameId
+                            let childDf = rootDf.childFrames[frameId]
+                            childTable.df = childDf
+                            td.appendChild(childTable)
+                            this.renderTable(frameId)
+                            if (childDf.nrow !== childDf.totalRows) {
+                                const footer = document.createElement("p")
+                                footer.innerText = `... showing only top ${childDf.nrow} of ${childDf.totalRows} rows`
+                                td.appendChild(footer)
+                            }
+                        } else {
+                            td.appendChild(link)
+                        }
+                    } else if (value.style !== undefined) {
+                        td.innerHTML = value.value
+                        td.setAttribute("style", value.style)
+                    } else td.innerHTML = value
+                    this.nodeScriptReplace(td)
+                }
+            }
+        }
+
+        this.nodeScriptReplace = function (node) {
+            if (this.nodeScriptIs(node) === true) {
+                node.parentNode.replaceChild(this.nodeScriptClone(node), node);
+            } else {
+                let i = -1, children = node.childNodes;
+                while (++i < children.length) {
+                    this.nodeScriptReplace(children[i]);
+                }
+            }
+
+            return node;
+        }
+
+        this.nodeScriptClone = function (node) {
+            let script = document.createElement("script");
+            script.text = node.innerHTML;
+
+            let i = -1, attrs = node.attributes, attr;
+            while (++i < attrs.length) {
+                script.setAttribute((attr = attrs[i]).name, attr.value);
+            }
+            return script;
+        }
+
+        this.nodeScriptIs = function (node) {
+            return node.tagName === 'SCRIPT';
+        }
+    })()
+
+    window.call_DataFrame = function (f) {
+        return f();
+    };
+
+    let funQueue = window["kotlinQueues"] && window["kotlinQueues"]["DataFrame"];
+    if (funQueue) {
+        funQueue.forEach(function (f) {
+            f();
+        });
+        funQueue = [];
+    }
+})()
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"name: String\">name</span>", children: [], rightAlign: false, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Alice"},"Bob","Charlie",{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Alice"},{ style: "background-color:#e9c7dc;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Alice"}] }, 
+{ name: "<span title=\"age: Int?\">age</span>", children: [], rightAlign: true, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">15</span></span>"},"<span class=\"formatted\" title=\"\"><span class=\"numbers\">20</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">25</span></span>",{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">15</span></span>"},{ style: "background-color:#e9c7dc;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"null\">null</span></span>"}] }, 
+], id: 0, rootId: 0, totalRows: 5 } ) });
+/*-->*/
+
+call_DataFrame(function() { DataFrame.renderTable(0) });
+
+function sendHeight() {
+    const table = document.querySelector('table.dataframe');
+    if (!table) return;
+
+    let height = 0;
+    
+    const thead = table.querySelector('thead');
+    if (thead) height += thead.offsetHeight;
+    
+    const rows = table.querySelectorAll(':scope > tbody > tr');
+    rows.forEach(row => {
+        height += row.offsetHeight;
+    });
+    
+    height += getVerticalMargins(table) + 10;
+
+    window.parent.postMessage({ type: 'iframeHeight', height: Math.ceil(height) }, '*');
+}
+
+function getVerticalMargins(element) {
+    const style = getComputedStyle(element);
+    return parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+}
+
+function repeatHeightCalculation(maxRetries = 10, interval = 100) {
+    let retries = 0;
+    const intervalId = setInterval(() => {
+        sendHeight();
+        retries++;
+        if (retries >= maxRetries) clearInterval(intervalId);
+    }, interval);
+}
+
+window.addEventListener('load', repeatHeightCalculation);
+
+const observer = new MutationObserver(() => repeatHeightCalculation(5, 50));
+observer.observe(document.querySelector('.dataframe'), {
+    childList: true,
+    subtree: true,
+    characterData: true,
+});
+
+
+</script>
+</html>
diff --git a/docs/StardustDocs/resources/api/valueCounts/valueCountsSelector_properties.html b/docs/StardustDocs/resources/api/valueCounts/valueCountsSelector_properties.html
new file mode 100644
index 0000000000..4ad14e034e
--- /dev/null
+++ b/docs/StardustDocs/resources/api/valueCounts/valueCountsSelector_properties.html
@@ -0,0 +1,511 @@
+<html>
+<head>
+<style type="text/css">
+:root {
+    --background: #fff;
+    --background-odd: #f5f5f5;
+    --background-hover: #d9edfd;
+    --header-text-color: #474747;
+    --text-color: #848484;
+    --text-color-dark: #000;
+    --text-color-medium: #737373;
+    --text-color-pale: #b3b3b3;
+    --inner-border-color: #aaa;
+    --bold-border-color: #000;
+    --link-color: #296eaa;
+    --link-color-pale: #296eaa;
+    --link-hover: #1a466c;
+}
+
+:root[theme="dark"], :root [data-jp-theme-light="false"], .dataframe_dark{
+    --background: #303030;
+    --background-odd: #3c3c3c;
+    --background-hover: #464646;
+    --header-text-color: #dddddd;
+    --text-color: #b3b3b3;
+    --text-color-dark: #dddddd;
+    --text-color-medium: #b2b2b2;
+    --text-color-pale: #737373;
+    --inner-border-color: #707070;
+    --bold-border-color: #777777;
+    --link-color: #008dc0;
+    --link-color-pale: #97e1fb;
+    --link-hover: #00688e;
+}
+
+p.dataframe_description {
+    color: var(--text-color-dark);
+}
+
+table.dataframe {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 12px;
+    background-color: var(--background);
+    color: var(--text-color-dark);
+    border: none;
+    border-collapse: collapse;
+}
+
+table.dataframe th, td {
+    padding: 6px;
+    border: 1px solid transparent;
+    text-align: left;
+}
+
+table.dataframe th {
+    background-color: var(--background);
+    color: var(--header-text-color);
+}
+
+table.dataframe td {
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+table.dataframe th.bottomBorder {
+    border-bottom-color: var(--bold-border-color);
+}
+
+table.dataframe tbody > tr:nth-child(odd) {
+    background: var(--background-odd);
+}
+
+table.dataframe tbody > tr:nth-child(even) {
+    background: var(--background);
+}
+
+table.dataframe tbody > tr:hover {
+    background: var(--background-hover);
+}
+
+table.dataframe a {
+    cursor: pointer;
+    color: var(--link-color);
+    text-decoration: none;
+}
+
+table.dataframe tr:hover > td a {
+    color: var(--link-color-pale);
+}
+
+table.dataframe a:hover {
+    color: var(--link-hover);
+    text-decoration: underline;
+}
+
+table.dataframe img {
+    max-width: fit-content;
+}
+
+table.dataframe th.complex {
+    background-color: var(--background);
+    border: 1px solid var(--background);
+}
+
+table.dataframe .leftBorder {
+    border-left-color: var(--inner-border-color);
+}
+
+table.dataframe .rightBorder {
+    border-right-color: var(--inner-border-color);
+}
+
+table.dataframe .rightAlign {
+    text-align: right;
+}
+
+table.dataframe .expanderSvg {
+    width: 8px;
+    height: 8px;
+    margin-right: 3px;
+}
+
+table.dataframe .expander {
+    display: flex;
+    align-items: center;
+}
+
+/* formatting */
+
+table.dataframe .null {
+    color: var(--text-color-pale);
+}
+
+table.dataframe .structural {
+    color: var(--text-color-medium);
+    font-weight: bold;
+}
+
+table.dataframe .dataFrameCaption {
+    font-weight: bold;
+}
+
+table.dataframe .numbers {
+    color: var(--text-color-dark);
+}
+
+table.dataframe td:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+table.dataframe tr:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+
+body {
+    font-family: "JetBrains Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;
+}       
+
+:root {
+    color: #19191C;
+    background-color: #fff;
+}
+
+:root[theme="dark"] {
+    background-color: #19191C;
+    color: #FFFFFFCC
+}
+
+details details {
+    margin-left: 20px; 
+}
+
+summary {
+    padding: 6px;
+}
+</style>
+</head>
+<body>
+<table class="dataframe" id="df_0"></table>
+
+<p class="dataframe_description"></p>
+</body>
+<script>
+(function () {
+    window.DataFrame = window.DataFrame || new (function () {
+        this.addTable = function (df) {
+            let cols = df.cols;
+            for (let i = 0; i < cols.length; i++) {
+                for (let c of cols[i].children) {
+                    cols[c].parent = i;
+                }
+            }
+            df.nrow = 0
+            for (let i = 0; i < df.cols.length; i++) {
+                if (df.cols[i].values.length > df.nrow) df.nrow = df.cols[i].values.length
+            }
+            if (df.id === df.rootId) {
+                df.expandedFrames = new Set()
+                df.childFrames = {}
+                const table = this.getTableElement(df.id)
+                table.df = df
+                for (let i = 0; i < df.cols.length; i++) {
+                    let col = df.cols[i]
+                    if (col.parent === undefined && col.children.length > 0) col.expanded = true
+                }
+            } else {
+                const rootDf = this.getTableData(df.rootId)
+                rootDf.childFrames[df.id] = df
+            }
+        }
+
+        this.computeRenderData = function (df) {
+            let result = []
+            let pos = 0
+            for (let col = 0; col < df.cols.length; col++) {
+                if (df.cols[col].parent === undefined)
+                    pos += this.computeRenderDataRec(df.cols, col, pos, 0, result, false, false)
+            }
+            for (let i = 0; i < result.length; i++) {
+                let row = result[i]
+                for (let j = 0; j < row.length; j++) {
+                    let cell = row[j]
+                    if (j === 0)
+                        cell.leftBd = false
+                    if (j < row.length - 1) {
+                        let nextData = row[j + 1]
+                        if (nextData.leftBd) cell.rightBd = true
+                        else if (cell.rightBd) nextData.leftBd = true
+                    } else cell.rightBd = false
+                }
+            }
+            return result
+        }
+
+        this.computeRenderDataRec = function (cols, colId, pos, depth, result, leftBorder, rightBorder) {
+            if (result.length === depth) {
+                const array = [];
+                if (pos > 0) {
+                    let j = 0
+                    for (let i = 0; j < pos; i++) {
+                        let c = result[depth - 1][i]
+                        j += c.span
+                        let copy = Object.assign({empty: true}, c)
+                        array.push(copy)
+                    }
+                }
+                result.push(array)
+            }
+            const col = cols[colId];
+            let size = 0;
+            if (col.expanded) {
+                let childPos = pos
+                for (let i = 0; i < col.children.length; i++) {
+                    let child = col.children[i]
+                    let childLeft = i === 0 && (col.children.length > 1 || leftBorder)
+                    let childRight = i === col.children.length - 1 && (col.children.length > 1 || rightBorder)
+                    let childSize = this.computeRenderDataRec(cols, child, childPos, depth + 1, result, childLeft, childRight)
+                    childPos += childSize
+                    size += childSize
+                }
+            } else {
+                for (let i = depth + 1; i < result.length; i++)
+                    result[i].push({id: colId, span: 1, leftBd: leftBorder, rightBd: rightBorder, empty: true})
+                size = 1
+            }
+            let left = leftBorder
+            let right = rightBorder
+            if (size > 1) {
+                left = true
+                right = true
+            }
+            result[depth].push({id: colId, span: size, leftBd: left, rightBd: right})
+            return size
+        }
+
+        this.getTableElement = function (id) {
+            return document.getElementById("df_" + id)
+        }
+
+        this.getTableData = function (id) {
+            return this.getTableElement(id).df
+        }
+
+        this.createExpander = function (isExpanded) {
+            const svgNs = "http://www.w3.org/2000/svg"
+            let svg = document.createElementNS(svgNs, "svg")
+            svg.classList.add("expanderSvg")
+            let path = document.createElementNS(svgNs, "path")
+            if (isExpanded) {
+                svg.setAttribute("viewBox", "0 -2 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 4 4 4 -4 -1 -1 -3 3Z")
+            } else {
+                svg.setAttribute("viewBox", "-2 0 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 3 3 -3 3 1 1 4 -4Z")
+            }
+            path.setAttribute("fill", "currentColor")
+            svg.appendChild(path)
+            return svg
+        }
+
+        this.renderTable = function (id) {
+
+            let table = this.getTableElement(id)
+
+            if (table === null) return
+
+            table.innerHTML = ""
+
+            let df = table.df
+            let rootDf = df.rootId === df.id ? df : this.getTableData(df.rootId)
+
+            // header
+            let header = document.createElement("thead")
+            table.appendChild(header)
+
+            let renderData = this.computeRenderData(df)
+            for (let j = 0; j < renderData.length; j++) {
+                let rowData = renderData[j]
+                let tr = document.createElement("tr");
+                let isLastRow = j === renderData.length - 1
+                header.appendChild(tr);
+                for (let i = 0; i < rowData.length; i++) {
+                    let cell = rowData[i]
+                    let th = document.createElement("th");
+                    th.setAttribute("colspan", cell.span)
+                    let colId = cell.id
+                    let col = df.cols[colId];
+                    if (!cell.empty) {
+                        if (col.children.length === 0) {
+                            th.innerHTML = col.name
+                        } else {
+                            let link = document.createElement("a")
+                            link.className = "expander"
+                            let that = this
+                            link.onclick = function () {
+                                col.expanded = !col.expanded
+                                that.renderTable(id)
+                            }
+                            link.appendChild(this.createExpander(col.expanded))
+                            link.innerHTML += col.name
+                            th.appendChild(link)
+                        }
+                    }
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (isLastRow)
+                        classes += " bottomBorder"
+                    if (classes.length > 0)
+                        th.setAttribute("class", classes)
+                    tr.appendChild(th)
+                }
+            }
+
+            // body
+            let body = document.createElement("tbody")
+            table.appendChild(body)
+
+            let columns = renderData.pop()
+            for (let row = 0; row < df.nrow; row++) {
+                let tr = document.createElement("tr");
+                body.appendChild(tr)
+                for (let i = 0; i < columns.length; i++) {
+                    let cell = columns[i]
+                    let td = document.createElement("td");
+                    let colId = cell.id
+                    let col = df.cols[colId]
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (classes.length > 0)
+                        td.setAttribute("class", classes)
+                    tr.appendChild(td)
+                    let value = col.values[row]
+                    if (value.frameId !== undefined) {
+                        let frameId = value.frameId
+                        let expanded = rootDf.expandedFrames.has(frameId)
+                        let link = document.createElement("a")
+                        link.className = "expander"
+                        let that = this
+                        link.onclick = function () {
+                            if (rootDf.expandedFrames.has(frameId))
+                                rootDf.expandedFrames.delete(frameId)
+                            else rootDf.expandedFrames.add(frameId)
+                            that.renderTable(id)
+                        }
+                        link.appendChild(this.createExpander(expanded))
+                        link.innerHTML += value.value
+                        if (expanded) {
+                            td.appendChild(link)
+                            td.appendChild(document.createElement("p"))
+                            const childTable = document.createElement("table")
+                            childTable.className = "dataframe"
+                            childTable.id = "df_" + frameId
+                            let childDf = rootDf.childFrames[frameId]
+                            childTable.df = childDf
+                            td.appendChild(childTable)
+                            this.renderTable(frameId)
+                            if (childDf.nrow !== childDf.totalRows) {
+                                const footer = document.createElement("p")
+                                footer.innerText = `... showing only top ${childDf.nrow} of ${childDf.totalRows} rows`
+                                td.appendChild(footer)
+                            }
+                        } else {
+                            td.appendChild(link)
+                        }
+                    } else if (value.style !== undefined) {
+                        td.innerHTML = value.value
+                        td.setAttribute("style", value.style)
+                    } else td.innerHTML = value
+                    this.nodeScriptReplace(td)
+                }
+            }
+        }
+
+        this.nodeScriptReplace = function (node) {
+            if (this.nodeScriptIs(node) === true) {
+                node.parentNode.replaceChild(this.nodeScriptClone(node), node);
+            } else {
+                let i = -1, children = node.childNodes;
+                while (++i < children.length) {
+                    this.nodeScriptReplace(children[i]);
+                }
+            }
+
+            return node;
+        }
+
+        this.nodeScriptClone = function (node) {
+            let script = document.createElement("script");
+            script.text = node.innerHTML;
+
+            let i = -1, attrs = node.attributes, attr;
+            while (++i < attrs.length) {
+                script.setAttribute((attr = attrs[i]).name, attr.value);
+            }
+            return script;
+        }
+
+        this.nodeScriptIs = function (node) {
+            return node.tagName === 'SCRIPT';
+        }
+    })()
+
+    window.call_DataFrame = function (f) {
+        return f();
+    };
+
+    let funQueue = window["kotlinQueues"] && window["kotlinQueues"]["DataFrame"];
+    if (funQueue) {
+        funQueue.forEach(function (f) {
+            f();
+        });
+        funQueue = [];
+    }
+})()
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"name: String\" style=\"color:#f44336;font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace\">name</span>", children: [], rightAlign: false, values: ["Alice","Bob","Charlie"] }, 
+{ name: "<span title=\"count: Int\">count</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">3</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>"] }, 
+], id: 0, rootId: 0, totalRows: 3 } ) });
+/*-->*/
+
+call_DataFrame(function() { DataFrame.renderTable(0) });
+
+function sendHeight() {
+    const table = document.querySelector('table.dataframe');
+    if (!table) return;
+
+    let height = 0;
+    
+    const thead = table.querySelector('thead');
+    if (thead) height += thead.offsetHeight;
+    
+    const rows = table.querySelectorAll(':scope > tbody > tr');
+    rows.forEach(row => {
+        height += row.offsetHeight;
+    });
+    
+    height += getVerticalMargins(table) + 10;
+
+    window.parent.postMessage({ type: 'iframeHeight', height: Math.ceil(height) }, '*');
+}
+
+function getVerticalMargins(element) {
+    const style = getComputedStyle(element);
+    return parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+}
+
+function repeatHeightCalculation(maxRetries = 10, interval = 100) {
+    let retries = 0;
+    const intervalId = setInterval(() => {
+        sendHeight();
+        retries++;
+        if (retries >= maxRetries) clearInterval(intervalId);
+    }, interval);
+}
+
+window.addEventListener('load', repeatHeightCalculation);
+
+const observer = new MutationObserver(() => repeatHeightCalculation(5, 50));
+observer.observe(document.querySelector('.dataframe'), {
+    childList: true,
+    subtree: true,
+    characterData: true,
+});
+
+
+</script>
+</html>
diff --git a/docs/StardustDocs/resources/api/valueCounts/valueCountsWithNA.html b/docs/StardustDocs/resources/api/valueCounts/valueCountsWithNA.html
new file mode 100644
index 0000000000..56040bc78a
--- /dev/null
+++ b/docs/StardustDocs/resources/api/valueCounts/valueCountsWithNA.html
@@ -0,0 +1,512 @@
+<html>
+<head>
+<style type="text/css">
+:root {
+    --background: #fff;
+    --background-odd: #f5f5f5;
+    --background-hover: #d9edfd;
+    --header-text-color: #474747;
+    --text-color: #848484;
+    --text-color-dark: #000;
+    --text-color-medium: #737373;
+    --text-color-pale: #b3b3b3;
+    --inner-border-color: #aaa;
+    --bold-border-color: #000;
+    --link-color: #296eaa;
+    --link-color-pale: #296eaa;
+    --link-hover: #1a466c;
+}
+
+:root[theme="dark"], :root [data-jp-theme-light="false"], .dataframe_dark{
+    --background: #303030;
+    --background-odd: #3c3c3c;
+    --background-hover: #464646;
+    --header-text-color: #dddddd;
+    --text-color: #b3b3b3;
+    --text-color-dark: #dddddd;
+    --text-color-medium: #b2b2b2;
+    --text-color-pale: #737373;
+    --inner-border-color: #707070;
+    --bold-border-color: #777777;
+    --link-color: #008dc0;
+    --link-color-pale: #97e1fb;
+    --link-hover: #00688e;
+}
+
+p.dataframe_description {
+    color: var(--text-color-dark);
+}
+
+table.dataframe {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 12px;
+    background-color: var(--background);
+    color: var(--text-color-dark);
+    border: none;
+    border-collapse: collapse;
+}
+
+table.dataframe th, td {
+    padding: 6px;
+    border: 1px solid transparent;
+    text-align: left;
+}
+
+table.dataframe th {
+    background-color: var(--background);
+    color: var(--header-text-color);
+}
+
+table.dataframe td {
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+table.dataframe th.bottomBorder {
+    border-bottom-color: var(--bold-border-color);
+}
+
+table.dataframe tbody > tr:nth-child(odd) {
+    background: var(--background-odd);
+}
+
+table.dataframe tbody > tr:nth-child(even) {
+    background: var(--background);
+}
+
+table.dataframe tbody > tr:hover {
+    background: var(--background-hover);
+}
+
+table.dataframe a {
+    cursor: pointer;
+    color: var(--link-color);
+    text-decoration: none;
+}
+
+table.dataframe tr:hover > td a {
+    color: var(--link-color-pale);
+}
+
+table.dataframe a:hover {
+    color: var(--link-hover);
+    text-decoration: underline;
+}
+
+table.dataframe img {
+    max-width: fit-content;
+}
+
+table.dataframe th.complex {
+    background-color: var(--background);
+    border: 1px solid var(--background);
+}
+
+table.dataframe .leftBorder {
+    border-left-color: var(--inner-border-color);
+}
+
+table.dataframe .rightBorder {
+    border-right-color: var(--inner-border-color);
+}
+
+table.dataframe .rightAlign {
+    text-align: right;
+}
+
+table.dataframe .expanderSvg {
+    width: 8px;
+    height: 8px;
+    margin-right: 3px;
+}
+
+table.dataframe .expander {
+    display: flex;
+    align-items: center;
+}
+
+/* formatting */
+
+table.dataframe .null {
+    color: var(--text-color-pale);
+}
+
+table.dataframe .structural {
+    color: var(--text-color-medium);
+    font-weight: bold;
+}
+
+table.dataframe .dataFrameCaption {
+    font-weight: bold;
+}
+
+table.dataframe .numbers {
+    color: var(--text-color-dark);
+}
+
+table.dataframe td:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+table.dataframe tr:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+
+body {
+    font-family: "JetBrains Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;
+}       
+
+:root {
+    color: #19191C;
+    background-color: #fff;
+}
+
+:root[theme="dark"] {
+    background-color: #19191C;
+    color: #FFFFFFCC
+}
+
+details details {
+    margin-left: 20px; 
+}
+
+summary {
+    padding: 6px;
+}
+</style>
+</head>
+<body>
+<table class="dataframe" id="df_0"></table>
+
+<p class="dataframe_description"></p>
+</body>
+<script>
+(function () {
+    window.DataFrame = window.DataFrame || new (function () {
+        this.addTable = function (df) {
+            let cols = df.cols;
+            for (let i = 0; i < cols.length; i++) {
+                for (let c of cols[i].children) {
+                    cols[c].parent = i;
+                }
+            }
+            df.nrow = 0
+            for (let i = 0; i < df.cols.length; i++) {
+                if (df.cols[i].values.length > df.nrow) df.nrow = df.cols[i].values.length
+            }
+            if (df.id === df.rootId) {
+                df.expandedFrames = new Set()
+                df.childFrames = {}
+                const table = this.getTableElement(df.id)
+                table.df = df
+                for (let i = 0; i < df.cols.length; i++) {
+                    let col = df.cols[i]
+                    if (col.parent === undefined && col.children.length > 0) col.expanded = true
+                }
+            } else {
+                const rootDf = this.getTableData(df.rootId)
+                rootDf.childFrames[df.id] = df
+            }
+        }
+
+        this.computeRenderData = function (df) {
+            let result = []
+            let pos = 0
+            for (let col = 0; col < df.cols.length; col++) {
+                if (df.cols[col].parent === undefined)
+                    pos += this.computeRenderDataRec(df.cols, col, pos, 0, result, false, false)
+            }
+            for (let i = 0; i < result.length; i++) {
+                let row = result[i]
+                for (let j = 0; j < row.length; j++) {
+                    let cell = row[j]
+                    if (j === 0)
+                        cell.leftBd = false
+                    if (j < row.length - 1) {
+                        let nextData = row[j + 1]
+                        if (nextData.leftBd) cell.rightBd = true
+                        else if (cell.rightBd) nextData.leftBd = true
+                    } else cell.rightBd = false
+                }
+            }
+            return result
+        }
+
+        this.computeRenderDataRec = function (cols, colId, pos, depth, result, leftBorder, rightBorder) {
+            if (result.length === depth) {
+                const array = [];
+                if (pos > 0) {
+                    let j = 0
+                    for (let i = 0; j < pos; i++) {
+                        let c = result[depth - 1][i]
+                        j += c.span
+                        let copy = Object.assign({empty: true}, c)
+                        array.push(copy)
+                    }
+                }
+                result.push(array)
+            }
+            const col = cols[colId];
+            let size = 0;
+            if (col.expanded) {
+                let childPos = pos
+                for (let i = 0; i < col.children.length; i++) {
+                    let child = col.children[i]
+                    let childLeft = i === 0 && (col.children.length > 1 || leftBorder)
+                    let childRight = i === col.children.length - 1 && (col.children.length > 1 || rightBorder)
+                    let childSize = this.computeRenderDataRec(cols, child, childPos, depth + 1, result, childLeft, childRight)
+                    childPos += childSize
+                    size += childSize
+                }
+            } else {
+                for (let i = depth + 1; i < result.length; i++)
+                    result[i].push({id: colId, span: 1, leftBd: leftBorder, rightBd: rightBorder, empty: true})
+                size = 1
+            }
+            let left = leftBorder
+            let right = rightBorder
+            if (size > 1) {
+                left = true
+                right = true
+            }
+            result[depth].push({id: colId, span: size, leftBd: left, rightBd: right})
+            return size
+        }
+
+        this.getTableElement = function (id) {
+            return document.getElementById("df_" + id)
+        }
+
+        this.getTableData = function (id) {
+            return this.getTableElement(id).df
+        }
+
+        this.createExpander = function (isExpanded) {
+            const svgNs = "http://www.w3.org/2000/svg"
+            let svg = document.createElementNS(svgNs, "svg")
+            svg.classList.add("expanderSvg")
+            let path = document.createElementNS(svgNs, "path")
+            if (isExpanded) {
+                svg.setAttribute("viewBox", "0 -2 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 4 4 4 -4 -1 -1 -3 3Z")
+            } else {
+                svg.setAttribute("viewBox", "-2 0 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 3 3 -3 3 1 1 4 -4Z")
+            }
+            path.setAttribute("fill", "currentColor")
+            svg.appendChild(path)
+            return svg
+        }
+
+        this.renderTable = function (id) {
+
+            let table = this.getTableElement(id)
+
+            if (table === null) return
+
+            table.innerHTML = ""
+
+            let df = table.df
+            let rootDf = df.rootId === df.id ? df : this.getTableData(df.rootId)
+
+            // header
+            let header = document.createElement("thead")
+            table.appendChild(header)
+
+            let renderData = this.computeRenderData(df)
+            for (let j = 0; j < renderData.length; j++) {
+                let rowData = renderData[j]
+                let tr = document.createElement("tr");
+                let isLastRow = j === renderData.length - 1
+                header.appendChild(tr);
+                for (let i = 0; i < rowData.length; i++) {
+                    let cell = rowData[i]
+                    let th = document.createElement("th");
+                    th.setAttribute("colspan", cell.span)
+                    let colId = cell.id
+                    let col = df.cols[colId];
+                    if (!cell.empty) {
+                        if (col.children.length === 0) {
+                            th.innerHTML = col.name
+                        } else {
+                            let link = document.createElement("a")
+                            link.className = "expander"
+                            let that = this
+                            link.onclick = function () {
+                                col.expanded = !col.expanded
+                                that.renderTable(id)
+                            }
+                            link.appendChild(this.createExpander(col.expanded))
+                            link.innerHTML += col.name
+                            th.appendChild(link)
+                        }
+                    }
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (isLastRow)
+                        classes += " bottomBorder"
+                    if (classes.length > 0)
+                        th.setAttribute("class", classes)
+                    tr.appendChild(th)
+                }
+            }
+
+            // body
+            let body = document.createElement("tbody")
+            table.appendChild(body)
+
+            let columns = renderData.pop()
+            for (let row = 0; row < df.nrow; row++) {
+                let tr = document.createElement("tr");
+                body.appendChild(tr)
+                for (let i = 0; i < columns.length; i++) {
+                    let cell = columns[i]
+                    let td = document.createElement("td");
+                    let colId = cell.id
+                    let col = df.cols[colId]
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (classes.length > 0)
+                        td.setAttribute("class", classes)
+                    tr.appendChild(td)
+                    let value = col.values[row]
+                    if (value.frameId !== undefined) {
+                        let frameId = value.frameId
+                        let expanded = rootDf.expandedFrames.has(frameId)
+                        let link = document.createElement("a")
+                        link.className = "expander"
+                        let that = this
+                        link.onclick = function () {
+                            if (rootDf.expandedFrames.has(frameId))
+                                rootDf.expandedFrames.delete(frameId)
+                            else rootDf.expandedFrames.add(frameId)
+                            that.renderTable(id)
+                        }
+                        link.appendChild(this.createExpander(expanded))
+                        link.innerHTML += value.value
+                        if (expanded) {
+                            td.appendChild(link)
+                            td.appendChild(document.createElement("p"))
+                            const childTable = document.createElement("table")
+                            childTable.className = "dataframe"
+                            childTable.id = "df_" + frameId
+                            let childDf = rootDf.childFrames[frameId]
+                            childTable.df = childDf
+                            td.appendChild(childTable)
+                            this.renderTable(frameId)
+                            if (childDf.nrow !== childDf.totalRows) {
+                                const footer = document.createElement("p")
+                                footer.innerText = `... showing only top ${childDf.nrow} of ${childDf.totalRows} rows`
+                                td.appendChild(footer)
+                            }
+                        } else {
+                            td.appendChild(link)
+                        }
+                    } else if (value.style !== undefined) {
+                        td.innerHTML = value.value
+                        td.setAttribute("style", value.style)
+                    } else td.innerHTML = value
+                    this.nodeScriptReplace(td)
+                }
+            }
+        }
+
+        this.nodeScriptReplace = function (node) {
+            if (this.nodeScriptIs(node) === true) {
+                node.parentNode.replaceChild(this.nodeScriptClone(node), node);
+            } else {
+                let i = -1, children = node.childNodes;
+                while (++i < children.length) {
+                    this.nodeScriptReplace(children[i]);
+                }
+            }
+
+            return node;
+        }
+
+        this.nodeScriptClone = function (node) {
+            let script = document.createElement("script");
+            script.text = node.innerHTML;
+
+            let i = -1, attrs = node.attributes, attr;
+            while (++i < attrs.length) {
+                script.setAttribute((attr = attrs[i]).name, attr.value);
+            }
+            return script;
+        }
+
+        this.nodeScriptIs = function (node) {
+            return node.tagName === 'SCRIPT';
+        }
+    })()
+
+    window.call_DataFrame = function (f) {
+        return f();
+    };
+
+    let funQueue = window["kotlinQueues"] && window["kotlinQueues"]["DataFrame"];
+    if (funQueue) {
+        funQueue.forEach(function (f) {
+            f();
+        });
+        funQueue = [];
+    }
+})()
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"name: String\">name</span>", children: [], rightAlign: false, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Alice"},"Bob","Charlie",{ style: "background-color:#e9c7dc;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Alice"}] }, 
+{ name: "<span title=\"age: Int?\">age</span>", children: [], rightAlign: true, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">15</span></span>"},"<span class=\"formatted\" title=\"\"><span class=\"numbers\">20</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">25</span></span>",{ style: "background-color:#e9c7dc;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"null\">null</span></span>"}] }, 
+{ name: "<span title=\"count: Int\">count</span>", children: [], rightAlign: true, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">2</span></span>"},"<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>",{ style: "background-color:#e9c7dc;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>"}] }, 
+], id: 0, rootId: 0, totalRows: 4 } ) });
+/*-->*/
+
+call_DataFrame(function() { DataFrame.renderTable(0) });
+
+function sendHeight() {
+    const table = document.querySelector('table.dataframe');
+    if (!table) return;
+
+    let height = 0;
+    
+    const thead = table.querySelector('thead');
+    if (thead) height += thead.offsetHeight;
+    
+    const rows = table.querySelectorAll(':scope > tbody > tr');
+    rows.forEach(row => {
+        height += row.offsetHeight;
+    });
+    
+    height += getVerticalMargins(table) + 10;
+
+    window.parent.postMessage({ type: 'iframeHeight', height: Math.ceil(height) }, '*');
+}
+
+function getVerticalMargins(element) {
+    const style = getComputedStyle(element);
+    return parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+}
+
+function repeatHeightCalculation(maxRetries = 10, interval = 100) {
+    let retries = 0;
+    const intervalId = setInterval(() => {
+        sendHeight();
+        retries++;
+        if (retries >= maxRetries) clearInterval(intervalId);
+    }, interval);
+}
+
+window.addEventListener('load', repeatHeightCalculation);
+
+const observer = new MutationObserver(() => repeatHeightCalculation(5, 50));
+observer.observe(document.querySelector('.dataframe'), {
+    childList: true,
+    subtree: true,
+    characterData: true,
+});
+
+
+</script>
+</html>
diff --git a/docs/StardustDocs/resources/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Analyze.valueCounts.html b/docs/StardustDocs/resources/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Analyze.valueCounts.html
deleted file mode 100644
index e8f152906d..0000000000
--- a/docs/StardustDocs/resources/snippets/org.jetbrains.kotlinx.dataframe.samples.api.Analyze.valueCounts.html
+++ /dev/null
@@ -1,638 +0,0 @@
-<html>
-<head>
-<style type="text/css">
-:root {
-    --background: #fff;
-    --background-odd: #f5f5f5;
-    --background-hover: #d9edfd;
-    --header-text-color: #474747;
-    --text-color: #848484;
-    --text-color-dark: #000;
-    --text-color-medium: #737373;
-    --text-color-pale: #b3b3b3;
-    --inner-border-color: #aaa;
-    --bold-border-color: #000;
-    --link-color: #296eaa;
-    --link-color-pale: #296eaa;
-    --link-hover: #1a466c;
-}
-
-:root[theme="dark"], :root [data-jp-theme-light="false"], .dataframe_dark{
-    --background: #303030;
-    --background-odd: #3c3c3c;
-    --background-hover: #464646;
-    --header-text-color: #dddddd;
-    --text-color: #b3b3b3;
-    --text-color-dark: #dddddd;
-    --text-color-medium: #b2b2b2;
-    --text-color-pale: #737373;
-    --inner-border-color: #707070;
-    --bold-border-color: #777777;
-    --link-color: #008dc0;
-    --link-color-pale: #97e1fb;
-    --link-hover: #00688e;
-}
-
-p.dataframe_description {
-    color: var(--text-color-dark);
-}
-
-table.dataframe {
-    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
-    font-size: 12px;
-    background-color: var(--background);
-    color: var(--text-color-dark);
-    border: none;
-    border-collapse: collapse;
-}
-
-table.dataframe th, td {
-    padding: 6px;
-    border: 1px solid transparent;
-    text-align: left;
-}
-
-table.dataframe th {
-    background-color: var(--background);
-    color: var(--header-text-color);
-}
-
-table.dataframe td {
-    vertical-align: top;
-    white-space: nowrap;
-}
-
-table.dataframe th.bottomBorder {
-    border-bottom-color: var(--bold-border-color);
-}
-
-table.dataframe tbody > tr:nth-child(odd) {
-    background: var(--background-odd);
-}
-
-table.dataframe tbody > tr:nth-child(even) {
-    background: var(--background);
-}
-
-table.dataframe tbody > tr:hover {
-    background: var(--background-hover);
-}
-
-table.dataframe a {
-    cursor: pointer;
-    color: var(--link-color);
-    text-decoration: none;
-}
-
-table.dataframe tr:hover > td a {
-    color: var(--link-color-pale);
-}
-
-table.dataframe a:hover {
-    color: var(--link-hover);
-    text-decoration: underline;
-}
-
-table.dataframe img {
-    max-width: fit-content;
-}
-
-table.dataframe th.complex {
-    background-color: var(--background);
-    border: 1px solid var(--background);
-}
-
-table.dataframe .leftBorder {
-    border-left-color: var(--inner-border-color);
-}
-
-table.dataframe .rightBorder {
-    border-right-color: var(--inner-border-color);
-}
-
-table.dataframe .rightAlign {
-    text-align: right;
-}
-
-table.dataframe .expanderSvg {
-    width: 8px;
-    height: 8px;
-    margin-right: 3px;
-}
-
-table.dataframe .expander {
-    display: flex;
-    align-items: center;
-}
-
-/* formatting */
-
-table.dataframe .null {
-    color: var(--text-color-pale);
-}
-
-table.dataframe .structural {
-    color: var(--text-color-medium);
-    font-weight: bold;
-}
-
-table.dataframe .dataFrameCaption {
-    font-weight: bold;
-}
-
-table.dataframe .numbers {
-    color: var(--text-color-dark);
-}
-
-table.dataframe td:hover .formatted .structural, .null {
-    color: var(--text-color-dark);
-}
-
-table.dataframe tr:hover .formatted .structural, .null {
-    color: var(--text-color-dark);
-}
-
-
-body {
-    font-family: "JetBrains Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;
-}       
-
-:root {
-    color: #19191C;
-    background-color: #fff;
-}
-
-:root[theme="dark"] {
-    background-color: #19191C;
-    color: #FFFFFFCC
-}
-
-details details {
-    margin-left: 20px; 
-}
-
-summary {
-    padding: 6px;
-}
-</style>
-</head>
-<body>
-                                <details>
-                                <summary>df.valueCounts()</summary>
-                                                                <details>
-                                <summary>Input DataFrame: rowsCount = 7, columnsCount = 5</summary>
-                                 <table class="dataframe" id="df_0"></table>
-
-<p class="dataframe_description"></p>
-                                </details>
-                                <details>
-                                <summary>Output DataFrame: rowsCount = 5, columnsCount = 2</summary>
-                                 <table class="dataframe" id="df_1"></table>
-
-<p class="dataframe_description"></p>
-                                </details>
-                                </details>
-                                <br>
-                                <details>
-                                <summary>df.valueCounts { name and city }</summary>
-                                                                <details>
-                                <summary>Input DataFrame: rowsCount = 7, columnsCount = 5</summary>
-                                 <table class="dataframe" id="df_2"></table>
-
-<p class="dataframe_description"></p>
-                                </details>
-                                <details>
-                                <summary>Output DataFrame: rowsCount = 6, columnsCount = 3</summary>
-                                 <table class="dataframe" id="df_3"></table>
-
-<p class="dataframe_description"></p>
-                                </details>
-                                </details>
-                                <br>
-</body>
-<script>
-(function () {
-    window.DataFrame = window.DataFrame || new (function () {
-        this.addTable = function (df) {
-            let cols = df.cols;
-            for (let i = 0; i < cols.length; i++) {
-                for (let c of cols[i].children) {
-                    cols[c].parent = i;
-                }
-            }
-            df.nrow = 0
-            for (let i = 0; i < df.cols.length; i++) {
-                if (df.cols[i].values.length > df.nrow) df.nrow = df.cols[i].values.length
-            }
-            if (df.id === df.rootId) {
-                df.expandedFrames = new Set()
-                df.childFrames = {}
-                const table = this.getTableElement(df.id)
-                table.df = df
-                for (let i = 0; i < df.cols.length; i++) {
-                    let col = df.cols[i]
-                    if (col.parent === undefined && col.children.length > 0) col.expanded = true
-                }
-            } else {
-                const rootDf = this.getTableData(df.rootId)
-                rootDf.childFrames[df.id] = df
-            }
-        }
-
-        this.computeRenderData = function (df) {
-            let result = []
-            let pos = 0
-            for (let col = 0; col < df.cols.length; col++) {
-                if (df.cols[col].parent === undefined)
-                    pos += this.computeRenderDataRec(df.cols, col, pos, 0, result, false, false)
-            }
-            for (let i = 0; i < result.length; i++) {
-                let row = result[i]
-                for (let j = 0; j < row.length; j++) {
-                    let cell = row[j]
-                    if (j === 0)
-                        cell.leftBd = false
-                    if (j < row.length - 1) {
-                        let nextData = row[j + 1]
-                        if (nextData.leftBd) cell.rightBd = true
-                        else if (cell.rightBd) nextData.leftBd = true
-                    } else cell.rightBd = false
-                }
-            }
-            return result
-        }
-
-        this.computeRenderDataRec = function (cols, colId, pos, depth, result, leftBorder, rightBorder) {
-            if (result.length === depth) {
-                const array = [];
-                if (pos > 0) {
-                    let j = 0
-                    for (let i = 0; j < pos; i++) {
-                        let c = result[depth - 1][i]
-                        j += c.span
-                        let copy = Object.assign({empty: true}, c)
-                        array.push(copy)
-                    }
-                }
-                result.push(array)
-            }
-            const col = cols[colId];
-            let size = 0;
-            if (col.expanded) {
-                let childPos = pos
-                for (let i = 0; i < col.children.length; i++) {
-                    let child = col.children[i]
-                    let childLeft = i === 0 && (col.children.length > 1 || leftBorder)
-                    let childRight = i === col.children.length - 1 && (col.children.length > 1 || rightBorder)
-                    let childSize = this.computeRenderDataRec(cols, child, childPos, depth + 1, result, childLeft, childRight)
-                    childPos += childSize
-                    size += childSize
-                }
-            } else {
-                for (let i = depth + 1; i < result.length; i++)
-                    result[i].push({id: colId, span: 1, leftBd: leftBorder, rightBd: rightBorder, empty: true})
-                size = 1
-            }
-            let left = leftBorder
-            let right = rightBorder
-            if (size > 1) {
-                left = true
-                right = true
-            }
-            result[depth].push({id: colId, span: size, leftBd: left, rightBd: right})
-            return size
-        }
-
-        this.getTableElement = function (id) {
-            return document.getElementById("df_" + id)
-        }
-
-        this.getTableData = function (id) {
-            return this.getTableElement(id).df
-        }
-
-        this.createExpander = function (isExpanded) {
-            const svgNs = "http://www.w3.org/2000/svg"
-            let svg = document.createElementNS(svgNs, "svg")
-            svg.classList.add("expanderSvg")
-            let path = document.createElementNS(svgNs, "path")
-            if (isExpanded) {
-                svg.setAttribute("viewBox", "0 -2 8 8")
-                path.setAttribute("d", "M1 0 l-1 1 4 4 4 -4 -1 -1 -3 3Z")
-            } else {
-                svg.setAttribute("viewBox", "-2 0 8 8")
-                path.setAttribute("d", "M1 0 l-1 1 3 3 -3 3 1 1 4 -4Z")
-            }
-            path.setAttribute("fill", "currentColor")
-            svg.appendChild(path)
-            return svg
-        }
-
-        this.renderTable = function (id) {
-
-            let table = this.getTableElement(id)
-
-            if (table === null) return
-
-            table.innerHTML = ""
-
-            let df = table.df
-            let rootDf = df.rootId === df.id ? df : this.getTableData(df.rootId)
-
-            // header
-            let header = document.createElement("thead")
-            table.appendChild(header)
-
-            let renderData = this.computeRenderData(df)
-            for (let j = 0; j < renderData.length; j++) {
-                let rowData = renderData[j]
-                let tr = document.createElement("tr");
-                let isLastRow = j === renderData.length - 1
-                header.appendChild(tr);
-                for (let i = 0; i < rowData.length; i++) {
-                    let cell = rowData[i]
-                    let th = document.createElement("th");
-                    th.setAttribute("colspan", cell.span)
-                    let colId = cell.id
-                    let col = df.cols[colId];
-                    if (!cell.empty) {
-                        if (col.children.length === 0) {
-                            th.innerHTML = col.name
-                        } else {
-                            let link = document.createElement("a")
-                            link.className = "expander"
-                            let that = this
-                            link.onclick = function () {
-                                col.expanded = !col.expanded
-                                that.renderTable(id)
-                            }
-                            link.appendChild(this.createExpander(col.expanded))
-                            link.innerHTML += col.name
-                            th.appendChild(link)
-                        }
-                    }
-                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
-                    if (col.rightAlign)
-                        classes += " rightAlign"
-                    if (isLastRow)
-                        classes += " bottomBorder"
-                    if (classes.length > 0)
-                        th.setAttribute("class", classes)
-                    tr.appendChild(th)
-                }
-            }
-
-            // body
-            let body = document.createElement("tbody")
-            table.appendChild(body)
-
-            let columns = renderData.pop()
-            for (let row = 0; row < df.nrow; row++) {
-                let tr = document.createElement("tr");
-                body.appendChild(tr)
-                for (let i = 0; i < columns.length; i++) {
-                    let cell = columns[i]
-                    let td = document.createElement("td");
-                    let colId = cell.id
-                    let col = df.cols[colId]
-                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
-                    if (col.rightAlign)
-                        classes += " rightAlign"
-                    if (classes.length > 0)
-                        td.setAttribute("class", classes)
-                    tr.appendChild(td)
-                    let value = col.values[row]
-                    if (value.frameId !== undefined) {
-                        let frameId = value.frameId
-                        let expanded = rootDf.expandedFrames.has(frameId)
-                        let link = document.createElement("a")
-                        link.className = "expander"
-                        let that = this
-                        link.onclick = function () {
-                            if (rootDf.expandedFrames.has(frameId))
-                                rootDf.expandedFrames.delete(frameId)
-                            else rootDf.expandedFrames.add(frameId)
-                            that.renderTable(id)
-                        }
-                        link.appendChild(this.createExpander(expanded))
-                        link.innerHTML += value.value
-                        if (expanded) {
-                            td.appendChild(link)
-                            td.appendChild(document.createElement("p"))
-                            const childTable = document.createElement("table")
-                            childTable.className = "dataframe"
-                            childTable.id = "df_" + frameId
-                            let childDf = rootDf.childFrames[frameId]
-                            childTable.df = childDf
-                            td.appendChild(childTable)
-                            this.renderTable(frameId)
-                            if (childDf.nrow !== childDf.totalRows) {
-                                const footer = document.createElement("p")
-                                footer.innerText = `... showing only top ${childDf.nrow} of ${childDf.totalRows} rows`
-                                td.appendChild(footer)
-                            }
-                        } else {
-                            td.appendChild(link)
-                        }
-                    } else if (value.style !== undefined) {
-                        td.innerHTML = value.value
-                        td.setAttribute("style", value.style)
-                    } else td.innerHTML = value
-                    this.nodeScriptReplace(td)
-                }
-            }
-        }
-
-        this.nodeScriptReplace = function (node) {
-            if (this.nodeScriptIs(node) === true) {
-                node.parentNode.replaceChild(this.nodeScriptClone(node), node);
-            } else {
-                let i = -1, children = node.childNodes;
-                while (++i < children.length) {
-                    this.nodeScriptReplace(children[i]);
-                }
-            }
-
-            return node;
-        }
-
-        this.nodeScriptClone = function (node) {
-            let script = document.createElement("script");
-            script.text = node.innerHTML;
-
-            let i = -1, attrs = node.attributes, attr;
-            while (++i < attrs.length) {
-                script.setAttribute((attr = attrs[i]).name, attr.value);
-            }
-            return script;
-        }
-
-        this.nodeScriptIs = function (node) {
-            return node.tagName === 'SCRIPT';
-        }
-    })()
-
-    window.call_DataFrame = function (f) {
-        return f();
-    };
-
-    let funQueue = window["kotlinQueues"] && window["kotlinQueues"]["DataFrame"];
-    if (funQueue) {
-        funQueue.forEach(function (f) {
-            f();
-        });
-        funQueue = [];
-    }
-})()
-
-function sendHeight() {
-    let totalHeight = 0;
-
-    document.querySelectorAll('body > details, body > br, body > table').forEach(element => {
-        if (element.tagName === 'DETAILS') {
-            totalHeight += getElementHeight(element.querySelector(':scope > summary'));
-
-            if (element.open) {
-                totalHeight += getVisibleContentHeight(element);
-            }
-        } else if (element.tagName === 'BR') {
-            totalHeight += getElementHeight(element);
-        } else if (element.tagName === 'TABLE') {
-            totalHeight += getElementHeight(element);
-        }
-    });
-
-    totalHeight += 10;
-
-    window.parent.postMessage({type: 'iframeHeight', height: Math.ceil(totalHeight)}, '*');
-}
-
-function getVisibleContentHeight(detailsElement) {
-    let height = 0;
-
-    detailsElement.querySelectorAll(':scope > details, :scope > table, :scope > p').forEach(child => {
-        if (child.tagName === 'DETAILS') {
-            const summary = child.querySelector(':scope > summary');
-            height += getElementHeight(summary);
-
-            if (child.open) {
-                height += getDirectVisibleContentHeight(child);
-            }
-        } else if (isElementVisible(child)) {
-            height += getElementHeight(child);
-        }
-    });
-
-    return height;
-}
-
-function getDirectVisibleContentHeight(element) {
-    let height = 0;
-    element.querySelectorAll(':scope > table, :scope > p, :scope > summary').forEach(child => {
-        if (isElementVisible(child)) {
-            height += getElementHeight(child);
-        }
-    });
-    return height;
-}
-
-function getElementHeight(el) {
-    const styles = getComputedStyle(el);
-    const margin = parseFloat(styles.marginTop) + parseFloat(styles.marginBottom);
-    
-    // More reliable cross-browser calculation
-    const rect = el.getBoundingClientRect();
-    return rect.height + margin;
-}
-
-function isElementVisible(el) {
-    return !!(el.offsetWidth || el.offsetHeight || el.getClientRects().length);
-}
-
-function sendInitialHeight() {
-    let initialHeight = 0;
-
-    document.querySelectorAll('body > details, body > br, body > table').forEach(element => {
-        if (element.tagName === 'DETAILS') {
-            initialHeight += getElementHeight(element.querySelector(':scope > summary'));
-        } else if (element.tagName === 'BR') {
-            initialHeight += getElementHeight(element);
-        } else if (element.tagName === `TABLE`) {
-            initialHeight += getElementHeight(element);
-        }
-    });
-
-    initialHeight += 10;
-
-    window.parent.postMessage({type: 'iframeHeight', height: Math.ceil(initialHeight)}, '*');
-}
-
-function repeatHeightCalculation(maxRetries = 10, interval = 100) {
-    let retries = 0;
-    const intervalId = setInterval(() => {
-        sendInitialHeight();
-        retries++;
-        if (retries >= maxRetries) clearInterval(intervalId);
-    }, interval);
-}
-
-window.addEventListener('load', () => {
-    repeatHeightCalculation();
-
-
-    document.querySelectorAll('details').forEach(detail => {
-        detail.addEventListener('toggle', () => {
-            setTimeout(sendHeight, 50);
-        });
-    });
-
-    const observer = new MutationObserver(() => setTimeout(sendHeight, 50));
-    observer.observe(document.body, {childList: true, subtree: true, characterData: true});
-});
-/*<!--*/
-call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"firstName: String\">firstName</span>", children: [], rightAlign: false, values: ["Alice","Bob","Charlie","Charlie","Bob","Alice","Charlie"] }, 
-{ name: "<span title=\"lastName: String\">lastName</span>", children: [], rightAlign: false, values: ["Cooper","Dylan","Daniels","Chaplin","Marley","Wolf","Byrd"] }, 
-{ name: "<span title=\"name: DataRow<*>\">name</span>", children: [0, 1], rightAlign: false, values: ["<span class=\"formatted\" title=\"firstName: Alice\nlastName: Cooper\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Alice<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Cooper<span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Bob\nlastName: Dylan\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Bob<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Dylan<span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Daniels\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Dan<span class=\"structural\">...</span><span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Chaplin\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Cha<span class=\"structural\">...</span><span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Bob\nlastName: Marley\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Bob<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Marley<span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Alice\nlastName: Wolf\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Alice<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Wolf<span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Byrd\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Byrd<span class=\"structural\"> }</span></span>"] }, 
-{ name: "<span title=\"age: Int\">age</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">15</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">45</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">20</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">40</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">30</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">20</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">30</span></span>"] }, 
-{ name: "<span title=\"city: String?\">city</span>", children: [], rightAlign: false, values: ["London","Dubai","Moscow","Milan","Tokyo","<span class=\"formatted\" title=\"\"><span class=\"null\">null</span></span>","Moscow"] }, 
-{ name: "<span title=\"weight: Int?\">weight</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">54</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">87</span></span>","<span class=\"formatted\" title=\"\"><span class=\"null\">null</span></span>","<span class=\"formatted\" title=\"\"><span class=\"null\">null</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">68</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">55</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">90</span></span>"] }, 
-{ name: "<span title=\"isHappy: Boolean\">isHappy</span>", children: [], rightAlign: false, values: ["true","true","false","true","true","false","true"] }, 
-], id: 0, rootId: 0, totalRows: 7 } ) });
-/*-->*/
-
-call_DataFrame(function() { DataFrame.renderTable(0) });
-
-/*<!--*/
-call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: ["Moscow","London","Dubai","Milan","Tokyo"] }, 
-{ name: "<span title=\"count: Int\">count</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">2</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>"] }, 
-], id: 1, rootId: 1, totalRows: 5 } ) });
-/*-->*/
-
-call_DataFrame(function() { DataFrame.renderTable(1) });
-
-/*<!--*/
-call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"firstName: String\">firstName</span>", children: [], rightAlign: false, values: ["Alice","Bob","Charlie","Charlie","Bob","Alice","Charlie"] }, 
-{ name: "<span title=\"lastName: String\">lastName</span>", children: [], rightAlign: false, values: ["Cooper","Dylan","Daniels","Chaplin","Marley","Wolf","Byrd"] }, 
-{ name: "<span title=\"name: DataRow<*>\">name</span>", children: [0, 1], rightAlign: false, values: ["<span class=\"formatted\" title=\"firstName: Alice\nlastName: Cooper\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Alice<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Cooper<span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Bob\nlastName: Dylan\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Bob<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Dylan<span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Daniels\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Dan<span class=\"structural\">...</span><span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Chaplin\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Cha<span class=\"structural\">...</span><span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Bob\nlastName: Marley\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Bob<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Marley<span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Alice\nlastName: Wolf\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Alice<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Wolf<span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Byrd\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Byrd<span class=\"structural\"> }</span></span>"] }, 
-{ name: "<span title=\"age: Int\">age</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">15</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">45</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">20</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">40</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">30</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">20</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">30</span></span>"] }, 
-{ name: "<span title=\"city: String?\">city</span>", children: [], rightAlign: false, values: ["London","Dubai","Moscow","Milan","Tokyo","<span class=\"formatted\" title=\"\"><span class=\"null\">null</span></span>","Moscow"] }, 
-{ name: "<span title=\"weight: Int?\">weight</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">54</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">87</span></span>","<span class=\"formatted\" title=\"\"><span class=\"null\">null</span></span>","<span class=\"formatted\" title=\"\"><span class=\"null\">null</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">68</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">55</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">90</span></span>"] }, 
-{ name: "<span title=\"isHappy: Boolean\">isHappy</span>", children: [], rightAlign: false, values: ["true","true","false","true","true","false","true"] }, 
-], id: 2, rootId: 2, totalRows: 7 } ) });
-/*-->*/
-
-call_DataFrame(function() { DataFrame.renderTable(2) });
-
-/*<!--*/
-call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"firstName: String\">firstName</span>", children: [], rightAlign: false, values: ["Alice","Bob","Charlie","Charlie","Bob","Charlie"] }, 
-{ name: "<span title=\"lastName: String\">lastName</span>", children: [], rightAlign: false, values: ["Cooper","Dylan","Daniels","Chaplin","Marley","Byrd"] }, 
-{ name: "<span title=\"name: DataRow<*>\">name</span>", children: [0, 1], rightAlign: false, values: ["<span class=\"formatted\" title=\"firstName: Alice\nlastName: Cooper\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Alice<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Cooper<span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Bob\nlastName: Dylan\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Bob<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Dylan<span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Daniels\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Dan<span class=\"structural\">...</span><span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Chaplin\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Cha<span class=\"structural\">...</span><span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Bob\nlastName: Marley\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Bob<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Marley<span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Byrd\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Byrd<span class=\"structural\"> }</span></span>"] }, 
-{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: ["London","Dubai","Moscow","Milan","Tokyo","Moscow"] }, 
-{ name: "<span title=\"count: Int\">count</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>"] }, 
-], id: 3, rootId: 3, totalRows: 6 } ) });
-/*-->*/
-
-call_DataFrame(function() { DataFrame.renderTable(3) });
-
-</script>
-</html>
diff --git a/docs/StardustDocs/topics/_shadow_resources.md b/docs/StardustDocs/topics/_shadow_resources.md
index 5177946e55..b92b8613c1 100644
--- a/docs/StardustDocs/topics/_shadow_resources.md
+++ b/docs/StardustDocs/topics/_shadow_resources.md
@@ -191,6 +191,11 @@
 <resource src="notebook_test_tail_1.html"></resource>
 <resource src="notebook_test_tail_2.html"></resource>
 <resource src="notebook_test_tail_3.html"></resource>
+<resource src="valueCounts.html"></resource>
+<resource src="valueCountsColumn.html"></resource>
+<resource src="valueCountsDf.html"></resource>
+<resource src="valueCountsSelector_properties.html"></resource>
+<resource src="valueCountsWithNA.html"></resource>
 <resource src="example.csv"></resource>
 <resource src="quickstart.ipynb"></resource>
 <resource src="dfCast.html"></resource>
@@ -261,7 +266,6 @@
 <resource src="org.jetbrains.kotlinx.dataframe.samples.api.Analyze.statisticPivotMany.html"></resource>
 <resource src="org.jetbrains.kotlinx.dataframe.samples.api.Analyze.statisticPivotManySeparate.html"></resource>
 <resource src="org.jetbrains.kotlinx.dataframe.samples.api.Analyze.statisticPivotSingle.html"></resource>
-<resource src="org.jetbrains.kotlinx.dataframe.samples.api.Analyze.valueCounts.html"></resource>
 <resource src="org.jetbrains.kotlinx.dataframe.samples.api.Create.columnAccessorMap.html"></resource>
 <resource src="org.jetbrains.kotlinx.dataframe.samples.api.Create.createDataFrameFromMap.html"></resource>
 <resource src="org.jetbrains.kotlinx.dataframe.samples.api.Create.createDataFrameWithFill.html"></resource>
diff --git a/docs/StardustDocs/topics/valueCounts.md b/docs/StardustDocs/topics/valueCounts.md
index aae0fc8b66..f2e4962073 100644
--- a/docs/StardustDocs/topics/valueCounts.md
+++ b/docs/StardustDocs/topics/valueCounts.md
@@ -1,30 +1,86 @@
 [//]: # (title: valueCounts)
 
-<!---IMPORT org.jetbrains.kotlinx.dataframe.samples.api.Analyze-->
+<!---IMPORT org.jetbrains.kotlinx.dataframe.samples.api.ValueCountsSamples-->
 
-Return [`DataFrame`](DataFrame.md) containing counts of unique values in [`DataFrame`](DataFrame.md) 
+Returns a [`DataFrame`](DataFrame.md) containing the counts of the unique values in a [`DataFrame`](DataFrame.md)
 or [`DataColumn`](DataColumn.md).
 
 ```kotlin
-valueCounts(sort = true, ascending = false, dropNA = false)
+valueCounts(sort = true, ascending = false, dropNA = true, resultColumn = "count")
      [ { columns } ]
 ```
 
 See [column selectors](ColumnSelectors.md) for how to select the columns for this operation.
 
 **Parameters:**
-* `sort: Boolean = true` — sort by count
-* `ascending: Boolean = false` — sort in ascending order
-* `dropNA: Boolean = true` — don't include counts of [`NA`](nanAndNa.md) values 
-* `columns = all` — columns to use when counting unique combinations 
+* `sort: Boolean = true` — whether to sort by count
+* `ascending: Boolean = false` — sort direction (by default most frequent first)
+* `dropNA: Boolean = true` — whether to exclude [`NA`](nanAndNa.md) values from counting (excluded by default)
+* `resultColumn: String = "count"` — name of the column with counts
+* `columns = all` — columns to use when counting unique combinations
+
+The following dataframe will be used in the examples below:
+
+<!---FUN valueCountsDf-->
+
+```kotlin
+df
+```
+
+<!---END-->
+<inline-frame src="./resources/valueCountsDf.html" width="100%" height="500px"></inline-frame>
+
+For a [`DataFrame`](DataFrame.md), `dropNA = true` (default) excludes the entire row if any selected column contains
+an [`NA`](nanAndNa.md) value. [`NA`](nanAndNa.md) values in columns that are not selected do not affect the result.
 
 <!---FUN valueCounts-->
 
 ```kotlin
-df.city.valueCounts()
+df.valueCounts()
+```
+
+<!---END-->
+<inline-frame src="./resources/valueCounts.html" width="100%" height="500px"></inline-frame>
+
+To include rows with [`NA`](nanAndNa.md) values, set `dropNA = false`:
+
+<!---FUN valueCountsWithNA-->
+
+```kotlin
+df.valueCounts(dropNA = false)
+```
+
+<!---END-->
+<inline-frame src="./resources/valueCountsWithNA.html" width="100%" height="500px"></inline-frame>
+
+You can specify columns that will be used to determine uniqueness:
+
+<!---FUN valueCountsSelector-->
+<tabs>
+<tab title="Properties">
+
+```kotlin
+df.valueCounts(dropNA = false) { name }
+```
+
+</tab>
+<tab title="Strings">
+
+```kotlin
+df.valueCounts("name", dropNA = false)
+```
+
+</tab></tabs>
+<!---END-->
+<inline-frame src="./resources/valueCountsSelector_properties.html" width="100%" height="500px"></inline-frame>
+
+This operation can also be applied to a [`DataColumn`](DataColumn.md):
 
-df.valueCounts { name and city }
+<!---FUN valueCountsColumn-->
+
+```kotlin
+df.age.valueCounts()
 ```
 
-<inline-frame src="resources/org.jetbrains.kotlinx.dataframe.samples.api.Analyze.valueCounts.html" width="100%"/>
 <!---END-->
+<inline-frame src="./resources/valueCountsColumn.html" width="100%" height="500px"></inline-frame>
diff --git a/samples/build.gradle.kts b/samples/build.gradle.kts
index 7cf0ccfd52..08d513d05b 100644
--- a/samples/build.gradle.kts
+++ b/samples/build.gradle.kts
@@ -117,6 +117,7 @@ korro {
                 include("groupBy.md")
                 include("pivot.md")
                 include("countDistinct.md")
+                include("valueCounts.md")
             },
         )
         baseDir = rootProject.file("docs/StardustDocs/topics")
diff --git a/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/ValueCountsSamples.kt b/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/ValueCountsSamples.kt
new file mode 100644
index 0000000000..7a086696f4
--- /dev/null
+++ b/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/ValueCountsSamples.kt
@@ -0,0 +1,101 @@
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.annotations.DataSchema
+import org.jetbrains.kotlinx.dataframe.api.RgbColor
+import org.jetbrains.kotlinx.dataframe.api.and
+import org.jetbrains.kotlinx.dataframe.api.cast
+import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
+import org.jetbrains.kotlinx.dataframe.api.format
+import org.jetbrains.kotlinx.dataframe.api.perRowCol
+import org.jetbrains.kotlinx.dataframe.api.valueCounts
+import org.jetbrains.kotlinx.dataframe.samples.DataFrameSampleHelper
+import org.jetbrains.kotlinx.dataframe.util.defaultHeaderFormatting
+import org.junit.Test
+
+class ValueCountsSamples : DataFrameSampleHelper("valueCounts", "api") {
+    @DataSchema
+    interface SimplePerson {
+        val name: String
+        val age: Int?
+    }
+
+    private val df: DataFrame<SimplePerson> = dataFrameOf(
+        "name" to listOf("Alice", "Bob", "Charlie", "Alice", "Alice"),
+        "age" to listOf(15, 20, 25, 15, null),
+    ).cast()
+
+    private val alice15Color = RgbColor(189, 206, 233)
+    private val aliceNullColor = RgbColor(233, 199, 220)
+
+    private fun aliceColor(name: String, age: Int?): RgbColor? =
+        when (name to age) {
+            "Alice" to 15 -> alice15Color
+            "Alice" to null -> aliceNullColor
+            else -> null
+        }
+
+    @Test
+    fun valueCountsDf() {
+        // SampleStart
+        df
+            // SampleEnd
+            .format().perRowCol { row, _ ->
+                aliceColor(row.name, row.age)?.let {
+                    background(it) and textColor(black)
+                }
+            }
+            .saveDfHtmlSample()
+    }
+
+    @Test
+    fun valueCounts() {
+        // SampleStart
+        df.valueCounts()
+            // SampleEnd
+            .format().perRowCol { row, _ ->
+                aliceColor(row.name, row.age)?.let {
+                    background(it) and textColor(black)
+                }
+            }
+            .saveDfHtmlSample()
+    }
+
+    @Test
+    fun valueCountsWithNA() {
+        // SampleStart
+        df.valueCounts(dropNA = false)
+            // SampleEnd
+            .format().perRowCol { row, _ ->
+                aliceColor(row.name, row.age)?.let {
+                    background(it) and textColor(black)
+                }
+            }
+            .saveDfHtmlSample()
+    }
+
+    @Test
+    fun valueCountsSelector_properties() {
+        // SampleStart
+        df.valueCounts(dropNA = false) { name }
+            // SampleEnd
+            .defaultHeaderFormatting { name }
+            .saveDfHtmlSample()
+    }
+
+    @Test
+    fun valueCountsSelector_strings() {
+        // SampleStart
+        df.valueCounts("name", dropNA = false)
+        // SampleEnd
+    }
+
+    @Test
+    fun valueCountsColumn() {
+        // SampleStart
+        df.age.valueCounts()
+            // SampleEnd
+            .defaultHeaderFormatting { "age"<Int>() }
+            .saveDfHtmlSample()
+    }
+}