Merge pull request '0.7.0' (!79) from dev into master

Reviewed-on: #79

.github/workflows/build.yml

@@ -0,0 +1,41 @@
+name: Gradle build
+
+on:
+  push:
+    branches: [ dev, master ]
+  pull_request:
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ macOS-latest, windows-latest ]
+    runs-on: ${{matrix.os}}
+    timeout-minutes: 40
+    steps:
+      - name: Checkout the repo
+        uses: actions/checkout@v2
+      - name: Set up JDK 11
+        uses: DeLaGuardo/setup-graalvm@4.0
+        with:
+          graalvm: 21.2.0
+          java: java11
+          arch: amd64
+      - name: Cache gradle
+        uses: actions/cache@v2
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('*.gradle.kts') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      - name: Cache konan
+        uses: actions/cache@v2
+        with:
+          path: ~/.konan
+          key: ${{ runner.os }}-gradle-${{ hashFiles('*.gradle.kts') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      - name: Build
+        run: ./gradlew build --build-cache --no-daemon --stacktrace

.github/workflows/pages.yml

@@ -0,0 +1,31 @@
+name: Dokka publication
+
+on:
+  workflow_dispatch:
+  release:
+    types: [ created ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 40
+    steps:
+      - uses: actions/checkout@v3.0.0
+      - uses: actions/setup-java@v3.0.0
+        with:
+          java-version: 11
+          distribution: liberica
+      - name: Cache konan
+        uses: actions/cache@v3.0.1
+        with:
+          path: ~/.konan
+          key: ${{ runner.os }}-gradle-${{ hashFiles('*.gradle.kts') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      - uses: gradle/gradle-build-action@v2.4.2
+        with:
+          arguments: dokkaHtmlMultiModule --no-parallel
+      - uses: JamesIves/github-pages-deploy-action@v4.3.0
+        with:
+          branch: gh-pages
+          folder: build/dokka/htmlMultiModule

.github/workflows/publish.yml

@@ -0,0 +1,50 @@
+name: Gradle publish
+
+on:
+  workflow_dispatch:
+  release:
+    types: [ created ]
+
+jobs:
+  publish:
+    environment:
+      name: publish
+    strategy:
+      matrix:
+        os: [ macOS-latest, windows-latest ]
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v3.0.0
+      - uses: actions/setup-java@v3.10.0
+        with:
+          java-version: 11
+          distribution: liberica
+      - name: Cache konan
+        uses: actions/cache@v3.0.1
+        with:
+          path: ~/.konan
+          key: ${{ runner.os }}-gradle-${{ hashFiles('*.gradle.kts') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      - name: Publish Windows Artifacts
+        if: matrix.os == 'windows-latest'
+        uses: gradle/gradle-build-action@v2.4.2
+        with:
+          arguments: |
+            publishAllPublicationsToSpaceRepository
+            -Ppublishing.targets=all
+            -Ppublishing.space.user=${{ secrets.SPACE_APP_ID }}
+            -Ppublishing.space.token=${{ secrets.SPACE_APP_SECRET }}
+      - name: Publish Mac Artifacts
+        if: matrix.os == 'macOS-latest'
+        uses: gradle/gradle-build-action@v2.4.2
+        with:
+          arguments: |
+            publishMacosX64PublicationToSpaceRepository
+            publishMacosArm64PublicationToSpaceRepository
+            publishIosX64PublicationToSpaceRepository
+            publishIosArm64PublicationToSpaceRepository
+            publishIosSimulatorArm64PublicationToSpaceRepository
+            -Ppublishing.targets=all
+            -Ppublishing.space.user=${{ secrets.SPACE_APP_ID }}
+            -Ppublishing.space.token=${{ secrets.SPACE_APP_SECRET }}

.gitignore

@@ -6,5 +6,4 @@ out/
 build/
 
 
-!gradle-wrapper.jar
-gradle.properties
+!gradle-wrapper.jar

CHANGELOG.md

@@ -0,0 +1,217 @@
+# Changelog
+
+## Unreleased
+
+### Added
+
+### Changed
+
+### Deprecated
+
+### Removed
+
+### Fixed
+
+### Security
+
+## 0.7.0 - 2023-11-26
+
+### Added
+
+- Obligatory `type: KType` and `descriptor` property for `MetaConverters`
+- Added separate `Meta`, `SealedMeta` and `ObservableMutableMeta` builders.
+
+### Changed
+
+- Meta converter `metaToObject` returns a non-nullable type. Additional method `metaToObjectOrNull` for nullable return.
+- Kotlin 1.9.20.
+- Migrated from ktor-io to kotlinx-io.
+- `MutableMeta` builder now returns a simplified version of meta that does not hold listeners.
+- More concise names for read/write methods in IO.
+- Remove unnecessary confusion with `get`/`getMeta` by removing `getMeta` from the interface.
+
+### Deprecated
+
+- `String.parseValue` is replaced with `Value.parse`
+
+### Fixed
+
+- Memory leak in SealedMeta builder
+
+## 0.6.2 - 2023-07-29
+
+### Changed
+
+- Meta to Json serializer now serializes a single item with index as an array. It is important for plotly integration.
+- Meta to Json serializes Meta without children a value as literal or array instead of an object with `@value` field.
+
+## 0.6.1 - 2023-03-31
+
+### Added
+
+- File cache for workspace
+- Smart task metadata transformation for workspace
+- Add `readOnly` property to descriptors
+- Add `specOrNull` delegate to meta and Scheme
+- Suspended read methods to the `Binary`
+- Synchronously accessed `meta` to all `DataSet`s
+- More fine-grained types in Action builders.
+
+### Changed
+
+- `Name::replaceLast` API
+- `PluginFactory` no longer requires plugin class
+- Collection<Named> toMap -> associateByName
+- Simplified `DFTL` envelope format. Closing symbols are unnecessary. Properties are discontinued.
+- Meta `get` method allows nullable receiver
+- `withDefault` functions do not add new keys to meta children and are consistent.
+- `dataforge.meta.values` package is merged into `dataforge.meta` for better star imports
+- Kotlin 1.8.20
+- `Factory` is now `fun interface` and uses `build` instead of `invoke`. `invoke moved to an extension.
+- KTor 2.0
+- DataTree `items` call is blocking.
+- DataSet `getData` is no longer suspended and renamed to `get`
+- DataSet operates with sequences of data instead of flows
+- PartialEnvelope uses `Int` instead `UInt`.
+- `ActiveDataSet` renamed to `DataSource`
+- `selectOne`->`getByType`
+- Data traversal in `DataSet` is done via iterator
+- Remove all unnecessary properties for `IOFormat`
+- Separate interfaces for `IOReader` and `IOWriter`
+
+### Deprecated
+
+- Context.fetch -> Context.request
+
+### Fixed
+
+- `readDataDirectory` does not split names with dots
+- Front matter reader does not crash on non-UTF files
+- Meta file name in readMeta from directory
+- Tagless and FrontMatter envelope partial readers fix.
+
+## 0.5.2
+
+### Added
+
+- Yaml plugin
+- Partial fix to #53
+
+### Fixed
+
+- MutableMetaImpl attachment and checks
+- Listeners in observable meta are replaced by lists
+- JS number comparison bug.
+
+## 0.5.0
+
+### Added
+
+- Experimental `listOfSpec` delegate.
+
+### Changed
+
+- **API breaking** Config is deprecated, use `ObservableMeta` instead.
+- **API breaking** Descriptor no has a member property `defaultValue` instead of `defaultItem()` extension. It caches default value state on the first call. It is done because computing default on each call is too expensive.
+- Kotlin 1.5.10
+- Build tools 0.10.0
+- Relaxed type restriction on `MetaConverter`. Now nullables are available.
+- **Huge API-breaking refactoring of Meta**. Meta now can have both value and children. There is only one kind of descriptor now.
+- **API breaking** `String.toName()` is replaced by `Name.parse()`
+- **API breaking** Configurable`config` changed to `meta`
+
+### Removed
+
+- `Config`
+- Public PluginManager mutability
+- Tables and tables-exposed moved to the separate project `tables.kt`
+- BinaryMetaFormat. Use CBOR encoding instead
+
+### Fixed
+
+- Proper json array index treatment.
+- Proper json index for single-value array.
+
+## 0.4.0
+
+### Added
+
+- LogManager plugin
+- dataforge-context API dependency on SLF4j
+- Context `withEnv` and `fetch` methods to manipulate plugins without changing plugins after creation.
+- Split `ItemDescriptor` into builder and read-only part
+
+### Changed
+
+- Kotlin-logging moved from common to JVM and JS. Replaced by console for native.
+- Package changed to `space.kscience`
+- Scheme made observable
+- Global context is a variable (the singleton is hidden and will be deprecated in future)
+- Kotlin 1.5
+- Added blank builders for children context.
+- Refactor loggers
+
+### Deprecated
+
+- Direct use of PluginManager
+
+### Removed
+
+- Common dependency on Kotlin-logging
+- Kotlinx-io fork dependency. Replaced by Ktor-io.
+
+### Fixed
+
+- Scheme properties properly handle children property change.
+
+## 0.3.0
+
+### Added
+
+- Yaml meta format based on yaml.kt
+- `Path` builders
+- Special ValueType for lists
+- `copy` method to descriptors
+- Multiplatform yaml meta
+
+### Changed
+
+- `ListValue` and `DoubleArrayValue` implement `Iterable`.
+- Changed the logic of `Value::isList` to check for type instead of size
+- `Meta{}` builder made inline
+- Moved `Envelope` builder to a top level function. Companion invoke is deprecated.
+- Context logging moved to the extension
+- `number` and `string` methods on `Value` moved to extensions (breaking change)
+- \[Major breaking change\] Schemes and configurables us `MutableItemProvider` instead of `Config`
+- \[Major breaking change\] `MetaItem` renamed to `TypedMetaItem` and `MetaItem` is now an alias for `TypedMetaItem<*>`
+- \[Major breaking change\] Moved `NodeItem` and `ValueItem` to a top level
+- Plugins are removed from Context constructor and added lazily in ContextBuilder
+- \[Major breaking change\] Full refactor of DataTree/DataSource
+- \[Major Breaking change\] Replace KClass with KType in data. Remove direct access to constructors with types.
+
+## 0.2.0
+
+### Changed
+
+- Context content resolution refactor
+- Kotlin 1.4.10 (build tools 0.6.0)
+- Empty query in Name is null instead of ""
+- Provider provides an empty map instead of error by default
+- Hidden delegates hierarchy in favor of stdlib properties
+- Removed io depdendency from `dataforge-output`. Replaced Output by Appendable.
+- Configurable is no longer MutableItemProvider. All functionality moved to Scheme.
+
+### Deprecated
+
+- Context activation API
+- TextRenderer
+
+### Removed
+
+- Functional server prototype
+- `dataforge-output` module
+
+### Fixed
+
+- Global context CoroutineScope resolution
+- Library mode compliance

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,38 @@
+[![JetBrains Research](https://jb.gg/badges/research.svg)](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub)
+[![DOI](https://zenodo.org/badge/148831678.svg)](https://zenodo.org/badge/latestdoi/148831678)
+
+![Gradle build](https://github.com/mipt-npm/dataforge-core/workflows/Gradle%20build/badge.svg)
+
+
+### [dataforge-context](dataforge-context)
+> Context and provider definitions
+>
+> **Maturity**: DEVELOPMENT
+
+### [dataforge-data](dataforge-data)
+>
+> **Maturity**: EXPERIMENTAL
+
+### [dataforge-io](dataforge-io)
+> IO module
+>
+> **Maturity**: EXPERIMENTAL
+
+### [dataforge-meta](dataforge-meta)
+> Meta definition and basic operations on meta
+>
+> **Maturity**: DEVELOPMENT
+
+### [dataforge-scripting](dataforge-scripting)
+>
+> **Maturity**: PROTOTYPE
+
+### [dataforge-workspace](dataforge-workspace)
+>
+> **Maturity**: EXPERIMENTAL
+
+### [dataforge-io/dataforge-io-yaml](dataforge-io/dataforge-io-yaml)
+> YAML meta converters and Front Matter envelope format
+>
+> **Maturity**: PROTOTYPE
+

build.gradle.kts

@@ -1,18 +1,39 @@
-val dataforgeVersion by extra("0.1.2")
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import space.kscience.gradle.useApache2Licence
+import space.kscience.gradle.useSPCTeam
+
+plugins {
+    id("space.kscience.gradle.project")
+}
 
 allprojects {
-    repositories {
-        jcenter()
-        maven("https://kotlin.bintray.com/kotlinx")
-    }
-
-    group = "hep.dataforge"
-    version = dataforgeVersion
+    group = "space.kscience"
+    version = "0.7.0"
 }
 
 subprojects {
-    if (name.startsWith("dataforge")) {
-        apply(plugin = "npm-bintray")
-        apply(plugin = "npm-artifactory")
-    } 
+    apply(plugin = "maven-publish")
+
+    tasks.withType<KotlinCompile> {
+        kotlinOptions {
+            freeCompilerArgs = freeCompilerArgs + "-Xcontext-receivers"
+        }
+    }
+}
+
+readme {
+    readmeTemplate = file("docs/templates/README-TEMPLATE.md")
+}
+
+ksciencePublish {
+    pom("https://github.com/SciProgCentre/kmath") {
+        useApache2Licence()
+        useSPCTeam()
+    }
+    repository("spc","https://maven.sciprog.center/kscience")
+    sonatype()
+}
+
+apiValidation {
+    nonPublicMarkers.add("space.kscience.dataforge.misc.DFExperimental")
 }

buildSrc/build.gradle.kts

@@ -1,20 +0,0 @@
-plugins {
-    `kotlin-dsl`
-}
-
-repositories {
-    gradlePluginPortal()
-    jcenter()
-}
-
-val kotlinVersion = "1.3.31"
-
-// Add plugins used in buildSrc as dependencies, also we should specify version only here
-dependencies {
-    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
-    implementation("org.jfrog.buildinfo:build-info-extractor-gradle:4.9.5")
-    implementation("com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4")
-    implementation("org.jetbrains.dokka:dokka-gradle-plugin:0.9.18")
-    implementation("com.moowork.gradle:gradle-node-plugin:1.3.1")
-    implementation("org.openjfx:javafx-plugin:0.0.7")
-}

buildSrc/src/main/kotlin/Versions.kt

@@ -1,9 +0,0 @@
-// Instead of defining runtime properties and use them dynamically
-// define version in buildSrc and have autocompletion and compile-time check
-// Also dependencies itself can be moved here
-object Versions {
-    val ioVersion = "0.1.8"
-    val coroutinesVersion = "1.2.1"
-    val atomicfuVersion = "0.12.6"
-    val serializationVersion = "0.11.0"
-}

buildSrc/src/main/kotlin/dokka-publish.gradle.kts

@@ -1,59 +0,0 @@
-import org.jetbrains.dokka.gradle.DokkaTask
-
-plugins {
-    kotlin("multiplatform")
-    id("org.jetbrains.dokka")
-    `maven-publish`
-}
-
-kotlin {
-
-    val dokka by tasks.getting(DokkaTask::class) {
-        outputFormat = "html"
-        outputDirectory = "$buildDir/javadoc"
-        jdkVersion = 8
-
-        kotlinTasks {
-            // dokka fails to retrieve sources from MPP-tasks so we only define the jvm task
-            listOf(tasks.getByPath("compileKotlinJvm"))
-        }
-        sourceRoot {
-            // assuming only single source dir
-            path = sourceSets["commonMain"].kotlin.srcDirs.first().toString()
-            platforms = listOf("Common")
-        }
-        // although the JVM sources are now taken from the task,
-        // we still define the jvm source root to get the JVM marker in the generated html
-        sourceRoot {
-            // assuming only single source dir
-            path = sourceSets["jvmMain"].kotlin.srcDirs.first().toString()
-            platforms = listOf("JVM")
-        }
-    }
-
-    val javadocJar by tasks.registering(Jar::class) {
-        dependsOn(dokka)
-        archiveClassifier.set("javadoc")
-        from("$buildDir/javadoc")
-    }
-
-    publishing {
-
-        //        publications.filterIsInstance<MavenPublication>().forEach { publication ->
-//            if (publication.name == "kotlinMultiplatform") {
-//                // for our root metadata publication, set artifactId with a package and project name
-//                publication.artifactId = project.name
-//            } else {
-//                // for targets, set artifactId with a package, project name and target name (e.g. iosX64)
-//                publication.artifactId = "${project.name}-${publication.name}"
-//            }
-//        }
-
-        targets.all {
-            val publication = publications.findByName(name) as MavenPublication
-
-            // Patch publications with fake javadoc
-            publication.artifact(javadocJar.get())
-        }
-    }
-}

buildSrc/src/main/kotlin/js-test.gradle.kts

@@ -1,44 +0,0 @@
-import com.moowork.gradle.node.npm.NpmTask
-import com.moowork.gradle.node.task.NodeTask
-import org.gradle.kotlin.dsl.*
-import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
-
-plugins {
-    id("com.moowork.node")
-    kotlin("multiplatform")
-}
-
-node {
-    nodeModulesDir = file("$buildDir/node_modules")
-}
-
-val compileKotlinJs by tasks.getting(Kotlin2JsCompile::class)
-val compileTestKotlinJs by tasks.getting(Kotlin2JsCompile::class)
-
-val populateNodeModules by tasks.registering(Copy::class) {
-    dependsOn(compileKotlinJs)
-    from(compileKotlinJs.destinationDir)
-
-    kotlin.js().compilations["test"].runtimeDependencyFiles.forEach {
-        if (it.exists() && !it.isDirectory) {
-            from(zipTree(it.absolutePath).matching { include("*.js") })
-        }
-    }
-
-    into("$buildDir/node_modules")
-}
-
-val installMocha by tasks.registering(NpmTask::class) {
-    setWorkingDir(buildDir)
-    setArgs(listOf("install", "mocha"))
-}
-
-val runMocha by tasks.registering(NodeTask::class) {
-    dependsOn(compileTestKotlinJs, populateNodeModules, installMocha)
-    setScript(file("$buildDir/node_modules/mocha/bin/mocha"))
-    setArgs(listOf(compileTestKotlinJs.outputFile))
-}
-
-tasks["jsTest"].dependsOn(runMocha)
-
-

buildSrc/src/main/kotlin/npm-artifactory.gradle.kts

@@ -1,38 +0,0 @@
-import groovy.lang.GroovyObject
-import org.jfrog.gradle.plugin.artifactory.dsl.PublisherConfig
-import org.jfrog.gradle.plugin.artifactory.dsl.ResolverConfig
-
-plugins {
-    id("com.jfrog.artifactory")
-}
-
-artifactory {
-    val artifactoryUser: String? by project
-    val artifactoryPassword: String? by project
-    val artifactoryContextUrl = "http://npm.mipt.ru:8081/artifactory"
-
-    setContextUrl(artifactoryContextUrl)//The base Artifactory URL if not overridden by the publisher/resolver
-    publish(delegateClosureOf<PublisherConfig> {
-        repository(delegateClosureOf<GroovyObject> {
-            setProperty("repoKey", "gradle-dev-local")
-            setProperty("username", artifactoryUser)
-            setProperty("password", artifactoryPassword)
-        })
-
-        defaults(delegateClosureOf<GroovyObject>{
-            invokeMethod("publications", arrayOf("jvm", "js", "kotlinMultiplatform", "metadata"))
-            //TODO: This property is not available for ArtifactoryTask
-            //setProperty("publishBuildInfo", false)
-            setProperty("publishArtifacts", true)
-            setProperty("publishPom", true)
-            setProperty("publishIvy", false)
-        })
-    })
-    resolve(delegateClosureOf<ResolverConfig> {
-        repository(delegateClosureOf<GroovyObject> {
-            setProperty("repoKey", "gradle-dev")
-            setProperty("username", artifactoryUser)
-            setProperty("password", artifactoryPassword)
-        })
-    })
-}

buildSrc/src/main/kotlin/npm-bintray.gradle.kts

@@ -1,97 +0,0 @@
-@file:Suppress("UnstableApiUsage")
-
-import com.jfrog.bintray.gradle.BintrayExtension.PackageConfig
-import com.jfrog.bintray.gradle.BintrayExtension.VersionConfig
-
-// Old bintray.gradle script converted to real Gradle plugin (precompiled script plugin)
-// It now has own dependencies and support type safe accessors
-// Syntax is pretty close to what we had in Groovy
-// (excluding Property.set and bintray dynamic configs)
-
-plugins {
-    id("com.jfrog.bintray")
-    `maven-publish`
-}
-
-val vcs = "https://github.com/mipt-npm/kmath"
-
-// Configure publishing
-publishing {
-    repositories {
-        maven("https://bintray.com/mipt-npm/scientifik")
-    }
-
-    // Process each publication we have in this project
-    publications.filterIsInstance<MavenPublication>().forEach { publication ->
-
-        // use type safe pom config GSL insterad of old dynamic
-        publication.pom {
-            name.set(project.name)
-            description.set(project.description)
-            url.set(vcs)
-
-            licenses {
-                license {
-                    name.set("The Apache Software License, Version 2.0")
-                    url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
-                    distribution.set("repo")
-                }
-            }
-            developers {
-                developer {
-                    id.set("MIPT-NPM")
-                    name.set("MIPT nuclear physics methods laboratory")
-                    organization.set("MIPT")
-                    organizationUrl.set("http://npm.mipt.ru")
-                }
-
-            }
-            scm {
-                url.set(vcs)
-            }
-        }
-
-    }
-}
-
-bintray {
-    // delegates for runtime properties
-    val bintrayUser: String? by project
-    val bintrayApiKey: String? by project
-    user = bintrayUser ?: System.getenv("BINTRAY_USER")
-    key = bintrayApiKey ?: System.getenv("BINTRAY_API_KEY")
-    publish = true
-    override = true // for multi-platform Kotlin/Native publishing
-
-    // We have to use delegateClosureOf because bintray supports only dynamic groovy syntax
-    // this is a problem of this plugin
-    pkg(delegateClosureOf<PackageConfig> {
-        userOrg = "mipt-npm"
-        repo = "scientifik"
-        name = "scientifik.kmath"
-        issueTrackerUrl = "https://github.com/mipt-npm/kmath/issues"
-        setLicenses("Apache-2.0")
-        vcsUrl = vcs
-        version(delegateClosureOf<VersionConfig> {
-            name = project.version.toString()
-            vcsTag = project.version.toString()
-            released = java.util.Date().toString()
-        })
-    })
-
-    tasks {
-        bintrayUpload {
-            dependsOn(publishToMavenLocal)
-            doFirst {
-                setPublications(project.publishing.publications
-                    .filterIsInstance<MavenPublication>()
-                    .filter { !it.name.contains("-test") && it.name != "kotlinMultiplatform" }
-                    .map {
-                        println("""Uploading artifact "${it.groupId}:${it.artifactId}:${it.version}" from publication "${it.name}""")
-                        it.name //https://github.com/bintray/gradle-bintray-plugin/issues/256
-                    })
-            }
-        }
-
-    }
-}

buildSrc/src/main/kotlin/npm-multiplatform.gradle.kts

@@ -1,86 +0,0 @@
-import org.gradle.kotlin.dsl.*
-
-plugins {
-    kotlin("multiplatform")
-    `maven-publish`
-}
-
-
-kotlin {
-    jvm {
-        compilations.all {
-            kotlinOptions {
-                jvmTarget = "1.8"
-            }
-        }
-    }
-
-    js {
-        compilations.all {
-            kotlinOptions {
-                metaInfo = true
-                sourceMap = true
-                sourceMapEmbedSources = "always"
-                moduleKind = "commonjs"
-            }
-        }
-
-        compilations.named("main") {
-            kotlinOptions {
-                main = "call"
-            }
-        }
-    }
-
-    sourceSets {
-        val commonMain by getting {
-            dependencies {
-                api(kotlin("stdlib"))
-            }
-        }
-        val commonTest by getting {
-            dependencies {
-                implementation(kotlin("test-common"))
-                implementation(kotlin("test-annotations-common"))
-            }
-        }
-        val jvmMain by getting {
-            dependencies {
-                api(kotlin("stdlib-jdk8"))
-            }
-        }
-        val jvmTest by getting {
-            dependencies {
-                implementation(kotlin("test"))
-                implementation(kotlin("test-junit"))
-            }
-        }
-        val jsMain by getting {
-            dependencies {
-                api(kotlin("stdlib-js"))
-            }
-        }
-        val jsTest by getting {
-            dependencies {
-                implementation(kotlin("test-js"))
-            }
-        }
-    }
-
-    targets.all {
-        sourceSets.all {
-            languageSettings.progressiveMode = true
-            languageSettings.enableLanguageFeature("InlineClasses")
-        }
-    }
-
-    apply(plugin = "dokka-publish")
-
-    // Apply JS test configuration
-    val runJsTests by ext(false)
-
-    if (runJsTests) {
-        apply(plugin = "js-test")
-    }
-
-}

dataforge-context/README.md

@@ -0,0 +1,23 @@
+# Module dataforge-context
+
+Context and provider definitions
+
+## Usage
+
+## Artifact:
+
+The Maven coordinates of this project are `space.kscience:dataforge-context:0.7.0`.
+
+**Gradle Kotlin DSL:**
+```kotlin
+repositories {
+    maven("https://repo.kotlin.link")
+    //uncomment to access development builds
+    //maven("https://maven.pkg.jetbrains.space/spc/p/sci/dev")
+    mavenCentral()
+}
+
+dependencies {
+    implementation("space.kscience:dataforge-context:0.7.0")
+}
+```

dataforge-context/api/dataforge-context.api

@@ -0,0 +1,327 @@
+public abstract class space/kscience/dataforge/context/AbstractPlugin : space/kscience/dataforge/context/Plugin {
+	public fun <init> ()V
+	public fun <init> (Lspace/kscience/dataforge/meta/Meta;)V
+	public synthetic fun <init> (Lspace/kscience/dataforge/meta/Meta;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun attach (Lspace/kscience/dataforge/context/Context;)V
+	public fun dependsOn ()Ljava/util/Map;
+	public fun detach ()V
+	public fun getContext ()Lspace/kscience/dataforge/context/Context;
+	public fun getMeta ()Lspace/kscience/dataforge/meta/Meta;
+	public fun isAttached ()Z
+	protected final fun require (Lspace/kscience/dataforge/context/PluginFactory;Lkotlin/reflect/KClass;Lspace/kscience/dataforge/meta/Meta;)Lkotlin/properties/ReadOnlyProperty;
+	public static synthetic fun require$default (Lspace/kscience/dataforge/context/AbstractPlugin;Lspace/kscience/dataforge/context/PluginFactory;Lkotlin/reflect/KClass;Lspace/kscience/dataforge/meta/Meta;ILjava/lang/Object;)Lkotlin/properties/ReadOnlyProperty;
+}
+
+public final class space/kscience/dataforge/context/AbstractPluginKt {
+	public static final fun associateByName (Ljava/util/Collection;)Ljava/util/Map;
+}
+
+public final class space/kscience/dataforge/context/ClassLoaderPlugin : space/kscience/dataforge/context/AbstractPlugin {
+	public static final field Companion Lspace/kscience/dataforge/context/ClassLoaderPlugin$Companion;
+	public fun <init> (Ljava/lang/ClassLoader;)V
+	public fun getTag ()Lspace/kscience/dataforge/context/PluginTag;
+	public final fun services (Lkotlin/reflect/KClass;)Lkotlin/sequences/Sequence;
+}
+
+public final class space/kscience/dataforge/context/ClassLoaderPlugin$Companion {
+	public final fun getDEFAULT ()Lspace/kscience/dataforge/context/ClassLoaderPlugin;
+}
+
+public final class space/kscience/dataforge/context/ClassLoaderPluginKt {
+	public static final fun getClassLoaderPlugin (Lspace/kscience/dataforge/context/Context;)Lspace/kscience/dataforge/context/ClassLoaderPlugin;
+}
+
+public class space/kscience/dataforge/context/Context : kotlinx/coroutines/CoroutineScope, space/kscience/dataforge/meta/MetaRepr, space/kscience/dataforge/misc/Named, space/kscience/dataforge/provider/Provider {
+	public static final field Companion Lspace/kscience/dataforge/context/Context$Companion;
+	public static final field PROPERTY_TARGET Ljava/lang/String;
+	public final fun buildContext (Lspace/kscience/dataforge/names/Name;Lkotlin/jvm/functions/Function1;)Lspace/kscience/dataforge/context/Context;
+	public static synthetic fun buildContext$default (Lspace/kscience/dataforge/context/Context;Lspace/kscience/dataforge/names/Name;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lspace/kscience/dataforge/context/Context;
+	public fun close ()V
+	public fun content (Ljava/lang/String;)Ljava/util/Map;
+	public final fun content (Ljava/lang/String;Z)Ljava/util/Map;
+	public fun getCoroutineContext ()Lkotlin/coroutines/CoroutineContext;
+	public fun getDefaultTarget ()Ljava/lang/String;
+	public final fun getName ()Lspace/kscience/dataforge/names/Name;
+	public final fun getParent ()Lspace/kscience/dataforge/context/Context;
+	public final fun getPlugins ()Lspace/kscience/dataforge/context/PluginManager;
+	public final fun getProperties ()Lspace/kscience/dataforge/meta/Laminate;
+	public fun toMeta ()Lspace/kscience/dataforge/meta/Meta;
+}
+
+public final class space/kscience/dataforge/context/Context$Companion {
+}
+
+public abstract interface class space/kscience/dataforge/context/ContextAware {
+	public abstract fun getContext ()Lspace/kscience/dataforge/context/Context;
+}
+
+public final class space/kscience/dataforge/context/ContextBuilder {
+	public final fun build ()Lspace/kscience/dataforge/context/Context;
+	public final fun getName ()Lspace/kscience/dataforge/names/Name;
+	public final fun plugin (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/functions/Function1;)V
+	public final fun plugin (Lspace/kscience/dataforge/context/Plugin;)V
+	public final fun plugin (Lspace/kscience/dataforge/context/PluginFactory;Lkotlin/jvm/functions/Function1;)V
+	public final fun plugin (Lspace/kscience/dataforge/context/PluginFactory;Lspace/kscience/dataforge/meta/Meta;)V
+	public final fun plugin (Lspace/kscience/dataforge/context/PluginTag;Lkotlin/jvm/functions/Function1;)V
+	public static synthetic fun plugin$default (Lspace/kscience/dataforge/context/ContextBuilder;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V
+	public static synthetic fun plugin$default (Lspace/kscience/dataforge/context/ContextBuilder;Lspace/kscience/dataforge/context/PluginFactory;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V
+	public static synthetic fun plugin$default (Lspace/kscience/dataforge/context/ContextBuilder;Lspace/kscience/dataforge/context/PluginTag;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V
+	public final fun properties (Lkotlin/jvm/functions/Function1;)V
+}
+
+public final class space/kscience/dataforge/context/ContextBuilderKt {
+}
+
+public final class space/kscience/dataforge/context/DefaultLogManager : space/kscience/dataforge/context/AbstractPlugin, space/kscience/dataforge/context/LogManager {
+	public static final field Companion Lspace/kscience/dataforge/context/DefaultLogManager$Companion;
+	public fun <init> ()V
+	public fun getDefaultLogger ()Lspace/kscience/dataforge/context/Logger;
+	public fun getTag ()Lspace/kscience/dataforge/context/PluginTag;
+	public fun logger (Lspace/kscience/dataforge/names/Name;)Lspace/kscience/dataforge/context/Logger;
+}
+
+public final class space/kscience/dataforge/context/DefaultLogManager$Companion : space/kscience/dataforge/context/PluginFactory {
+	public synthetic fun build (Lspace/kscience/dataforge/context/Context;Lspace/kscience/dataforge/meta/Meta;)Ljava/lang/Object;
+	public fun build (Lspace/kscience/dataforge/context/Context;Lspace/kscience/dataforge/meta/Meta;)Lspace/kscience/dataforge/context/DefaultLogManager;
+	public fun getTag ()Lspace/kscience/dataforge/context/PluginTag;
+}
+
+public abstract interface class space/kscience/dataforge/context/Factory {
+	public abstract fun build (Lspace/kscience/dataforge/context/Context;Lspace/kscience/dataforge/meta/Meta;)Ljava/lang/Object;
+}
+
+public final class space/kscience/dataforge/context/FactoryKt {
+	public static final fun invoke (Lspace/kscience/dataforge/context/Factory;Lspace/kscience/dataforge/meta/Meta;Lspace/kscience/dataforge/context/Context;)Ljava/lang/Object;
+	public static synthetic fun invoke$default (Lspace/kscience/dataforge/context/Factory;Lspace/kscience/dataforge/meta/Meta;Lspace/kscience/dataforge/context/Context;ILjava/lang/Object;)Ljava/lang/Object;
+}
+
+public final class space/kscience/dataforge/context/GlobalKt {
+	public static final fun Context (Ljava/lang/String;Lkotlin/jvm/functions/Function1;)Lspace/kscience/dataforge/context/Context;
+	public static synthetic fun Context$default (Ljava/lang/String;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lspace/kscience/dataforge/context/Context;
+	public static final fun getGlobal ()Lspace/kscience/dataforge/context/Context;
+}
+
+public abstract interface class space/kscience/dataforge/context/LogManager : space/kscience/dataforge/context/Logger, space/kscience/dataforge/context/Plugin {
+	public static final field Companion Lspace/kscience/dataforge/context/LogManager$Companion;
+	public static final field DEBUG Ljava/lang/String;
+	public static final field ERROR Ljava/lang/String;
+	public static final field INFO Ljava/lang/String;
+	public static final field TRACE Ljava/lang/String;
+	public static final field WARNING Ljava/lang/String;
+	public abstract fun getDefaultLogger ()Lspace/kscience/dataforge/context/Logger;
+	public fun log (Ljava/lang/String;Lkotlin/jvm/functions/Function0;)V
+	public fun log (Lspace/kscience/dataforge/names/Name;Ljava/lang/String;Lkotlin/jvm/functions/Function0;)V
+	public abstract fun logger (Lspace/kscience/dataforge/names/Name;)Lspace/kscience/dataforge/context/Logger;
+}
+
+public final class space/kscience/dataforge/context/LogManager$Companion {
+	public static final field DEBUG Ljava/lang/String;
+	public static final field ERROR Ljava/lang/String;
+	public static final field INFO Ljava/lang/String;
+	public static final field TRACE Ljava/lang/String;
+	public static final field WARNING Ljava/lang/String;
+}
+
+public final class space/kscience/dataforge/context/LogManagerKt {
+	public static final fun debug (Lspace/kscience/dataforge/context/Logger;Lkotlin/jvm/functions/Function0;)V
+	public static final fun error (Lspace/kscience/dataforge/context/Logger;Ljava/lang/Throwable;Lkotlin/jvm/functions/Function0;)V
+	public static final fun error (Lspace/kscience/dataforge/context/Logger;Lkotlin/jvm/functions/Function0;)V
+	public static final fun getLogger (Lspace/kscience/dataforge/context/Context;)Lspace/kscience/dataforge/context/LogManager;
+	public static final fun getLogger (Lspace/kscience/dataforge/context/ContextAware;)Lspace/kscience/dataforge/context/Logger;
+	public static final fun info (Lspace/kscience/dataforge/context/Logger;Lkotlin/jvm/functions/Function0;)V
+	public static final fun trace (Lspace/kscience/dataforge/context/Logger;Lkotlin/jvm/functions/Function0;)V
+	public static final fun warn (Lspace/kscience/dataforge/context/Logger;Lkotlin/jvm/functions/Function0;)V
+}
+
+public abstract interface class space/kscience/dataforge/context/Logger {
+	public abstract fun log (Ljava/lang/String;Lkotlin/jvm/functions/Function0;)V
+}
+
+public abstract interface class space/kscience/dataforge/context/Plugin : space/kscience/dataforge/context/ContextAware, space/kscience/dataforge/meta/MetaRepr, space/kscience/dataforge/misc/Named, space/kscience/dataforge/provider/Provider {
+	public static final field Companion Lspace/kscience/dataforge/context/Plugin$Companion;
+	public static final field TARGET Ljava/lang/String;
+	public abstract fun attach (Lspace/kscience/dataforge/context/Context;)V
+	public abstract fun dependsOn ()Ljava/util/Map;
+	public abstract fun detach ()V
+	public abstract fun getMeta ()Lspace/kscience/dataforge/meta/Meta;
+	public fun getName ()Lspace/kscience/dataforge/names/Name;
+	public abstract fun getTag ()Lspace/kscience/dataforge/context/PluginTag;
+	public abstract fun isAttached ()Z
+	public fun toMeta ()Lspace/kscience/dataforge/meta/Meta;
+}
+
+public final class space/kscience/dataforge/context/Plugin$Companion {
+	public static final field TARGET Ljava/lang/String;
+}
+
+public final class space/kscience/dataforge/context/PluginBuilder {
+	public fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun build ()Lspace/kscience/dataforge/context/PluginFactory;
+	public final fun getTag ()Lspace/kscience/dataforge/context/PluginTag;
+	public final fun provides (Ljava/lang/String;Ljava/util/Map;)V
+	public final fun provides (Ljava/lang/String;[Lspace/kscience/dataforge/misc/Named;)V
+	public final fun requires (Lspace/kscience/dataforge/context/PluginFactory;Lspace/kscience/dataforge/meta/Meta;)V
+	public static synthetic fun requires$default (Lspace/kscience/dataforge/context/PluginBuilder;Lspace/kscience/dataforge/context/PluginFactory;Lspace/kscience/dataforge/meta/Meta;ILjava/lang/Object;)V
+}
+
+public final class space/kscience/dataforge/context/PluginBuilderKt {
+	public static final fun PluginFactory (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/functions/Function1;)Lspace/kscience/dataforge/context/PluginFactory;
+	public static synthetic fun PluginFactory$default (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lspace/kscience/dataforge/context/PluginFactory;
+}
+
+public abstract interface class space/kscience/dataforge/context/PluginFactory : space/kscience/dataforge/context/Factory {
+	public static final field Companion Lspace/kscience/dataforge/context/PluginFactory$Companion;
+	public static final field TYPE Ljava/lang/String;
+	public abstract fun getTag ()Lspace/kscience/dataforge/context/PluginTag;
+}
+
+public final class space/kscience/dataforge/context/PluginFactory$Companion {
+	public static final field TYPE Ljava/lang/String;
+}
+
+public final class space/kscience/dataforge/context/PluginManager : java/lang/Iterable, kotlin/jvm/internal/markers/KMappedMarker, space/kscience/dataforge/context/ContextAware {
+	public final fun find (ZLkotlin/jvm/functions/Function1;)Lspace/kscience/dataforge/context/Plugin;
+	public static synthetic fun find$default (Lspace/kscience/dataforge/context/PluginManager;ZLkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lspace/kscience/dataforge/context/Plugin;
+	public final fun get (Lspace/kscience/dataforge/context/PluginTag;Z)Lspace/kscience/dataforge/context/Plugin;
+	public static synthetic fun get$default (Lspace/kscience/dataforge/context/PluginManager;Lspace/kscience/dataforge/context/PluginTag;ZILjava/lang/Object;)Lspace/kscience/dataforge/context/Plugin;
+	public final fun getByType (Lkotlin/reflect/KClass;Lspace/kscience/dataforge/context/PluginTag;Z)Ljava/lang/Object;
+	public static synthetic fun getByType$default (Lspace/kscience/dataforge/context/PluginManager;Lkotlin/reflect/KClass;Lspace/kscience/dataforge/context/PluginTag;ZILjava/lang/Object;)Ljava/lang/Object;
+	public fun getContext ()Lspace/kscience/dataforge/context/Context;
+	public fun iterator ()Ljava/util/Iterator;
+	public final fun list (Z)Ljava/util/Collection;
+}
+
+public final class space/kscience/dataforge/context/PluginTag : space/kscience/dataforge/meta/MetaRepr {
+	public static final field Companion Lspace/kscience/dataforge/context/PluginTag$Companion;
+	public static final field DATAFORGE_GROUP Ljava/lang/String;
+	public fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3 ()Ljava/lang/String;
+	public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lspace/kscience/dataforge/context/PluginTag;
+	public static synthetic fun copy$default (Lspace/kscience/dataforge/context/PluginTag;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lspace/kscience/dataforge/context/PluginTag;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getGroup ()Ljava/lang/String;
+	public final fun getName ()Ljava/lang/String;
+	public final fun getVersion ()Ljava/lang/String;
+	public fun hashCode ()I
+	public final fun matches (Lspace/kscience/dataforge/context/PluginTag;)Z
+	public fun toMeta ()Lspace/kscience/dataforge/meta/Meta;
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class space/kscience/dataforge/context/PluginTag$$serializer : kotlinx/serialization/internal/GeneratedSerializer {
+	public static final field INSTANCE Lspace/kscience/dataforge/context/PluginTag$$serializer;
+	public fun childSerializers ()[Lkotlinx/serialization/KSerializer;
+	public synthetic fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ljava/lang/Object;
+	public fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Lspace/kscience/dataforge/context/PluginTag;
+	public fun getDescriptor ()Lkotlinx/serialization/descriptors/SerialDescriptor;
+	public synthetic fun serialize (Lkotlinx/serialization/encoding/Encoder;Ljava/lang/Object;)V
+	public fun serialize (Lkotlinx/serialization/encoding/Encoder;Lspace/kscience/dataforge/context/PluginTag;)V
+	public fun typeParametersSerializers ()[Lkotlinx/serialization/KSerializer;
+}
+
+public final class space/kscience/dataforge/context/PluginTag$Companion {
+	public final fun fromString (Ljava/lang/String;)Lspace/kscience/dataforge/context/PluginTag;
+	public final fun serializer ()Lkotlinx/serialization/KSerializer;
+}
+
+public final class space/kscience/dataforge/context/ResolveKt {
+	public static final fun gather (Lspace/kscience/dataforge/context/Context;Ljava/lang/String;Lkotlin/reflect/KClass;Z)Ljava/util/Map;
+	public static synthetic fun gather$default (Lspace/kscience/dataforge/context/Context;Ljava/lang/String;Lkotlin/reflect/KClass;ZILjava/lang/Object;)Ljava/util/Map;
+	public static final fun getValues (Lkotlin/sequences/Sequence;)Lkotlin/sequences/Sequence;
+	public static final fun resolve (Lspace/kscience/dataforge/context/Context;Ljava/lang/String;Lspace/kscience/dataforge/names/Name;Lkotlin/reflect/KClass;)Ljava/lang/Object;
+}
+
+public final class space/kscience/dataforge/context/SlfLogManager : space/kscience/dataforge/context/AbstractPlugin, space/kscience/dataforge/context/LogManager {
+	public static final field Companion Lspace/kscience/dataforge/context/SlfLogManager$Companion;
+	public fun <init> ()V
+	public fun getDefaultLogger ()Lspace/kscience/dataforge/context/Logger;
+	public fun getTag ()Lspace/kscience/dataforge/context/PluginTag;
+	public fun logger (Lspace/kscience/dataforge/names/Name;)Lspace/kscience/dataforge/context/Logger;
+}
+
+public final class space/kscience/dataforge/context/SlfLogManager$Companion : space/kscience/dataforge/context/PluginFactory {
+	public synthetic fun build (Lspace/kscience/dataforge/context/Context;Lspace/kscience/dataforge/meta/Meta;)Ljava/lang/Object;
+	public fun build (Lspace/kscience/dataforge/context/Context;Lspace/kscience/dataforge/meta/Meta;)Lspace/kscience/dataforge/context/SlfLogManager;
+	public fun getTag ()Lspace/kscience/dataforge/context/PluginTag;
+}
+
+public final class space/kscience/dataforge/properties/PropertyKt {
+}
+
+public final class space/kscience/dataforge/properties/SchemePropertyKt {
+}
+
+public final class space/kscience/dataforge/provider/DfTypeKt {
+}
+
+public final class space/kscience/dataforge/provider/Path : java/lang/Iterable, kotlin/jvm/internal/markers/KMappedMarker {
+	public static final field Companion Lspace/kscience/dataforge/provider/Path$Companion;
+	public static final field PATH_SEGMENT_SEPARATOR Ljava/lang/String;
+	public static final synthetic fun box-impl (Ljava/util/List;)Lspace/kscience/dataforge/provider/Path;
+	public static fun constructor-impl (Ljava/util/List;)Ljava/util/List;
+	public fun equals (Ljava/lang/Object;)Z
+	public static fun equals-impl (Ljava/util/List;Ljava/lang/Object;)Z
+	public static final fun equals-impl0 (Ljava/util/List;Ljava/util/List;)Z
+	public final fun getTokens ()Ljava/util/List;
+	public fun hashCode ()I
+	public static fun hashCode-impl (Ljava/util/List;)I
+	public fun iterator ()Ljava/util/Iterator;
+	public static fun iterator-impl (Ljava/util/List;)Ljava/util/Iterator;
+	public fun toString ()Ljava/lang/String;
+	public static fun toString-impl (Ljava/util/List;)Ljava/lang/String;
+	public final synthetic fun unbox-impl ()Ljava/util/List;
+}
+
+public final class space/kscience/dataforge/provider/Path$Companion {
+	public final fun parse-X5wN5Vs (Ljava/lang/String;)Ljava/util/List;
+}
+
+public final class space/kscience/dataforge/provider/PathKt {
+	public static final fun Path ([Lkotlin/Pair;)Ljava/util/List;
+	public static final fun Path ([Lspace/kscience/dataforge/names/Name;)Ljava/util/List;
+	public static final fun asPath (Lspace/kscience/dataforge/names/Name;Ljava/lang/String;)Ljava/util/List;
+	public static final fun asPath (Lspace/kscience/dataforge/provider/PathToken;)Ljava/util/List;
+	public static synthetic fun asPath$default (Lspace/kscience/dataforge/names/Name;Ljava/lang/String;ILjava/lang/Object;)Ljava/util/List;
+	public static final fun getHead-LGjlSZY (Ljava/util/List;)Lspace/kscience/dataforge/provider/PathToken;
+	public static final fun getLength-LGjlSZY (Ljava/util/List;)I
+	public static final fun getTail-LGjlSZY (Ljava/util/List;)Ljava/util/List;
+	public static final fun plus-sn2Gq0g (Ljava/util/List;Ljava/util/List;)Ljava/util/List;
+}
+
+public final class space/kscience/dataforge/provider/PathToken {
+	public static final field Companion Lspace/kscience/dataforge/provider/PathToken$Companion;
+	public static final field TARGET_SEPARATOR Ljava/lang/String;
+	public fun <init> (Lspace/kscience/dataforge/names/Name;Ljava/lang/String;)V
+	public synthetic fun <init> (Lspace/kscience/dataforge/names/Name;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Lspace/kscience/dataforge/names/Name;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun copy (Lspace/kscience/dataforge/names/Name;Ljava/lang/String;)Lspace/kscience/dataforge/provider/PathToken;
+	public static synthetic fun copy$default (Lspace/kscience/dataforge/provider/PathToken;Lspace/kscience/dataforge/names/Name;Ljava/lang/String;ILjava/lang/Object;)Lspace/kscience/dataforge/provider/PathToken;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getName ()Lspace/kscience/dataforge/names/Name;
+	public final fun getTarget ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class space/kscience/dataforge/provider/PathToken$Companion {
+	public final fun parse (Ljava/lang/String;Z)Lspace/kscience/dataforge/provider/PathToken;
+	public static synthetic fun parse$default (Lspace/kscience/dataforge/provider/PathToken$Companion;Ljava/lang/String;ZILjava/lang/Object;)Lspace/kscience/dataforge/provider/PathToken;
+}
+
+public abstract interface class space/kscience/dataforge/provider/Provider {
+	public fun content (Ljava/lang/String;)Ljava/util/Map;
+	public fun getDefaultChainTarget ()Ljava/lang/String;
+	public fun getDefaultTarget ()Ljava/lang/String;
+}
+
+public final class space/kscience/dataforge/provider/ProviderKt {
+	public static final fun provide-CSkoCSg (Lspace/kscience/dataforge/provider/Provider;Ljava/util/List;Ljava/lang/String;)Ljava/lang/Object;
+	public static synthetic fun provide-CSkoCSg$default (Lspace/kscience/dataforge/provider/Provider;Ljava/util/List;Ljava/lang/String;ILjava/lang/Object;)Ljava/lang/Object;
+	public static final fun top (Lspace/kscience/dataforge/provider/Provider;Ljava/lang/String;Lkotlin/reflect/KClass;)Ljava/util/Map;
+}
+

dataforge-context/build.gradle.kts

@@ -1,36 +1,24 @@
 plugins {
-    `npm-multiplatform`
+    id("space.kscience.gradle.mpp")
 }
 
 description = "Context and provider definitions"
 
-val coroutinesVersion: String  = Versions.coroutinesVersion
-
-kotlin {
+kscience {
     jvm()
     js()
-
-    sourceSets {
-        val commonMain by getting {
-            dependencies {
-                api(project(":dataforge-meta"))
-                api(kotlin("reflect"))
-                api("io.github.microutils:kotlin-logging-common:1.6.10")
-                api("org.jetbrains.kotlinx:kotlinx-coroutines-core-common:$coroutinesVersion")
-            }
-        }
-        val jvmMain by getting {
-            dependencies {
-                api("io.github.microutils:kotlin-logging:1.6.10")
-                api("ch.qos.logback:logback-classic:1.2.3")
-                api("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion")
-            }
-        }
-        val jsMain by getting {
-            dependencies {
-                api("io.github.microutils:kotlin-logging-js:1.6.10")
-                api("org.jetbrains.kotlinx:kotlinx-coroutines-core-js:$coroutinesVersion")
-            }
-        }
+    native()
+    useCoroutines()
+    useSerialization()
+    dependencies {
+        api(project(":dataforge-meta"))
     }
+    dependencies(jvmMain){
+        api(kotlin("reflect"))
+        api("org.slf4j:slf4j-api:1.7.30")
+    }
+}
+
+readme {
+    maturity = space.kscience.gradle.Maturity.DEVELOPMENT
 }

dataforge-context/src/commonMain/kotlin/hep/dataforge/context/AbstractPlugin.kt

@@ -1,24 +0,0 @@
-package hep.dataforge.context
-
-import hep.dataforge.meta.EmptyMeta
-import hep.dataforge.meta.Meta
-import hep.dataforge.names.Name
-
-abstract class AbstractPlugin(override val meta: Meta = EmptyMeta) : Plugin {
-    private var _context: Context? = null
-
-    override val context: Context
-        get() = _context ?: error("Plugin $tag is not attached")
-
-    override fun attach(context: Context) {
-        this._context = context
-    }
-
-    override fun detach() {
-        this._context = null
-    }
-
-    override fun provideTop(target: String, name: Name): Any? = null
-
-    override fun listNames(target: String): Sequence<Name> = emptySequence()
-}

dataforge-context/src/commonMain/kotlin/hep/dataforge/context/Context.kt

@@ -1,183 +0,0 @@
-package hep.dataforge.context
-
-import hep.dataforge.meta.*
-import hep.dataforge.names.Name
-import hep.dataforge.names.appendLeft
-import hep.dataforge.names.toName
-import hep.dataforge.provider.Provider
-import hep.dataforge.provider.top
-import hep.dataforge.values.Value
-import kotlinx.coroutines.CoroutineScope
-import mu.KLogger
-import mu.KotlinLogging
-import kotlin.coroutines.CoroutineContext
-import kotlin.coroutines.EmptyCoroutineContext
-import kotlin.jvm.JvmName
-
-/**
- * The local environment for anything being done in DataForge framework. Contexts are organized into tree structure with [Global] at the top.
- * Context has [properties] - equivalent for system environment values, but grouped into a tree and inherited from parent context.
- *
- * The main function of the Context is to provide [PluginManager] which stores the loaded plugins and works as a dependency injection point.
- * The normal behaviour of the [PluginManager] is to search for a plugin in parent context if it is not found in a current one. It is possible to have
- * different plugins with the same interface in different contexts in the hierarchy. The usual behaviour is to use nearest one, but it could
- * be overridden by plugin implementation.
- *
- * Since plugins could contain mutable state, context has two states: active and inactive. No changes are allowed to active context.
- * @author Alexander Nozik
- */
-open class Context(final override val name: String, val parent: Context? = Global) : Named, MetaRepr, Provider,
-    CoroutineScope {
-
-    private val config = Config()
-
-    /**
-     * Context properties. Working as substitute for environment variables
-     */
-    val properties: Meta = if (parent == null) {
-        config
-    } else {
-        Laminate(config, parent.properties)
-    }
-
-    /**
-     * Context logger
-     */
-    val logger: KLogger = KotlinLogging.logger(name)
-
-    /**
-     * A [PluginManager] for current context
-     */
-    val plugins: PluginManager by lazy { PluginManager(this) }
-
-    private val activators = HashSet<Any>()
-
-    /**
-     * Defines if context is used in any kind of active computations. Active context properties and plugins could not be changed
-     */
-    val isActive: Boolean = activators.isNotEmpty()
-
-    override val defaultTarget: String get() = Plugin.PLUGIN_TARGET
-
-    override fun provideTop(target: String, name: Name): Any? {
-        return when (target) {
-            Plugin.PLUGIN_TARGET -> plugins[PluginTag.fromString(name.toString())]
-            Value.TYPE -> properties[name]?.value
-            else -> null
-        }
-    }
-
-    override fun listNames(target: String): Sequence<Name> {
-        return when (target) {
-            Plugin.PLUGIN_TARGET -> plugins.asSequence().map { it.name.toName() }
-            Value.TYPE -> properties.values().map { it.first }
-            else -> emptySequence()
-        }
-    }
-
-    /**
-     * Mark context as active and used by [activator]
-     */
-    fun activate(activator: Any) {
-        activators.add(activator)
-    }
-
-    /**
-     * Mark context unused by [activator]
-     */
-    fun deactivate(activator: Any) {
-        activators.remove(activator)
-    }
-
-    /**
-     * Change the properties of the context. If active, throw an exception
-     */
-    fun configure(action: Config.() -> Unit) {
-        if (isActive) error("Can't configure active context")
-        config.action()
-    }
-
-    override val coroutineContext: CoroutineContext
-        get() = EmptyCoroutineContext
-
-    /**
-     * Detach all plugins and terminate context
-     */
-    open fun close() {
-        if (isActive) error("Can't close active context")
-        //detach all plugins
-        plugins.forEach { it.detach() }
-    }
-
-    override fun toMeta(): Meta = buildMeta {
-        "parent" to parent?.name
-        "properties" to properties.seal()
-        "plugins" to plugins.map { it.toMeta() }
-    }
-}
-
-/**
- * A sequences of all objects provided by plugins with given target and type
- */
-fun Context.content(target: String): Map<Name, Any> = content<Any>(target)
-
-@JvmName("typedContent")
-inline fun <reified T : Any> Context.content(target: String): Map<Name, T> =
-    plugins.flatMap { plugin ->
-        plugin.top<T>(target).entries.map { (it.key.appendLeft(plugin.name)) to it.value }
-    }.associate { it }
-
-
-/**
- * A global root context. Closing [Global] terminates the framework.
- */
-object Global : Context("GLOBAL", null) {
-    /**
-     * Closing all contexts
-     *
-     * @throws Exception
-     */
-    override fun close() {
-        logger.info { "Shutting down GLOBAL" }
-        for (ctx in contextRegistry.values) {
-            ctx.close()
-        }
-        super.close()
-    }
-
-    private val contextRegistry = HashMap<String, Context>()
-
-    /**
-     * Get previously builder context o builder a new one
-     *
-     * @param name
-     * @return
-     */
-    fun getContext(name: String): Context {
-        return contextRegistry.getOrPut(name) { Context(name) }
-    }
-}
-
-
-/**
- * The interface for something that encapsulated in context
- *
- * @author Alexander Nozik
- * @version $Id: $Id
- */
-interface ContextAware {
-    /**
-     * Get context for this object
-     *
-     * @return
-     */
-    val context: Context
-
-    val logger: KLogger
-        get() = if (this is Named) {
-            KotlinLogging.logger(context.name + "." + (this as Named).name)
-        } else {
-            context.logger
-        }
-
-}

dataforge-context/src/commonMain/kotlin/hep/dataforge/context/ContextBuilder.kt

@@ -1,36 +0,0 @@
-package hep.dataforge.context
-
-import hep.dataforge.meta.MetaBuilder
-import hep.dataforge.meta.buildMeta
-
-/**
- * A convenience builder for context
- */
-class ContextBuilder(var name: String = "@anonimous", val parent: Context = Global) {
-    private val plugins = ArrayList<Plugin>()
-    private var meta = MetaBuilder()
-
-    fun properties(action: MetaBuilder.() -> Unit) {
-        meta.action()
-    }
-
-    fun plugin(plugin: Plugin) {
-        plugins.add(plugin)
-    }
-
-    fun plugin(tag: PluginTag, action: MetaBuilder.() -> Unit) {
-        plugins.add(PluginRepository.fetch(tag, buildMeta(action)))
-    }
-
-    fun plugin(name: String, group: String = "", version: String = "", action: MetaBuilder.() -> Unit) {
-        plugin(PluginTag(name, group, version), action)
-    }
-
-    fun build(): Context {
-        return Context(name, parent).apply {
-            this@ContextBuilder.plugins.forEach {
-                plugins.load(it)
-            }
-        }
-    }
-}

dataforge-context/src/commonMain/kotlin/hep/dataforge/context/PluginManager.kt

@@ -1,171 +0,0 @@
-package hep.dataforge.context
-
-import hep.dataforge.meta.EmptyMeta
-import hep.dataforge.meta.Meta
-import hep.dataforge.meta.MetaBuilder
-import hep.dataforge.meta.buildMeta
-import kotlin.reflect.KClass
-
-/**
- * The manager for plugin system. Should monitor plugin dependencies and locks.
- *
- * @property context A context for this plugin manager
- * @author Alexander Nozik
- */
-class PluginManager(override val context: Context) : ContextAware, Iterable<Plugin> {
-
-    /**
-     * A set of loaded plugins
-     */
-    private val plugins = HashSet<Plugin>()
-
-    /**
-     * A [PluginManager] of parent context if it is present
-     */
-    private val parent: PluginManager? = context.parent?.plugins
-
-
-    fun sequence(recursive: Boolean): Sequence<Plugin> {
-        return if (recursive && parent != null) {
-            plugins.asSequence() + parent.sequence(true)
-        } else {
-            plugins.asSequence()
-        }
-    }
-
-    /**
-     * Get existing plugin or return null if not present. Only first matching plugin is returned.
-     * @param recursive search for parent [PluginManager] plugins
-     * @param predicate condition for the plugin
-     */
-    fun get(recursive: Boolean = true, predicate: (Plugin) -> Boolean): Plugin? = sequence(recursive).find(predicate)
-
-
-    /**
-     * Find a loaded plugin via its tag
-     *
-     * @param tag
-     * @return
-     */
-    operator fun get(tag: PluginTag, recursive: Boolean = true): Plugin? = get(recursive) { tag.matches(it.tag) }
-
-
-    /**
-     * Find a loaded plugin via its class
-     *
-     * @param tag
-     * @param type
-     * @param <T>
-     * @return
-     */
-    @Suppress("UNCHECKED_CAST")
-    operator fun <T : Plugin> get(type: KClass<T>, recursive: Boolean = true): T? =
-        get(recursive) { type.isInstance(it) } as T?
-
-    inline fun <reified T : Plugin> get(recursive: Boolean = true): T? = get(T::class, recursive)
-
-
-    /**
-     * Load given plugin into this manager and return loaded instance.
-     * Throw error if plugin of the same class already exists in manager
-     *
-     * @param plugin
-     * @return
-     */
-    fun <T : Plugin> load(plugin: T): T {
-        if (context.isActive) error("Can't load plugin into active context")
-
-        if (get(plugin::class, false) != null) {
-            throw  RuntimeException("Plugin of type ${plugin::class} already exists in ${context.name}")
-        } else {
-            loadDependencies(plugin)
-
-            logger.info { "Loading plugin ${plugin.name} into ${context.name}" }
-            plugin.attach(context)
-            plugins.add(plugin)
-            return plugin
-        }
-    }
-
-    private fun loadDependencies(plugin: Plugin) {
-        for (tag in plugin.dependsOn()) {
-            load(tag)
-        }
-    }
-
-    /**
-     * Remove a plugin from [PluginManager]
-     */
-    fun remove(plugin: Plugin) {
-        if (context.isActive) error("Can't remove plugin from active context")
-
-        if (plugins.contains(plugin)) {
-            logger.info { "Removing plugin ${plugin.name} from ${context.name}" }
-            plugin.detach()
-            plugins.remove(plugin)
-        }
-    }
-
-    /**
-     * Get plugin instance via plugin resolver and load it.
-     *
-     * @param tag
-     * @return
-     */
-    fun load(tag: PluginTag, meta: Meta = EmptyMeta): Plugin {
-        val loaded = get(tag, false)
-        return when {
-            loaded == null -> load(PluginRepository.fetch(tag,meta))
-            loaded.meta == meta -> loaded // if meta is the same, return existing plugin
-            else -> throw RuntimeException("Can't load plugin with tag $tag. Plugin with this tag and different configuration already exists in context.")
-        }
-    }
-
-    fun load(factory: PluginFactory<*>, meta: Meta = EmptyMeta): Plugin{
-        val loaded = get(factory.tag, false)
-        return when {
-            loaded == null -> load(factory(meta))
-            loaded.meta == meta -> loaded // if meta is the same, return existing plugin
-            else -> throw RuntimeException("Can't load plugin with tag ${factory.tag}. Plugin with this tag and different configuration already exists in context.")
-        }
-    }
-
-    /**
-     * Load plugin by its class and meta. Ignore if plugin with this meta is already loaded.
-     * Throw an exception if there exists plugin with the same type, but different meta
-     */
-    fun <T : Plugin> load(type: KClass<T>, meta: Meta = EmptyMeta): T {
-        val loaded = get(type, false)
-        return when {
-            loaded == null -> {
-                val plugin = PluginRepository.list().first { it.type == type }.invoke(meta)
-                if (type.isInstance(plugin)) {
-                    @Suppress("UNCHECKED_CAST")
-                    load(plugin as T)
-                } else {
-                    error("Corrupt type information in plugin repository")
-                }
-            }
-            loaded.meta == meta -> loaded // if meta is the same, return existing plugin
-            else -> throw RuntimeException("Can't load plugin with type $type. Plugin with this type and different configuration already exists in context.")
-        }
-    }
-
-    inline fun <reified T : Plugin> load(noinline metaBuilder: MetaBuilder.() -> Unit = {}): T {
-        return load(T::class, buildMeta(metaBuilder))
-    }
-
-    fun load(name: String, meta: Meta = EmptyMeta): Plugin {
-        return load(PluginTag.fromString(name), meta)
-    }
-
-    override fun iterator(): Iterator<Plugin> = plugins.iterator()
-
-    /**
-     * Get a plugin if it exists or load it with given meta if it is not.
-     */
-    inline fun <reified T : Plugin> getOrLoad(noinline metaBuilder: MetaBuilder.() -> Unit = {}): T {
-        return get(true) ?: load(metaBuilder)
-    }
-
-}

dataforge-context/src/commonMain/kotlin/hep/dataforge/context/PluginRepository.kt

@@ -1,49 +0,0 @@
-package hep.dataforge.context
-
-import hep.dataforge.meta.EmptyMeta
-import hep.dataforge.meta.Meta
-import kotlin.reflect.KClass
-
-interface PluginFactory<T : Plugin> {
-    val tag: PluginTag
-    val type: KClass<out T>
-    operator fun invoke(meta: Meta = EmptyMeta): T
-}
-
-expect object PluginRepository {
-
-    fun register(factory: PluginFactory<*>)
-
-    /**
-     * List plugins available in the repository
-     */
-    fun list(): Sequence<PluginFactory<*>>
-
-}
-
-/**
- * Fetch specific plugin and instantiate it with given meta
- */
-fun PluginRepository.fetch(tag: PluginTag, meta: Meta = EmptyMeta): Plugin =
-    list().find { it.tag.matches(tag) }?.invoke(meta) ?: error("Plugin with tag $tag not found in the repository")
-
-fun <T : Plugin> PluginRepository.register(
-    tag: PluginTag,
-    type: KClass<out T>,
-    constructor: (Meta) -> T
-): PluginFactory<T> {
-    val factory = object : PluginFactory<T> {
-        override val tag: PluginTag = tag
-        override val type: KClass<out T> = type
-
-        override fun invoke(meta: Meta): T = constructor(meta)
-
-    }
-    register(factory)
-    return factory
-}
-
-inline fun <reified T : Plugin> PluginRepository.register(tag: PluginTag, noinline constructor: (Meta) -> T) =
-    register(tag, T::class, constructor)
-
-fun PluginRepository.register(plugin: Plugin) = register(plugin.tag, plugin::class) { plugin }

dataforge-context/src/commonMain/kotlin/hep/dataforge/provider/Path.kt

@@ -1,75 +0,0 @@
-/*
- * Copyright 2015 Alexander Nozik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package hep.dataforge.provider
-
-import hep.dataforge.names.Name
-import hep.dataforge.names.toName
-
-/**
- *
- *
- * Path interface.
- *
- * @author Alexander Nozik
- * @version $Id: $Id
- */
-inline class Path(val tokens: List<PathToken>) : Iterable<PathToken> {
-
-    val head: PathToken? get() = tokens.firstOrNull()
-
-    val length: Int get() = tokens.size
-
-    /**
-     * Returns non-empty optional containing the chain without first segment in case of chain path.
-     *
-     * @return
-     */
-    val tail: Path? get() = if (tokens.isEmpty()) null else Path(tokens.drop(1))
-
-    override fun iterator(): Iterator<PathToken> = tokens.iterator()
-
-    companion object {
-        const val PATH_SEGMENT_SEPARATOR = "/"
-
-        fun parse(path: String): Path {
-            val head = path.substringBefore(PATH_SEGMENT_SEPARATOR)
-            val tail = path.substringAfter(PATH_SEGMENT_SEPARATOR)
-            return PathToken.parse(head).toPath() + parse(tail)
-        }
-    }
-}
-
-operator fun Path.plus(path: Path) = Path(this.tokens + path.tokens)
-
-data class PathToken(val name: Name, val target: String? = null) {
-    override fun toString(): String = if (target == null) {
-        name.toString()
-    } else {
-        "$target$TARGET_SEPARATOR$name"
-    }
-
-    companion object {
-        const val TARGET_SEPARATOR = "::"
-        fun parse(token: String): PathToken {
-            val target = token.substringBefore(TARGET_SEPARATOR, "")
-            val name = token.substringAfter(TARGET_SEPARATOR).toName()
-            if (target.contains("[")) TODO("target separators in queries are not supported")
-            return PathToken(name, target)
-        }
-    }
-}
-
-fun PathToken.toPath() = Path(listOf(this))

dataforge-context/src/commonMain/kotlin/hep/dataforge/provider/Provider.kt

@@ -1,100 +0,0 @@
-/*
- * Copyright 2015 Alexander Nozik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package hep.dataforge.provider
-
-import hep.dataforge.names.Name
-import hep.dataforge.names.toName
-import kotlin.jvm.JvmName
-
-/**
- * A marker utility interface for providers.
- *
- * @author Alexander Nozik
- */
-interface Provider {
-
-    /**
-     * Default target for this provider
-     *
-     * @return
-     */
-    val defaultTarget: String get() = ""
-
-    /**
-     * Default target for next chain segment
-     *
-     * @return
-     */
-    val defaultChainTarget: String get() = ""
-
-
-    /**
-     * Provide a top level element for this [Provider] or return null if element is not present
-     */
-    fun provideTop(target: String, name: Name): Any?
-
-    /**
-     * [Sequence] of available names with given target. Only top level names are listed, no chain path.
-     *
-     * @param target
-     * @return
-     */
-    fun listNames(target: String): Sequence<Name>
-}
-
-fun Provider.provide(path: Path, targetOverride: String? = null): Any? {
-    if (path.length == 0) throw IllegalArgumentException("Can't provide by empty path")
-    val first = path.first()
-    val top = provideTop(targetOverride ?: first.target ?: defaultTarget, first.name)
-    return when (path.length) {
-        1 -> top
-        else -> {
-            when (top) {
-                null -> null
-                is Provider -> top.provide(path.tail!!, targetOverride = defaultChainTarget)
-                else -> throw IllegalStateException("Chain path not supported: child is not a provider")
-            }
-        }
-    }
-}
-
-/**
- * Type checked provide
- */
-inline fun <reified T : Any> Provider.provide(path: String): T? {
-    return provide(Path.parse(path)) as? T
-}
-
-inline fun <reified T : Any> Provider.provide(target: String, name: Name): T? {
-    return provide(PathToken(name, target).toPath()) as? T
-}
-
-inline fun <reified T : Any> Provider.provide(target: String, name: String): T? =
-    provide(target, name.toName())
-
-/**
- *  A top level content with names
- */
-fun Provider.top(target: String): Map<Name, Any> = top<Any>(target)
-
-@JvmName("typedTop")
-inline fun <reified T : Any> Provider.top(target: String): Map<Name, T> {
-    return listNames(target).associate {
-        it to (provideTop(target, it) as? T ?: error("The element $it is declared but not provided"))
-    }
-}
-
-

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/context/AbstractPlugin.kt

@@ -0,0 +1,57 @@
+package space.kscience.dataforge.context
+
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.misc.DFInternal
+import space.kscience.dataforge.misc.Named
+import space.kscience.dataforge.names.Name
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KClass
+import kotlin.reflect.KProperty
+
+public abstract class AbstractPlugin(override val meta: Meta = Meta.EMPTY) : Plugin {
+    private var _context: Context? = null
+    private val dependencies = HashMap<PluginFactory<*>, Meta>()
+
+    override val isAttached: Boolean get() = _context != null
+
+    override val context: Context
+        get() = _context ?: error("Plugin $tag is not attached")
+
+    override fun attach(context: Context) {
+        this._context = context
+    }
+
+    override fun detach() {
+        this._context = null
+    }
+
+    override fun dependsOn(): Map<PluginFactory<*>, Meta> = dependencies
+
+    protected fun <P : Plugin> require(
+        factory: PluginFactory<P>,
+        type: KClass<P>,
+        meta: Meta = Meta.EMPTY,
+    ): ReadOnlyProperty<AbstractPlugin, P> {
+        dependencies[factory] = meta
+        return PluginDependencyDelegate(factory, type)
+    }
+
+    /**
+     * Register plugin dependency and return a delegate which provides lazily initialized reference to dependent plugin
+     */
+    protected inline fun <reified P : Plugin> require(
+        factory: PluginFactory<P>,
+        meta: Meta = Meta.EMPTY,
+    ): ReadOnlyProperty<AbstractPlugin, P> = require(factory, P::class, meta)
+}
+
+public fun <T : Named> Collection<T>.associateByName(): Map<Name, T> = associate { it.name to it }
+
+private class PluginDependencyDelegate<P : Plugin>(val factory: PluginFactory<P>, val type: KClass<P>) :
+    ReadOnlyProperty<AbstractPlugin, P> {
+    @OptIn(DFInternal::class)
+    override fun getValue(thisRef: AbstractPlugin, property: KProperty<*>): P {
+        if (!thisRef.isAttached) error("Plugin dependency must not be called eagerly during initialization.")
+        return thisRef.context.plugins.getByType(type, factory.tag) ?: error("Plugin ${factory.tag} not found")
+    }
+}

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/context/Context.kt

@@ -0,0 +1,119 @@
+package space.kscience.dataforge.context
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import space.kscience.dataforge.meta.*
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.misc.Named
+import space.kscience.dataforge.misc.ThreadSafe
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.provider.Provider
+import kotlin.coroutines.CoroutineContext
+
+/**
+ * The local environment for anything being done in DataForge framework. Contexts are organized into tree structure with [Global] at the top.
+ * Context has [properties] - equivalent for system environment values, but grouped into a tree and inherited from parent context.
+ *
+ * The main function of the Context is to provide [PluginManager] which stores the loaded plugins and works as a dependency injection point.
+ * The normal behaviour of the [PluginManager] is to search for a plugin in parent context if it is not found in a current one. It is possible to have
+ * different plugins with the same interface in different contexts in the hierarchy. The usual behaviour is to use nearest one, but it could
+ * be overridden by plugin implementation.
+ *
+ */
+public open class Context internal constructor(
+    final override val name: Name,
+    public val parent: Context?,
+    plugins: Set<Plugin>, // set of unattached plugins
+    meta: Meta,
+) : Named, MetaRepr, Provider, CoroutineScope {
+
+    /**
+     * Context properties. Working as substitute for environment variables
+     */
+    public val properties: Laminate = if (parent == null) {
+        Laminate(meta)
+    } else {
+        Laminate(meta, parent.properties)
+    }
+
+
+    /**
+     * A [PluginManager] for current context
+     */
+    public val plugins: PluginManager by lazy { PluginManager(this, plugins) }
+
+    override val defaultTarget: String get() = Plugin.TARGET
+
+    public fun content(target: String, inherit: Boolean): Map<Name, Any> {
+        return if (inherit) {
+            when (target) {
+                PROPERTY_TARGET -> properties.nodeSequence().toMap()
+                Plugin.TARGET -> plugins.list(true).associateBy { it.name }
+                else -> emptyMap()
+            }
+        } else {
+            when (target) {
+                PROPERTY_TARGET -> properties.layers.firstOrNull()?.nodeSequence()?.toMap() ?: emptyMap()
+                Plugin.TARGET -> plugins.list(false).associateBy { it.name }
+                else -> emptyMap()
+            }
+        }
+    }
+
+    override fun content(target: String): Map<Name, Any> = content(target, true)
+
+    override val coroutineContext: CoroutineContext by lazy {
+        (parent ?: Global).coroutineContext.let { parenContext ->
+            parenContext + SupervisorJob(parenContext[Job])
+        }
+    }
+
+    private val childrenContexts = HashMap<Name, Context>()
+
+    /**
+     * Get and validate existing context or build and register a new child context.
+     * @param name the relative (tail) name of the new context. If null, uses context hash code as a marker.
+     */
+    @OptIn(DFExperimental::class)
+    @ThreadSafe
+    public fun buildContext(name: Name? = null, block: ContextBuilder.() -> Unit = {}): Context {
+        val existing = name?.let { childrenContexts[name] }
+        return existing?.modify(block) ?: ContextBuilder(this, name).apply(block).build().also {
+            childrenContexts[it.name] = it
+        }
+    }
+
+    /**
+     * Detach all plugins, and close child contexts
+     */
+    public open fun close() {
+        //recursively closed child context
+        childrenContexts.forEach { it.value.close() }
+        //detach all plugins
+        plugins.forEach { it.detach() }
+    }
+
+    override fun toMeta(): Meta = Meta {
+        "parent" to parent?.name
+        properties.layers.firstOrNull()?.let { set("properties", it) }
+        "plugins" putIndexed plugins.map { it.toMeta() }
+    }
+
+    public companion object {
+        public const val PROPERTY_TARGET: String = "context.property"
+    }
+}
+
+/**
+ * The interface for something that encapsulated in context
+ *
+ */
+public interface ContextAware {
+    /**
+     * Get context for this object
+     *
+     * @return
+     */
+    public val context: Context
+}

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/context/ContextBuilder.kt

@@ -0,0 +1,111 @@
+package space.kscience.dataforge.context
+
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MutableMeta
+import space.kscience.dataforge.meta.seal
+import space.kscience.dataforge.meta.toMutableMeta
+import space.kscience.dataforge.misc.DFBuilder
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.NameToken
+import space.kscience.dataforge.names.asName
+import space.kscience.dataforge.names.plus
+import kotlin.collections.component1
+import kotlin.collections.component2
+import kotlin.collections.set
+
+/**
+ * A convenience builder for context
+ */
+@DFBuilder
+public class ContextBuilder internal constructor(
+    private val parent: Context,
+    public val name: Name? = null,
+    meta: Meta = Meta.EMPTY,
+) {
+    internal val factories = HashMap<PluginFactory<*>, Meta>()
+    internal var meta = meta.toMutableMeta()
+
+    public fun properties(action: MutableMeta.() -> Unit) {
+        meta.action()
+    }
+
+    @OptIn(DFExperimental::class)
+    private fun findPluginFactory(tag: PluginTag): PluginFactory<*> =
+        parent.gatherInSequence<PluginFactory<*>>(PluginFactory.TYPE).values
+            .find { it.tag.matches(tag) } ?: error("Can't resolve plugin factory for $tag")
+
+    public fun plugin(tag: PluginTag, mutableMeta: MutableMeta.() -> Unit = {}) {
+        val factory = findPluginFactory(tag)
+        factories[factory] = Meta(mutableMeta)
+    }
+
+    public fun plugin(factory: PluginFactory<*>, meta: Meta) {
+        factories[factory] = meta
+    }
+
+    public fun plugin(factory: PluginFactory<*>, mutableMeta: MutableMeta.() -> Unit = {}) {
+        factories[factory] = Meta(mutableMeta)
+    }
+
+    public fun plugin(name: String, group: String = "", version: String = "", action: MutableMeta.() -> Unit = {}) {
+        plugin(PluginTag(name, group, version), action)
+    }
+
+    /**
+     * Add de-facto existing plugin as a dependency
+     */
+    public fun plugin(plugin: Plugin) {
+        plugin(DeFactoPluginFactory(plugin))
+    }
+
+    public fun build(): Context {
+        val contextName = name ?: NameToken("@auto",hashCode().toUInt().toString(16)).asName()
+        val plugins = HashMap<PluginTag, Plugin>()
+
+        fun addPlugin(factory: PluginFactory<*>, meta: Meta) {
+            val existing = plugins[factory.tag]
+            // Add if does not exist
+            if (existing == null) {
+                //TODO bypass if parent already has plugin with given meta?
+                val plugin = factory.build(parent, meta)
+
+                for ((depFactory, deoMeta) in plugin.dependsOn()) {
+                    addPlugin(depFactory, deoMeta)
+                }
+
+                parent.logger.info { "Loading plugin ${plugin.name} into $contextName" }
+                plugins[plugin.tag] = plugin
+            } else if (existing.meta != meta) {
+                error("Plugin with tag ${factory.tag} and meta $meta already exists in $contextName")
+            }
+            //bypass if exists with the same meta
+        }
+
+        factories.forEach { (factory, meta) ->
+            addPlugin(factory, meta)
+        }
+
+        return Context(contextName, parent, plugins.values.toSet(), meta.seal())
+    }
+}
+
+/**
+ * Check if current context contains all plugins required by the builder and return it does or forks to a new context
+ * if it does not.
+ */
+@DFExperimental
+public fun Context.modify(block: ContextBuilder.() -> Unit): Context {
+
+    fun Context.contains(factory: PluginFactory<*>, meta: Meta): Boolean {
+        val loaded = plugins[factory.tag] ?: return false
+        return loaded.meta == meta
+    }
+
+    val builder = ContextBuilder(this, name + "mod", properties).apply(block)
+    val requiresFork = builder.factories.any { (factory, meta) ->
+        !contains(factory, meta)
+    } || ((properties as Meta) == builder.meta)
+
+    return if (requiresFork) builder.build() else this
+}

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/context/Factory.kt

@@ -0,0 +1,12 @@
+package space.kscience.dataforge.context
+
+import space.kscience.dataforge.meta.Meta
+
+public fun interface Factory<out T> {
+    public fun build(context: Context, meta: Meta): T
+}
+
+public operator fun <T> Factory<T>.invoke(
+    meta: Meta = Meta.EMPTY,
+    context: Context = Global,
+): T = build(context, meta)

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/context/Global.kt

@@ -0,0 +1,24 @@
+package space.kscience.dataforge.context
+
+import kotlinx.coroutines.CoroutineName
+import kotlinx.coroutines.Job
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.names.asName
+import space.kscience.dataforge.names.parseAsName
+import kotlin.coroutines.CoroutineContext
+import kotlin.native.concurrent.ThreadLocal
+
+internal expect fun getGlobalLoggerFactory(): PluginFactory<out LogManager>
+
+/**
+ * A global root context. Closing [Global] terminates the framework.
+ */
+@ThreadLocal
+private object GlobalContext : Context("GLOBAL".asName(), null, emptySet(), Meta.EMPTY) {
+    override val coroutineContext: CoroutineContext = Job() + CoroutineName("GlobalContext")
+}
+
+public val Global: Context get() = GlobalContext
+
+public fun Context(name: String? = null, block: ContextBuilder.() -> Unit = {}): Context =
+    Global.buildContext(name?.parseAsName(), block)

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/context/LogManager.kt

@@ -0,0 +1,89 @@
+package space.kscience.dataforge.context
+
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.misc.Named
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.plus
+
+public fun interface Logger {
+    public fun log(tag: String, body: () -> String)
+}
+
+public interface LogManager : Plugin, Logger {
+    public fun logger(name: Name): Logger
+
+    public val defaultLogger: Logger
+
+    override fun log(tag: String, body: () -> String): Unit = defaultLogger.log(tag, body)
+
+    public fun log(name: Name, tag: String, body: () -> String): Unit = logger(name).log(tag, body)
+
+    public companion object {
+        public const val TRACE: String = "TRACE"
+        public const val INFO: String = "INFO"
+        public const val DEBUG: String = "DEBUG"
+        public const val WARNING: String = "WARNING"
+        public const val ERROR: String = "ERROR"
+    }
+}
+
+public fun Logger.trace(body: () -> String): Unit = log(LogManager.TRACE, body)
+public fun Logger.info(body: () -> String): Unit = log(LogManager.INFO, body)
+public fun Logger.debug(body: () -> String): Unit = log(LogManager.DEBUG, body)
+public fun Logger.warn(body: () -> String): Unit = log(LogManager.WARNING, body)
+public fun Logger.error(body: () -> String): Unit = log(LogManager.ERROR, body)
+
+internal val (() -> String).safe: String
+    get() = try {
+        invoke()
+    } catch (t: Throwable) {
+        "Error while evaluating log string: ${t.message}"
+    }
+
+
+public fun Logger.error(throwable: Throwable?, body: () -> String): Unit = log(LogManager.ERROR) {
+    buildString {
+        appendLine(body())
+        throwable?.let { appendLine(throwable.stackTraceToString()) }
+    }
+}
+
+
+public class DefaultLogManager : AbstractPlugin(), LogManager {
+
+    override fun logger(name: Name): Logger = Logger { tag, body ->
+        val message: String = body.safe
+        println("$tag $name: [${context.name}] $message")
+    }
+
+    override val defaultLogger: Logger = logger(Name.EMPTY)
+
+
+    override val tag: PluginTag get() = Companion.tag
+
+    public companion object : PluginFactory<DefaultLogManager> {
+        override fun build(context: Context, meta: Meta): DefaultLogManager = DefaultLogManager()
+
+        override val tag: PluginTag = PluginTag(group = PluginTag.DATAFORGE_GROUP, name = "log.default")
+    }
+}
+
+/**
+ * Context log manager inherited from parent
+ */
+public val Context.logger: LogManager
+    get() = plugins.find(inherit = true) { it is LogManager } as? LogManager
+        ?: getGlobalLoggerFactory().build(context = Global, meta = Meta.EMPTY).apply { attach(Global) }
+
+/**
+ * The named proxy logger for a context member
+ */
+public val ContextAware.logger: Logger
+    get() = if (this is Named) {
+        Logger { tag, body ->
+            context.logger.log(this@logger.name + name, tag, body)
+        }
+    } else {
+        context.logger
+    }
+

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/context/Plugin.kt

@@ -1,78 +1,68 @@
-package hep.dataforge.context
+package space.kscience.dataforge.context
 
-import hep.dataforge.meta.Meta
-import hep.dataforge.meta.MetaRepr
-import hep.dataforge.meta.buildMeta
-import hep.dataforge.provider.Provider
+import space.kscience.dataforge.context.Plugin.Companion.TARGET
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MetaRepr
+import space.kscience.dataforge.misc.DfId
+import space.kscience.dataforge.misc.Named
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.parseAsName
+import space.kscience.dataforge.provider.Provider
 
 /**
  * The interface to define a Context plugin. A plugin stores all runtime features of a context.
  * The plugin is by default configurable and a Provider (both features could be ignored).
  * The plugin must in most cases have an empty constructor in order to be able to load it from library.
  *
- *
  * The plugin lifecycle is the following:
  *
- *
  * create - configure - attach - detach - destroy
- *
- *
- * Configuration of attached plugin is possible for a context which is not in a runtime mode, but it is not recommended.
- *
- * @author Alexander Nozik
  */
-interface Plugin : Named, ContextAware, Provider, MetaRepr {
+@DfId(TARGET)
+public interface Plugin : Named, ContextAware, Provider, MetaRepr {
 
     /**
      * Get tag for this plugin
-     *
-     * @return
      */
-    val tag: PluginTag
+    public val tag: PluginTag
 
-    val meta: Meta
+    public val meta: Meta
 
     /**
      * The name of this plugin ignoring version and group
-     *
-     * @return
      */
-    override val name: String get() = tag.name
+    override val name: Name get() = tag.name.parseAsName()
 
     /**
      * Plugin dependencies which are required to attach this plugin. Plugin
      * dependencies must be initialized and enabled in the Context before this
      * plugin is enabled.
-     *
-     * @return
      */
-    fun dependsOn(): List<PluginFactory<*>> = emptyList()
+    public fun dependsOn(): Map<PluginFactory<*>, Meta>
 
     /**
      * Start this plugin and attach registration info to the context. This method
      * should be called only via PluginManager to avoid dependency issues.
-     *
-     * @param context
      */
-    fun attach(context: Context)
+    public fun attach(context: Context)
 
     /**
      * Stop this plugin and remove registration info from context and other
      * plugins. This method should be called only via PluginManager to avoid
      * dependency issues.
      */
-    fun detach()
+    public fun detach()
 
-    override fun toMeta(): Meta = buildMeta {
-        "context" to context.name
+    public val isAttached: Boolean
+
+    override fun toMeta(): Meta = Meta {
+        "context" put context.name.toString()
         "type" to this::class.simpleName
-        "tag" to tag
-        "meta" to meta
+        "tag" put tag
+        "meta" put meta
     }
 
-    companion object {
-
-        const val PLUGIN_TARGET = "plugin"
+    public companion object {
+        public const val TARGET: String = "plugin"
     }
-
 }

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/context/PluginBuilder.kt

@@ -0,0 +1,57 @@
+package space.kscience.dataforge.context
+
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.misc.Named
+import space.kscience.dataforge.names.Name
+
+/**
+ * A convenience factory to build simple plugins
+ */
+public class PluginBuilder(
+    name: String,
+    group: String = "",
+    version: String = "",
+) {
+    public val tag: PluginTag = PluginTag(name, group, version)
+
+    private val content = HashMap<String, MutableMap<Name, Any>>()
+    private val dependencies = HashMap<PluginFactory<*>, Meta>()
+
+    public fun requires(
+        factory: PluginFactory<*>,
+        meta: Meta = Meta.EMPTY,
+    ) {
+        dependencies[factory] = meta
+    }
+
+    public fun provides(target: String, items: Map<Name, Any>) {
+        content.getOrPut(target) { HashMap() }.putAll(items)
+    }
+
+    public fun provides(target: String, vararg items: Named) {
+        provides(target, items.associateBy { it.name })
+    }
+
+    public fun build(): PluginFactory<*> {
+
+        return object : PluginFactory<Plugin> {
+            override val tag: PluginTag get() = this@PluginBuilder.tag
+
+            override fun build(context: Context, meta: Meta): Plugin = object : AbstractPlugin() {
+                override val tag: PluginTag get() = this@PluginBuilder.tag
+
+                override fun content(target: String): Map<Name, Any> = this@PluginBuilder.content[target] ?: emptyMap()
+
+                override fun dependsOn(): Map<PluginFactory<*>, Meta> = this@PluginBuilder.dependencies
+            }
+
+        }
+    }
+}
+
+public fun PluginFactory(
+    name: String,
+    group: String = "",
+    version: String = "",
+    block: PluginBuilder.() -> Unit,
+): PluginFactory<*> = PluginBuilder(name, group, version).apply(block).build()

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/context/PluginFactory.kt

@@ -0,0 +1,21 @@
+package space.kscience.dataforge.context
+
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.misc.DfId
+
+@DfId(PluginFactory.TYPE)
+public interface PluginFactory<T : Plugin> : Factory<T> {
+    public val tag: PluginTag
+
+    public companion object {
+        public const val TYPE: String = "pluginFactory"
+    }
+}
+
+/**
+ * Plugin factory created for the specific actual plugin
+ */
+internal class DeFactoPluginFactory<T : Plugin>(val plugin: T) : PluginFactory<T> {
+    override fun build(context: Context, meta: Meta): T = plugin
+    override val tag: PluginTag get() = plugin.tag
+}

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/context/PluginManager.kt

@@ -0,0 +1,100 @@
+package space.kscience.dataforge.context
+
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.misc.DFInternal
+import space.kscience.dataforge.names.plus
+import kotlin.reflect.KClass
+import kotlin.reflect.cast
+
+
+/**
+ * The manager for plugin system. Should monitor plugin dependencies and locks.
+ *
+ * @property context A context for this plugin manager
+ * @author Alexander Nozik
+ */
+public class PluginManager internal constructor(
+    override val context: Context,
+    private val plugins: Set<Plugin>,
+) : ContextAware, Iterable<Plugin> {
+
+    init {
+        plugins.forEach { it.attach(context) }
+    }
+
+    /**
+     * A [PluginManager] of parent context if it is present
+     */
+    private val parent: PluginManager? = context.parent?.plugins
+
+    /**
+     * List plugins stored in this [PluginManager]. If [inherit] is true, include parent plugins as well
+     */
+    public fun list(inherit: Boolean): Collection<Plugin> {
+        return if (inherit && parent != null) {
+            plugins + parent.list(true)
+        } else {
+            plugins
+        }
+    }
+
+    /**
+     * Get existing plugin or return null if not present. Only first matching plugin is returned.
+     * @param inherit search for parent [PluginManager] plugins
+     * @param predicate condition for the plugin
+     */
+    public fun find(inherit: Boolean = true, predicate: (Plugin) -> Boolean): Plugin? =
+        list(inherit).find(predicate)
+
+    /**
+     * Find a loaded plugin via its tag
+     *
+     * @param tag
+     * @return
+     */
+    public operator fun get(tag: PluginTag, inherit: Boolean = true): Plugin? =
+        find(inherit) { tag.matches(it.tag) }
+
+    /**
+     * Find a loaded plugin via its class. This method does not check if the result is unique and just returns first
+     * plugin matching the class condition.
+     * For safe search provide a tag since tags are checked on load and plugins with the same tag are not allowed
+     * in the same context.
+     *
+     * @param tag
+     * @param type
+     * @param <T>
+     * @return
+     */
+    @DFInternal
+    public fun <T : Any> getByType(type: KClass<T>, tag: PluginTag? = null, inherit: Boolean = true): T? =
+        find(inherit) { type.isInstance(it) && (tag == null || tag.matches(it.tag)) }?.let { type.cast(it) }
+
+    @OptIn(DFInternal::class)
+    public inline operator fun <reified T : Any> get(tag: PluginTag? = null, recursive: Boolean = true): T? =
+        getByType(T::class, tag, recursive)
+
+    @OptIn(DFInternal::class)
+    public inline operator fun <reified T : Plugin> get(factory: PluginFactory<T>, recursive: Boolean = true): T? =
+        getByType(T::class, factory.tag, recursive)
+
+    override fun iterator(): Iterator<Plugin> = plugins.iterator()
+}
+
+/**
+ * Fetch a plugin with given meta from the context. If the plugin (with given meta) is already registered, it is returned.
+ * Otherwise, new child context with the plugin is created. In the later case the context could be retrieved from the plugin.
+ */
+public inline fun <reified T : Plugin> Context.request(factory: PluginFactory<T>, meta: Meta = Meta.EMPTY): T {
+    val existing = plugins[factory]
+    return if (existing != null && existing.meta == meta) existing
+    else {
+        buildContext(name = this@request.name + factory.tag.name) {
+            plugin(factory, meta)
+        }.plugins[factory]!!
+    }
+}
+
+@Deprecated("Replace with request", ReplaceWith("request(factory, meta)"))
+public inline fun <reified T : Plugin> Context.fetch(factory: PluginFactory<T>, meta: Meta = Meta.EMPTY): T =
+    request(factory, meta)

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/context/PluginTag.kt

@@ -1,8 +1,8 @@
-package hep.dataforge.context
+package space.kscience.dataforge.context
 
-import hep.dataforge.meta.Meta
-import hep.dataforge.meta.MetaRepr
-import hep.dataforge.meta.buildMeta
+import kotlinx.serialization.Serializable
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MetaRepr
 
 /**
  * The tag which contains information about name, group and version of some
@@ -10,7 +10,8 @@ import hep.dataforge.meta.buildMeta
  *
  * @author Alexander Nozik
  */
-data class PluginTag(
+@Serializable
+public data class PluginTag(
     val name: String,
     val group: String = "",
     val version: String = ""
@@ -22,7 +23,7 @@ data class PluginTag(
      * @param otherTag
      * @return
      */
-    fun matches(otherTag: PluginTag): Boolean {
+    public fun matches(otherTag: PluginTag): Boolean {
         return matchesName(otherTag) && matchesGroup(otherTag)
     }
 
@@ -36,15 +37,15 @@ data class PluginTag(
 
     override fun toString(): String = listOf(group, name, version).joinToString(separator = ":")
 
-    override fun toMeta(): Meta = buildMeta {
-        "name" to name
-        "group" to group
-        "version" to version
+    override fun toMeta(): Meta = Meta {
+        "name" put name
+        "group" put group
+        "version" put version
     }
 
-    companion object {
+    public companion object {
 
-        const val DATAFORGE_GROUP = "hep.dataforge"
+        public const val DATAFORGE_GROUP: String = "dataforge"
 
         /**
          * Build new PluginTag from standard string representation
@@ -52,7 +53,7 @@ data class PluginTag(
          * @param tag
          * @return
          */
-        fun fromString(tag: String): PluginTag {
+        public fun fromString(tag: String): PluginTag {
             val sepIndex = tag.indexOf(":")
             return if (sepIndex >= 0) {
                 PluginTag(group = tag.substring(0, sepIndex), name = tag.substring(sepIndex + 1))

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/context/resolve.kt

@@ -0,0 +1,97 @@
+package space.kscience.dataforge.context
+
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.plus
+import space.kscience.dataforge.provider.Provider
+import space.kscience.dataforge.provider.top
+import kotlin.reflect.KClass
+import kotlin.reflect.cast
+
+/**
+ * Resolve a specific element in top level elements of the provider and attempt to cast it to the given type
+ */
+private fun <T : Any> Provider.provide(target: String, name: Name, type: KClass<out T>): T? {
+    return content(target)[name]?.let { type.cast(it) }
+}
+
+/**
+ * Resolve a top level object with given [target] and [name] in a [Context] own scope or its plugins.
+ */
+public fun <T : Any> Context.resolve(target: String, name: Name, type: KClass<out T>): T? {
+    //Try searching for plugin an context property
+    provide(target, name, type)?.let { return it }
+    val pluginContent = plugins.mapNotNull { it.provide(target, name, type) }
+    return if (pluginContent.isEmpty()) {
+        parent?.resolve<T>(target, name, type)
+    } else {
+        pluginContent.single() // throws error in case of name/type conflicts
+    }
+}
+
+/**
+ * Resolve a top level object with given [target] and [name] in a [Context] own scope or its plugins.
+ */
+public inline fun <reified T : Any> Context.resolve(target: String, name: Name): T? =
+    resolve(target, name, T::class)
+
+/**
+ * Gather a map of all top-level objects with given [target] from context plugins.
+ * Content from plugins is prefixed by plugin name so name conflicts are impossible
+ * This operation could be slow in case of large number of plugins
+ */
+public fun <T : Any> Context.gather(
+    target: String,
+    type: KClass<out T>,
+    inherit: Boolean = true,
+): Map<Name, T> = buildMap {
+    putAll(top(target, type))
+    plugins.forEach { plugin ->
+        plugin.top(target, type).forEach { (name, value) ->
+            val itemName = plugin.name + name
+            if (containsKey(itemName)) error("Name conflict during gather. An item with name $name could not be gathered from $plugin because key is already present.")
+            put(itemName, value)
+        }
+    }
+    if (inherit) {
+        parent?.gather(target, type, inherit)?.forEach {
+            //put all values from parent if they are not conflicting
+            if (!containsKey(it.key)) {
+                put(it.key, it.value)
+            }
+        }
+    }
+}
+
+public inline fun <reified T : Any> Context.gather(target: String, inherit: Boolean = true): Map<Name, T> =
+    gather(target, T::class, inherit)
+
+/**
+ * Gather all content from context itself and its plugins in a form of sequence of name-value pairs. Ignores name conflicts.
+ *
+ * Adds parent context sequence as well if [inherit] is true
+ */
+@DFExperimental
+public fun <T : Any> Context.gatherInSequence(
+    target: String,
+    type: KClass<out T>,
+    inherit: Boolean = true,
+): Sequence<Map.Entry<Name, T>> = sequence {
+    yieldAll(top(target, type).entries)
+    plugins.forEach { plugin ->
+        yieldAll(plugin.top(target, type).mapKeys { plugin.name + it.key }.entries)
+    }
+    if (inherit) {
+        parent?.gather(target, type, inherit)?.let {
+            yieldAll(it.entries)
+        }
+    }
+}
+
+@DFExperimental
+public inline fun <reified T : Any> Context.gatherInSequence(
+    target: String,
+    inherit: Boolean = true,
+): Sequence<Map.Entry<Name, T>> = gatherInSequence(target, T::class, inherit)
+
+public val <T> Sequence<Map.Entry<Name, T>>.values: Sequence<T> get() = map { it.value }

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/properties/MetaProperty.kt

@@ -0,0 +1,35 @@
+package space.kscience.dataforge.properties
+
+
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.ObservableMutableMeta
+import space.kscience.dataforge.meta.transformations.MetaConverter
+import space.kscience.dataforge.meta.transformations.nullableMetaToObject
+import space.kscience.dataforge.meta.transformations.nullableObjectToMeta
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.startsWith
+
+@DFExperimental
+public class MetaProperty<T : Any>(
+    public val meta: ObservableMutableMeta,
+    public val name: Name,
+    public val converter: MetaConverter<T>,
+) : Property<T?> {
+
+    override var value: T?
+        get() = converter.nullableMetaToObject(meta[name])
+        set(value) {
+            meta[name] = converter.nullableObjectToMeta(value) ?: Meta.EMPTY
+        }
+
+    override fun onChange(owner: Any?, callback: (T?) -> Unit) {
+        meta.onChange(owner) { name ->
+            if (name.startsWith(this@MetaProperty.name)) callback(converter.nullableMetaToObject(this[name]))
+        }
+    }
+
+    override fun removeChangeListener(owner: Any?) {
+        meta.removeListener(owner)
+    }
+}

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/properties/Property.kt

@@ -0,0 +1,47 @@
+package space.kscience.dataforge.properties
+
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import space.kscience.dataforge.misc.DFExperimental
+
+@DFExperimental
+public interface Property<T> {
+    public var value: T
+
+    public fun onChange(owner: Any? = null, callback: (T) -> Unit)
+    public fun removeChangeListener(owner: Any? = null)
+}
+
+@DFExperimental
+@OptIn(ExperimentalCoroutinesApi::class)
+public fun <T> Property<T>.toFlow(): StateFlow<T> = MutableStateFlow(value).also { stateFlow ->
+    onChange {
+        stateFlow.value = it
+    }
+}
+
+/**
+ * Reflect all changes in the [source] property onto this property. Does not reflect changes back.
+ *
+ * @return a mirroring job
+ */
+@DFExperimental
+public fun <T> Property<T>.mirror(source: Property<T>) {
+    source.onChange(this) {
+        this.value = it
+    }
+}
+
+/**
+ * Bi-directional connection between properties
+ */
+@DFExperimental
+public fun <T> Property<T>.bind(other: Property<T>) {
+    onChange(other) {
+        other.value = it
+    }
+    other.onChange {
+        this.value = it
+    }
+}

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/properties/schemeProperty.kt

@@ -0,0 +1,31 @@
+package space.kscience.dataforge.properties
+
+
+import space.kscience.dataforge.meta.Scheme
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.names.parseAsName
+import space.kscience.dataforge.names.startsWith
+import kotlin.reflect.KMutableProperty1
+
+@DFExperimental
+public fun <S : Scheme, T : Any> S.property(property: KMutableProperty1<S, T?>): Property<T?> =
+    object : Property<T?> {
+        override var value: T?
+            get() = property.get(this@property)
+            set(value) {
+                property.set(this@property, value)
+            }
+
+        override fun onChange(owner: Any?, callback: (T?) -> Unit) {
+            this@property.meta.onChange(this) { name ->
+                if (name.startsWith(property.name.parseAsName(true))) {
+                    callback(property.get(this@property))
+                }
+            }
+        }
+
+        override fun removeChangeListener(owner: Any?) {
+            this@property.meta.removeListener(this@property)
+        }
+
+    }

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/provider/Path.kt

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2015 Alexander Nozik.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package space.kscience.dataforge.provider
+
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.parseAsName
+import kotlin.jvm.JvmInline
+
+/**
+ * Path interface.
+ *
+ */
+@JvmInline
+public value class Path(public val tokens: List<PathToken>) : Iterable<PathToken> {
+
+    override fun iterator(): Iterator<PathToken> = tokens.iterator()
+
+    override fun toString(): String = tokens.joinToString(separator = PATH_SEGMENT_SEPARATOR)
+
+    public companion object {
+        public const val PATH_SEGMENT_SEPARATOR: String = "/"
+
+        public fun parse(path: String): Path = Path(path.split(PATH_SEGMENT_SEPARATOR).map { PathToken.parse(it) })
+    }
+}
+
+public val Path.length: Int get() = tokens.size
+
+public val Path.head: PathToken? get() = tokens.firstOrNull()
+
+
+/**
+ * Returns non-empty optional containing the chain without first segment in case of chain path.
+ *
+ * @return
+ */
+public val Path.tail: Path? get() = if (tokens.isEmpty()) null else Path(tokens.drop(1))
+
+
+public operator fun Path.plus(path: Path): Path = Path(this.tokens + path.tokens)
+
+public data class PathToken(val name: Name, val target: String? = null) {
+    override fun toString(): String = if (target == null) {
+        name.toString()
+    } else {
+        "$target$TARGET_SEPARATOR$name"
+    }
+
+    public companion object {
+        public const val TARGET_SEPARATOR: String = "::"
+
+        public fun parse(token: String, cache: Boolean = false): PathToken {
+            val target = token.substringBefore(TARGET_SEPARATOR, "")
+            val name = token.substringAfter(TARGET_SEPARATOR).parseAsName(cache)
+            if (target.contains("[")) TODO("target separators in queries are not supported")
+            return PathToken(name, target)
+        }
+    }
+}
+
+/**
+ * Represent this path token as full path
+ */
+public fun PathToken.asPath(): Path = Path(listOf(this))
+
+/**
+ * Represent a name with optional [target] as a [Path]
+ */
+public fun Name.asPath(target: String? = null): Path = PathToken(this, target).asPath()
+
+/**
+ * Build a path from given names using default targets
+ */
+public fun Path(vararg names: Name): Path = Path(names.map { PathToken(it) })
+
+/**
+ * Use an array of [Name]-target pairs to construct segmented [Path]
+ */
+public fun Path(vararg tokens: Pair<Name, String?>): Path = Path(tokens.map { PathToken(it.first, it.second) })

dataforge-context/src/commonMain/kotlin/space/kscience/dataforge/provider/Provider.kt

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2015 Alexander Nozik.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package space.kscience.dataforge.provider
+
+import space.kscience.dataforge.names.Name
+import kotlin.reflect.KClass
+import kotlin.reflect.safeCast
+
+/**
+ * A marker utility interface for providers.
+ *
+ * @author Alexander Nozik
+ */
+public interface Provider {
+
+    /**
+     * Default target for this provider
+     */
+    public val defaultTarget: String get() = ""
+
+    /**
+     * Default target for next chain segment
+     */
+    public val defaultChainTarget: String get() = ""
+
+    /**
+     * A map of direct children for specific target
+     */
+    public fun content(target: String): Map<Name, Any> = emptyMap()
+}
+
+public fun Provider.provide(path: Path, targetOverride: String? = null): Any? {
+    if (path.length == 0) throw IllegalArgumentException("Can't provide by empty path")
+    val first = path.first()
+    val target = targetOverride ?: first.target ?: defaultTarget
+    val res = content(target)[first.name] ?: return null
+    return when (path.length) {
+        1 -> res
+        else -> {
+            when (res) {
+                is Provider -> res.provide(path.tail!!, targetOverride = defaultChainTarget)
+                else -> throw IllegalStateException("Chain path not supported: child is not a provider")
+            }
+        }
+    }
+}
+
+/**
+ * Type checked provide
+ */
+public inline fun <reified T : Any> Provider.provide(path: String, targetOverride: String? = null): T? {
+    return provide(Path.parse(path), targetOverride) as? T
+}
+//
+//inline fun <reified T : Any> Provider.provide(target: String, name: Name): T? {
+//    return provide(PathToken(name, target).toPath()) as? T
+//}
+
+//inline fun <reified T : Any> Provider.provide(target: String, name: String): T? =
+//    provide(target, name.toName())
+
+/**
+ *  Typed top level content
+ */
+public fun <T : Any> Provider.top(target: String, type: KClass<out T>): Map<Name, T> = content(target).mapValues {
+    type.safeCast(it.value) ?: error("The type of element ${it.value} is ${it.value::class} but $type is expected")
+}
+
+/**
+ *  Typed top level content
+ */
+public inline fun <reified T : Any> Provider.top(target: String ): Map<Name, T> = top(target, T::class)
+
+

dataforge-context/src/commonTest/kotlin/hep/dataforge/context/ContextTest.kt

@@ -1,40 +0,0 @@
-package hep.dataforge.context
-
-import hep.dataforge.names.Name
-import hep.dataforge.names.appendLeft
-import hep.dataforge.names.toName
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertTrue
-
-
-class ContextTest {
-    class DummyPlugin : AbstractPlugin() {
-        override val tag get() = PluginTag("test")
-
-        override fun provideTop(target: String, name: Name): Any? {
-            return when (target) {
-                "test" -> return name
-                else -> super.provideTop(target, name)
-            }
-        }
-
-        override fun listNames(target: String): Sequence<Name> {
-            return when (target) {
-                "test" -> sequenceOf("a", "b", "c.d").map { it.toName() }
-                else -> super.listNames(target)
-            }
-        }
-    }
-
-    @Test
-    fun testPluginManager() {
-        Global.plugins.load(DummyPlugin())
-        val members = Global.content<Name>("test")
-        assertEquals(3, members.count())
-        members.forEach {
-            assertTrue{it.key == it.value.appendLeft("test")}
-        }
-    }
-
-}

dataforge-context/src/commonTest/kotlin/space/kscience/dataforge/context/ContextTest.kt

@@ -0,0 +1,33 @@
+package space.kscience.dataforge.context
+
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.appendFirst
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+
+class ContextTest {
+    class DummyPlugin : AbstractPlugin() {
+        override val tag get() = PluginTag("test")
+
+        override fun content(target: String): Map<Name, Any> {
+            return when (target) {
+                "test" -> listOf("a", "b", "c.d").associate { Name.parse(it) to Name.parse(it) }
+                else -> emptyMap()
+            }
+        }
+    }
+
+    @Test
+    fun testPluginManager() {
+        val context = Context("test") {
+            plugin(DummyPlugin())
+        }
+        val members = context.gather<Name>("test")
+        assertEquals(3, members.count())
+        members.forEach {
+            assertEquals(it.key, it.value.appendFirst("test"))
+        }
+    }
+
+}

dataforge-context/src/commonTest/kotlin/space/kscience/dataforge/properties/MetaPropertiesTest.kt

@@ -0,0 +1,28 @@
+package space.kscience.dataforge.properties
+
+import space.kscience.dataforge.meta.Scheme
+import space.kscience.dataforge.meta.SchemeSpec
+import space.kscience.dataforge.meta.int
+import space.kscience.dataforge.misc.DFExperimental
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+internal class TestScheme : Scheme() {
+    var a by int()
+    var b by int()
+    companion object : SchemeSpec<TestScheme>(::TestScheme)
+}
+
+@DFExperimental
+class MetaPropertiesTest {
+    @Test
+    fun testBinding() {
+        val scheme = TestScheme.empty()
+        val a = scheme.property(TestScheme::a)
+        val b = scheme.property(TestScheme::b)
+        a.bind(b)
+        scheme.a = 2
+        assertEquals(2, scheme.b)
+        assertEquals(2, b.value)
+    }
+}

dataforge-context/src/commonTest/kotlin/space/kscience/dataforge/provider/PathTest.kt

@@ -0,0 +1,14 @@
+package space.kscience.dataforge.provider
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class PathTest {
+    @Test
+    fun testParse(){
+        val nameString = "a.b.c.d"
+        val pathString = "a.b/c.d"
+        assertEquals(1, Path.parse(nameString).length)
+        assertEquals(2, Path.parse(pathString).length)
+    }
+}

dataforge-context/src/jsMain/kotlin/hep/dataforge/context/PluginRepository.kt

@@ -1,16 +0,0 @@
-package hep.dataforge.context
-
-
-actual object PluginRepository {
-
-    private val factories: MutableSet<PluginFactory<*>> = HashSet()
-
-    actual fun register(factory: PluginFactory<*>) {
-        factories.add(factory)
-    }
-
-    /**
-     * List plugins available in the repository
-     */
-    actual fun list(): Sequence<PluginFactory<*>> = factories.asSequence()
-}

dataforge-context/src/jsMain/kotlin/space/kscience/dataforge/context/loggingJs.kt

@@ -0,0 +1,32 @@
+package space.kscience.dataforge.context
+
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.names.Name
+
+public class ConsoleLogManager : AbstractPlugin(), LogManager {
+
+    override fun logger(name: Name): Logger  = Logger { tag, body ->
+        val message: String = body.safe
+        when (tag) {
+            // TODO depends on https://youtrack.jetbrains.com/issue/KT-33595/
+            LogManager.DEBUG -> console.asDynamic().debug("[${context.name}] $name: $message")
+            LogManager.INFO -> console.info("[${context.name}] $name: $message")
+            LogManager.WARNING ->  console.warn("[${context.name}] $name: $message")
+            LogManager.ERROR -> console.error("[${context.name}] $name: $message")
+            else ->  console.log("[${context.name}] $name: $message")
+        }
+    }
+
+    override val defaultLogger: Logger = logger(Name.EMPTY)
+
+
+    override val tag: PluginTag get() = Companion.tag
+
+    public companion object : PluginFactory<ConsoleLogManager> {
+        override fun build(context: Context, meta: Meta): ConsoleLogManager = ConsoleLogManager()
+
+        override val tag: PluginTag = PluginTag(group = PluginTag.DATAFORGE_GROUP, name = "log.jsConsole")
+    }
+}
+
+internal actual fun getGlobalLoggerFactory(): PluginFactory<out LogManager> = ConsoleLogManager

dataforge-context/src/jsMain/kotlin/space/kscience/dataforge/properties/bindings.kt

@@ -0,0 +1,32 @@
+package space.kscience.dataforge.properties
+
+import org.w3c.dom.HTMLInputElement
+import space.kscience.dataforge.misc.DFExperimental
+
+@DFExperimental
+public fun HTMLInputElement.bindValue(property: Property<String>) {
+    if (this.onchange != null) error("Input element already bound")
+    this.onchange = {
+        property.value = this.value
+        Unit
+    }
+    property.onChange(this) {
+        if (value != it) {
+            value = it
+        }
+    }
+}
+
+@DFExperimental
+public fun HTMLInputElement.bindChecked(property: Property<Boolean>) {
+    if (this.onchange != null) error("Input element already bound")
+    this.onchange = {
+        property.value = this.checked
+        Unit
+    }
+    property.onChange(this) {
+        if (checked != it) {
+            checked = it
+        }
+    }
+}

dataforge-context/src/jvmMain/kotlin/hep/dataforge/context/PluginRepository.kt

@@ -1,17 +0,0 @@
-package hep.dataforge.context
-
-actual object PluginRepository {
-
-    private val factories: MutableSet<PluginFactory<*>> = HashSet()
-
-    actual fun register(factory: PluginFactory<*>) {
-        factories.add(factory)
-    }
-
-    /**
-     * List plugins available in the repository
-     */
-    actual fun list(): Sequence<PluginFactory<*>> =
-        factories.asSequence() + Global.services()
-
-}

dataforge-context/src/jvmMain/kotlin/hep/dataforge/provider/Types.kt

@@ -1,46 +0,0 @@
-package hep.dataforge.provider
-
-import hep.dataforge.context.Context
-import hep.dataforge.context.content
-import hep.dataforge.names.Name
-import kotlin.reflect.KClass
-import kotlin.reflect.full.findAnnotation
-
-/**
- *
- */
-object Types {
-    operator fun get(cl: KClass<*>): String {
-        return cl.findAnnotation<Type>()?.id ?: cl.simpleName ?: ""
-    }
-
-    operator fun get(obj: Any): String {
-        return get(obj::class)
-    }
-}
-
-/**
- * Provide an object with given name inferring target from its type using [Type] annotation
- */
-inline fun <reified T : Any> Provider.provideByType(name: String): T? {
-    val target = Types[T::class]
-    return provide(target, name)
-}
-
-inline fun <reified T : Any> Provider.provideByType(name: Name): T? {
-    val target = Types[T::class]
-    return provide(target, name)
-}
-
-inline fun <reified T : Any> Provider.top(): Map<Name, T> {
-    val target = Types[T::class]
-    return listNames(target).associate { name ->
-        name to (provideByType<T>(name) ?: error("The element $name is declared but not provided"))
-    }
-}
-
-/**
- * A sequences of all objects provided by plugins with given target and type
- */
-inline fun <reified T : Any> Context.content(): Map<Name, T> = content<T>(Types[T::class])
-

dataforge-context/src/jvmMain/kotlin/space/kscience/dataforge/context/ClassLoaderPlugin.kt

@@ -13,30 +13,30 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-package hep.dataforge.context
+package space.kscience.dataforge.context
 
 import java.util.*
 import kotlin.reflect.KClass
 import kotlin.reflect.full.cast
 
-class ClassLoaderPlugin(val classLoader: ClassLoader) : AbstractPlugin() {
+public class ClassLoaderPlugin(private val classLoader: ClassLoader) : AbstractPlugin() {
     override val tag: PluginTag = PluginTag("classLoader", PluginTag.DATAFORGE_GROUP)
 
     private val serviceCache: MutableMap<Class<*>, ServiceLoader<*>> = HashMap()
 
-    fun <T : Any> services(type: KClass<T>): Sequence<T> {
+    public fun <T : Any> services(type: KClass<T>): Sequence<T> {
         return serviceCache.getOrPut(type.java) { ServiceLoader.load(type.java, classLoader) }.asSequence()
             .map { type.cast(it) }
     }
 
-    companion object {
-        val DEFAULT = ClassLoaderPlugin(Global::class.java.classLoader)
+    public companion object {
+        public val DEFAULT: ClassLoaderPlugin = ClassLoaderPlugin(Global::class.java.classLoader)
     }
 }
 
-val Context.classLoaderPlugin get() = this.plugins.get() ?: ClassLoaderPlugin.DEFAULT
+public val Context.classLoaderPlugin: ClassLoaderPlugin get() = this.plugins.get() ?: ClassLoaderPlugin.DEFAULT
 
-inline fun <reified T : Any> Context.services() = classLoaderPlugin.services(T::class)
+public inline fun <reified T : Any> Context.services(): Sequence<T> = classLoaderPlugin.services(T::class)
 
 
 //open class JVMContext(

dataforge-context/src/jvmMain/kotlin/space/kscience/dataforge/context/loggingJvm.kt

@@ -0,0 +1,32 @@
+package space.kscience.dataforge.context
+
+import org.slf4j.LoggerFactory
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.names.Name
+
+public class SlfLogManager : AbstractPlugin(), LogManager {
+
+    override fun logger(name: Name): Logger = Logger { tag, body ->
+        val logger = LoggerFactory.getLogger("[${context.name}] $name") //KotlinLogging.logger("[${context.name}] $name")
+        val message = body.safe
+        when (tag) {
+            LogManager.DEBUG -> logger.debug(message)
+            LogManager.INFO -> logger.info(message)
+            LogManager.WARNING -> logger.warn(message)
+            LogManager.ERROR -> logger.error(message)
+            else -> logger.trace(message)
+        }
+    }
+
+    override val defaultLogger: Logger = logger(Name.EMPTY)
+
+    override val tag: PluginTag get() = Companion.tag
+
+    public companion object : PluginFactory<SlfLogManager> {
+        override fun build(context: Context, meta: Meta): SlfLogManager = SlfLogManager()
+
+        override val tag: PluginTag = PluginTag(group = PluginTag.DATAFORGE_GROUP, name = "log.kotlinLogging")
+    }
+}
+
+internal actual fun getGlobalLoggerFactory(): PluginFactory<out LogManager> = SlfLogManager

dataforge-context/src/jvmMain/kotlin/space/kscience/dataforge/descriptors/annotations.kt

@@ -0,0 +1,126 @@
+/*
+ * Copyright  2018 Alexander Nozik.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package space.kscience.dataforge.descriptors
+
+//@MustBeDocumented
+//annotation class Attribute(
+//    val key: String,
+//    val value: String
+//)
+//
+//@MustBeDocumented
+//annotation class Attributes(
+//    val attrs: Array<Attribute>
+//)
+//
+//@MustBeDocumented
+//annotation class ItemDef(
+//    val info: String = "",
+//    val multiple: Boolean = false,
+//    val required: Boolean = false
+//)
+//
+//@Target(AnnotationTarget.PROPERTY)
+//@MustBeDocumented
+//annotation class ValueDef(
+//    val type: Array<ValueType> = [ValueType.STRING],
+//    val def: String = "",
+//    val allowed: Array<String> = [],
+//    val enumeration: KClass<*> = Any::class
+//)
+
+///**
+// * Description text for meta property, node or whole object
+// */
+//@Target(AnnotationTarget.CLASS, AnnotationTarget.PROPERTY)
+//@Retention(AnnotationRetention.RUNTIME)
+//@MustBeDocumented
+//annotation class Description(val value: String)
+//
+///**
+// * Annotation for value property which states that lists are expected
+// */
+//@Target(AnnotationTarget.PROPERTY)
+//@Retention(AnnotationRetention.RUNTIME)
+//@MustBeDocumented
+//annotation class Multiple
+//
+///**
+// * Descriptor target
+// * The DataForge path to the resource containing the description. Following targets are supported:
+// *  1. resource
+// *  1. file
+// *  1. class
+// *  1. method
+// *  1. property
+// *
+// *
+// * Does not work if [type] is provided
+// */
+//@Target(AnnotationTarget.CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.VALUE_PARAMETER)
+//@Retention(AnnotationRetention.RUNTIME)
+//@MustBeDocumented
+//annotation class Descriptor(val value: String)
+//
+//
+///**
+// * Aggregator class for descriptor nodes
+// */
+//@Target(AnnotationTarget.CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.FUNCTION, AnnotationTarget.VALUE_PARAMETER)
+//@Retention(AnnotationRetention.RUNTIME)
+//@MustBeDocumented
+//annotation class DescriptorNodes(vararg val nodes: NodeDef)
+//
+///**
+// * Aggregator class for descriptor values
+// */
+//@Target(AnnotationTarget.CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.FUNCTION, AnnotationTarget.VALUE_PARAMETER)
+//@Retention(AnnotationRetention.RUNTIME)
+//@MustBeDocumented
+//annotation class DescriptorValues(vararg val nodes: ValueDef)
+//
+///**
+// * Alternative name for property descriptor declaration
+// */
+//@Target(AnnotationTarget.PROPERTY, AnnotationTarget.VALUE_PARAMETER)
+//@Retention(AnnotationRetention.RUNTIME)
+//@MustBeDocumented
+//annotation class DescriptorName(val name: String)
+//
+//@Target(AnnotationTarget.PROPERTY)
+//@Retention(AnnotationRetention.RUNTIME)
+//@MustBeDocumented
+//annotation class DescriptorValue(val def: ValueDef)
+////TODO enter fields directly?
+//
+//@Target(AnnotationTarget.PROPERTY)
+//@Retention(AnnotationRetention.RUNTIME)
+//@MustBeDocumented
+//annotation class ValueProperty(
+//    val name: String = "",
+//    val type: Array<ValueType> = arrayOf(ValueType.STRING),
+//    val multiple: Boolean = false,
+//    val def: String = "",
+//    val enumeration: KClass<*> = Any::class,
+//    val tags: Array<String> = emptyArray()
+//)
+//
+//
+//@Target(AnnotationTarget.PROPERTY)
+//@Retention(AnnotationRetention.RUNTIME)
+//@MustBeDocumented
+//annotation class NodeProperty(val name: String = "")

dataforge-context/src/jvmMain/kotlin/space/kscience/dataforge/descriptors/reflectiveDescriptors.kt

@@ -0,0 +1,53 @@
+package space.kscience.dataforge.descriptors
+
+
+//inline fun <reified T : Scheme> T.buildDescriptor(): NodeDescriptor = NodeDescriptor {
+//    T::class.apply {
+//        findAnnotation<ItemDef>()?.let { def ->
+//            info = def.info
+//            required = def.required
+//            multiple = def.multiple
+//        }
+//        findAnnotation<Attribute>()?.let { attr ->
+//            attributes {
+//                this[attr.key] = attr.value.parseValue()
+//            }
+//        }
+//        findAnnotation<Attributes>()?.attrs?.forEach { attr ->
+//            attributes {
+//                this[attr.key] = attr.value.parseValue()
+//            }
+//        }
+//    }
+//    T::class.memberProperties.forEach { property ->
+//        val delegate = property.getDelegate(this@buildDescriptor)
+//
+//        val descriptor: ItemDescriptor = when (delegate) {
+//            is ConfigurableDelegate -> buildPropertyDescriptor(property, delegate)
+//            is ReadWriteDelegateWrapper<*, *> -> {
+//                if (delegate.delegate is ConfigurableDelegate) {
+//                    buildPropertyDescriptor(property, delegate.delegate as ConfigurableDelegate)
+//                } else {
+//                    return@forEach
+//                }
+//            }
+//            else -> return@forEach
+//        }
+//        defineItem(property.name, descriptor)
+//    }
+//}
+
+//inline fun <T : Scheme, reified V : Any?> buildPropertyDescriptor(
+//    property: KProperty1<T, V>,
+//    delegate: ConfigurableDelegate
+//): ItemDescriptor {
+//    when {
+//        V::class.isSubclassOf(Scheme::class) -> NodeDescriptor {
+//            default = delegate.default.node
+//        }
+//        V::class.isSubclassOf(Meta::class) -> NodeDescriptor {
+//            default = delegate.default.node
+//        }
+//
+//    }
+//}

dataforge-context/src/jvmMain/kotlin/space/kscience/dataforge/provider/dfType.kt

@@ -0,0 +1,49 @@
+package space.kscience.dataforge.provider
+
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.context.PluginBuilder
+import space.kscience.dataforge.context.gather
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.misc.DfId
+import space.kscience.dataforge.misc.Named
+import space.kscience.dataforge.names.Name
+import kotlin.reflect.KClass
+import kotlin.reflect.full.findAnnotation
+
+
+@DFExperimental
+public val KClass<*>.dfId: String
+    get() = findAnnotation<DfId>()?.id ?: simpleName ?: ""
+
+/**
+ * Provide an object with given name inferring target from its type using [DfId] annotation
+ */
+@DFExperimental
+public inline fun <reified T : Any> Provider.provideByType(name: String): T? {
+    val target = T::class.dfId
+    return provide(target, name)
+}
+
+@DFExperimental
+public inline fun <reified T : Any> Provider.top(): Map<Name, T> {
+    val target = T::class.dfId
+    return top(target)
+}
+
+/**
+ * All objects provided by plugins with given target and type
+ */
+@DFExperimental
+public inline fun <reified T : Any> Context.gather(inherit: Boolean = true): Map<Name, T> =
+    gather<T>(T::class.dfId, inherit)
+
+
+@DFExperimental
+public inline fun <reified T : Any> PluginBuilder.provides(items: Map<Name, T>) {
+    provides(T::class.dfId, items)
+}
+
+@DFExperimental
+public inline fun <reified T : Any> PluginBuilder.provides(vararg items: Named) {
+    provides(T::class.dfId, *items)
+}

dataforge-context/src/nativeMain/kotlin/space/kscience/dataforge/context/loggingNative.kt

@@ -0,0 +1,4 @@
+package space.kscience.dataforge.context
+
+
+internal actual fun getGlobalLoggerFactory(): PluginFactory<out LogManager> = DefaultLogManager

dataforge-data/README.md

@@ -0,0 +1,23 @@
+# Module dataforge-data
+
+
+
+## Usage
+
+## Artifact:
+
+The Maven coordinates of this project are `space.kscience:dataforge-data:0.7.0`.
+
+**Gradle Kotlin DSL:**
+```kotlin
+repositories {
+    maven("https://repo.kotlin.link")
+    //uncomment to access development builds
+    //maven("https://maven.pkg.jetbrains.space/spc/p/sci/dev")
+    mavenCentral()
+}
+
+dependencies {
+    implementation("space.kscience:dataforge-data:0.7.0")
+}
+```

dataforge-data/api/dataforge-data.api

@@ -0,0 +1,391 @@
+public abstract interface class hep/dataforge/data/Action {
+	public abstract fun invoke (Lhep/dataforge/data/DataNode;Lhep/dataforge/meta/Meta;)Lhep/dataforge/data/DataNode;
+	public abstract fun isTerminal ()Z
+}
+
+public final class hep/dataforge/data/Action$DefaultImpls {
+	public static fun isTerminal (Lhep/dataforge/data/Action;)Z
+}
+
+public final class hep/dataforge/data/ActionEnv {
+	public fun <init> (Lhep/dataforge/names/Name;Lhep/dataforge/meta/Meta;Lhep/dataforge/meta/Meta;)V
+	public final fun component1 ()Lhep/dataforge/names/Name;
+	public final fun component2 ()Lhep/dataforge/meta/Meta;
+	public final fun component3 ()Lhep/dataforge/meta/Meta;
+	public final fun copy (Lhep/dataforge/names/Name;Lhep/dataforge/meta/Meta;Lhep/dataforge/meta/Meta;)Lhep/dataforge/data/ActionEnv;
+	public static synthetic fun copy$default (Lhep/dataforge/data/ActionEnv;Lhep/dataforge/names/Name;Lhep/dataforge/meta/Meta;Lhep/dataforge/meta/Meta;ILjava/lang/Object;)Lhep/dataforge/data/ActionEnv;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getActionMeta ()Lhep/dataforge/meta/Meta;
+	public final fun getMeta ()Lhep/dataforge/meta/Meta;
+	public final fun getName ()Lhep/dataforge/names/Name;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class hep/dataforge/data/ActionKt {
+	public static final fun then (Lhep/dataforge/data/Action;Lhep/dataforge/data/Action;)Lhep/dataforge/data/Action;
+}
+
+public final class hep/dataforge/data/ComputationData : hep/dataforge/data/ComputationGoal, hep/dataforge/data/Data {
+	public fun <init> (Lkotlin/reflect/KClass;Lhep/dataforge/meta/Meta;Lkotlin/coroutines/CoroutineContext;Ljava/util/Collection;Lkotlin/jvm/functions/Function2;)V
+	public synthetic fun <init> (Lkotlin/reflect/KClass;Lhep/dataforge/meta/Meta;Lkotlin/coroutines/CoroutineContext;Ljava/util/Collection;Lkotlin/jvm/functions/Function2;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun getMeta ()Lhep/dataforge/meta/Meta;
+	public fun getType ()Lkotlin/reflect/KClass;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+}
+
+public class hep/dataforge/data/ComputationGoal : hep/dataforge/data/Goal {
+	public fun <init> (Lkotlin/coroutines/CoroutineContext;Ljava/util/Collection;Lkotlin/jvm/functions/Function2;)V
+	public synthetic fun <init> (Lkotlin/coroutines/CoroutineContext;Ljava/util/Collection;Lkotlin/jvm/functions/Function2;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun getBlock ()Lkotlin/jvm/functions/Function2;
+	public fun getDependencies ()Ljava/util/Collection;
+	public final fun getResult ()Lkotlinx/coroutines/Deferred;
+	public fun reset ()V
+	public fun startAsync (Lkotlinx/coroutines/CoroutineScope;)Lkotlinx/coroutines/Deferred;
+}
+
+public final class hep/dataforge/data/CoroutineMonitor : kotlin/coroutines/CoroutineContext$Element {
+	public static final field Companion Lhep/dataforge/data/CoroutineMonitor$Companion;
+	public fun <init> ()V
+	public final fun finish ()V
+	public fun fold (Ljava/lang/Object;Lkotlin/jvm/functions/Function2;)Ljava/lang/Object;
+	public fun get (Lkotlin/coroutines/CoroutineContext$Key;)Lkotlin/coroutines/CoroutineContext$Element;
+	public fun getKey ()Lkotlin/coroutines/CoroutineContext$Key;
+	public final fun getStatus ()Ljava/lang/String;
+	public final fun getTotalWork ()D
+	public final fun getWorkDone ()D
+	public fun minusKey (Lkotlin/coroutines/CoroutineContext$Key;)Lkotlin/coroutines/CoroutineContext;
+	public fun plus (Lkotlin/coroutines/CoroutineContext;)Lkotlin/coroutines/CoroutineContext;
+	public final fun setStatus (Ljava/lang/String;)V
+	public final fun setTotalWork (D)V
+	public final fun setWorkDone (D)V
+	public final fun start ()V
+}
+
+public final class hep/dataforge/data/CoroutineMonitor$Companion : kotlin/coroutines/CoroutineContext$Key {
+}
+
+public final class hep/dataforge/data/CoroutineMonitorKt {
+	public static final fun getDependencies (Lkotlinx/coroutines/Job;)Ljava/util/Collection;
+	public static final fun getMonitor (Lkotlin/coroutines/CoroutineContext;)Lhep/dataforge/data/CoroutineMonitor;
+	public static final fun getMonitor (Lkotlinx/coroutines/CoroutineScope;)Lhep/dataforge/data/CoroutineMonitor;
+	public static final fun getProgress (Lkotlinx/coroutines/Job;)D
+	public static final fun getStatus (Lkotlinx/coroutines/Job;)Ljava/lang/String;
+	public static final fun getTotalWork (Lkotlinx/coroutines/Job;)D
+	public static final fun getWorkDone (Lkotlinx/coroutines/Job;)D
+}
+
+public abstract interface class hep/dataforge/data/Data : hep/dataforge/data/Goal, hep/dataforge/meta/MetaRepr {
+	public static final field Companion Lhep/dataforge/data/Data$Companion;
+	public static final field TYPE Ljava/lang/String;
+	public abstract fun getMeta ()Lhep/dataforge/meta/Meta;
+	public abstract fun getType ()Lkotlin/reflect/KClass;
+	public abstract fun toMeta ()Lhep/dataforge/meta/Meta;
+}
+
+public final class hep/dataforge/data/Data$Companion {
+	public static final field TYPE Ljava/lang/String;
+	public final fun invoke (Ljava/lang/String;Lkotlin/reflect/KClass;Lhep/dataforge/meta/Meta;Lkotlin/coroutines/CoroutineContext;Ljava/util/Collection;Lkotlin/jvm/functions/Function2;)Lhep/dataforge/data/Data;
+	public final fun invoke (Lkotlin/reflect/KClass;Lhep/dataforge/meta/Meta;Lkotlin/coroutines/CoroutineContext;Ljava/util/Collection;Lkotlin/jvm/functions/Function2;)Lhep/dataforge/data/Data;
+	public static synthetic fun invoke$default (Lhep/dataforge/data/Data$Companion;Ljava/lang/String;Lkotlin/reflect/KClass;Lhep/dataforge/meta/Meta;Lkotlin/coroutines/CoroutineContext;Ljava/util/Collection;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lhep/dataforge/data/Data;
+	public static synthetic fun invoke$default (Lhep/dataforge/data/Data$Companion;Lkotlin/reflect/KClass;Lhep/dataforge/meta/Meta;Lkotlin/coroutines/CoroutineContext;Ljava/util/Collection;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lhep/dataforge/data/Data;
+	public final fun static (Ljava/lang/Object;Lhep/dataforge/meta/Meta;)Lhep/dataforge/data/Data;
+	public static synthetic fun static$default (Lhep/dataforge/data/Data$Companion;Ljava/lang/Object;Lhep/dataforge/meta/Meta;ILjava/lang/Object;)Lhep/dataforge/data/Data;
+}
+
+public final class hep/dataforge/data/Data$DefaultImpls {
+	public static fun toMeta (Lhep/dataforge/data/Data;)Lhep/dataforge/meta/Meta;
+}
+
+public final class hep/dataforge/data/DataFilter : hep/dataforge/meta/Scheme {
+	public static final field Companion Lhep/dataforge/data/DataFilter$Companion;
+	public fun <init> ()V
+	public final fun getFrom ()Ljava/lang/String;
+	public final fun getPattern ()Ljava/lang/String;
+	public final fun getTo ()Ljava/lang/String;
+	public final fun setFrom (Ljava/lang/String;)V
+	public final fun setPattern (Ljava/lang/String;)V
+	public final fun setTo (Ljava/lang/String;)V
+}
+
+public final class hep/dataforge/data/DataFilter$Companion : hep/dataforge/meta/SchemeSpec {
+}
+
+public final class hep/dataforge/data/DataFilterKt {
+	public static final fun filter (Lhep/dataforge/data/DataNode;Lhep/dataforge/data/DataFilter;)Lhep/dataforge/data/DataNode;
+	public static final fun filter (Lhep/dataforge/data/DataNode;Lhep/dataforge/meta/Meta;)Lhep/dataforge/data/DataNode;
+	public static final fun filter (Lhep/dataforge/data/DataNode;Lkotlin/jvm/functions/Function1;)Lhep/dataforge/data/DataNode;
+}
+
+public abstract class hep/dataforge/data/DataItem : hep/dataforge/meta/MetaRepr {
+	public abstract fun getMeta ()Lhep/dataforge/meta/Meta;
+	public abstract fun getType ()Lkotlin/reflect/KClass;
+}
+
+public final class hep/dataforge/data/DataItem$Leaf : hep/dataforge/data/DataItem {
+	public fun <init> (Lhep/dataforge/data/Data;)V
+	public final fun getData ()Lhep/dataforge/data/Data;
+	public fun getMeta ()Lhep/dataforge/meta/Meta;
+	public fun getType ()Lkotlin/reflect/KClass;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+}
+
+public final class hep/dataforge/data/DataItem$Node : hep/dataforge/data/DataItem {
+	public fun <init> (Lhep/dataforge/data/DataNode;)V
+	public fun getMeta ()Lhep/dataforge/meta/Meta;
+	public final fun getNode ()Lhep/dataforge/data/DataNode;
+	public fun getType ()Lkotlin/reflect/KClass;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+}
+
+public final class hep/dataforge/data/DataJVMKt {
+	public static final fun canCast (Lhep/dataforge/data/DataItem;Lkotlin/reflect/KClass;)Z
+	public static final fun cast (Lhep/dataforge/data/Data;Lkotlin/reflect/KClass;)Lhep/dataforge/data/Data;
+	public static final fun cast (Lhep/dataforge/data/DataNode;Lkotlin/reflect/KClass;)Lhep/dataforge/data/DataNode;
+	public static final fun ensureType (Lhep/dataforge/data/DataNode;Lkotlin/reflect/KClass;)V
+	public static final fun filterIsInstance (Lhep/dataforge/data/Data;Lkotlin/reflect/KClass;)Lhep/dataforge/data/Data;
+	public static final fun filterIsInstance (Lhep/dataforge/data/DataItem;Lkotlin/reflect/KClass;)Lhep/dataforge/data/DataItem;
+	public static final fun filterIsInstance (Lhep/dataforge/data/DataNode;Lkotlin/reflect/KClass;)Lhep/dataforge/data/DataNode;
+	public static final fun get (Lhep/dataforge/data/Data;)Ljava/lang/Object;
+	public static final fun upcast (Lhep/dataforge/data/Data;Lkotlin/reflect/KClass;)Lhep/dataforge/data/Data;
+}
+
+public final class hep/dataforge/data/DataKt {
+	public static final fun map (Lhep/dataforge/data/Data;Lkotlin/reflect/KClass;Lkotlin/coroutines/CoroutineContext;Lhep/dataforge/meta/Meta;Lkotlin/jvm/functions/Function3;)Lhep/dataforge/data/Data;
+	public static synthetic fun map$default (Lhep/dataforge/data/Data;Lkotlin/reflect/KClass;Lkotlin/coroutines/CoroutineContext;Lhep/dataforge/meta/Meta;Lkotlin/jvm/functions/Function3;ILjava/lang/Object;)Lhep/dataforge/data/Data;
+	public static final fun reduce (Ljava/util/Map;Lkotlin/reflect/KClass;Lkotlin/coroutines/CoroutineContext;Lhep/dataforge/meta/Meta;Lkotlin/jvm/functions/Function3;)Lhep/dataforge/data/ComputationData;
+	public static synthetic fun reduce$default (Ljava/util/Map;Lkotlin/reflect/KClass;Lkotlin/coroutines/CoroutineContext;Lhep/dataforge/meta/Meta;Lkotlin/jvm/functions/Function3;ILjava/lang/Object;)Lhep/dataforge/data/ComputationData;
+}
+
+public abstract interface class hep/dataforge/data/DataNode : hep/dataforge/meta/MetaRepr {
+	public static final field Companion Lhep/dataforge/data/DataNode$Companion;
+	public static final field TYPE Ljava/lang/String;
+	public abstract fun getItems ()Ljava/util/Map;
+	public abstract fun getMeta ()Lhep/dataforge/meta/Meta;
+	public abstract fun getType ()Lkotlin/reflect/KClass;
+	public abstract fun toMeta ()Lhep/dataforge/meta/Meta;
+}
+
+public final class hep/dataforge/data/DataNode$Companion {
+	public static final field TYPE Ljava/lang/String;
+	public final fun builder (Lkotlin/reflect/KClass;)Lhep/dataforge/data/DataTreeBuilder;
+}
+
+public final class hep/dataforge/data/DataNode$DefaultImpls {
+	public static fun toMeta (Lhep/dataforge/data/DataNode;)Lhep/dataforge/meta/Meta;
+}
+
+public final class hep/dataforge/data/DataNodeKt {
+	public static final fun dataSequence (Lhep/dataforge/data/DataNode;)Lkotlin/sequences/Sequence;
+	public static final fun filter (Lhep/dataforge/data/DataNode;Lkotlin/jvm/functions/Function2;)Lhep/dataforge/data/DataNode;
+	public static final fun first (Lhep/dataforge/data/DataNode;)Lhep/dataforge/data/Data;
+	public static final fun get (Lhep/dataforge/data/DataNode;Lhep/dataforge/names/Name;)Lhep/dataforge/data/DataItem;
+	public static final fun get (Lhep/dataforge/data/DataNode;Ljava/lang/String;)Lhep/dataforge/data/DataItem;
+	public static final fun getData (Lhep/dataforge/data/DataItem;)Lhep/dataforge/data/Data;
+	public static final fun getNode (Lhep/dataforge/data/DataItem;)Lhep/dataforge/data/DataNode;
+	public static final fun itemSequence (Lhep/dataforge/data/DataNode;)Lkotlin/sequences/Sequence;
+	public static final fun iterator (Lhep/dataforge/data/DataNode;)Ljava/util/Iterator;
+	public static final fun join (Lhep/dataforge/data/DataNode;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
+	public static final fun startAll (Lhep/dataforge/data/DataNode;Lkotlinx/coroutines/CoroutineScope;)Lkotlinx/coroutines/Job;
+}
+
+public final class hep/dataforge/data/DataTree : hep/dataforge/data/DataNode {
+	public fun getItems ()Ljava/util/Map;
+	public fun getMeta ()Lhep/dataforge/meta/Meta;
+	public fun getType ()Lkotlin/reflect/KClass;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+}
+
+public final class hep/dataforge/data/DataTreeBuilder {
+	public fun <init> (Lkotlin/reflect/KClass;)V
+	public final fun build ()Lhep/dataforge/data/DataTree;
+	public final fun getType ()Lkotlin/reflect/KClass;
+	public final fun meta (Lhep/dataforge/meta/Meta;)V
+	public final fun meta (Lkotlin/jvm/functions/Function1;)Lhep/dataforge/meta/MetaBuilder;
+	public final fun put (Ljava/lang/String;Lhep/dataforge/data/Data;)V
+	public final fun put (Ljava/lang/String;Lhep/dataforge/data/DataItem;)V
+	public final fun put (Ljava/lang/String;Lhep/dataforge/data/DataNode;)V
+	public final fun put (Ljava/lang/String;Lkotlin/jvm/functions/Function1;)V
+	public final fun set (Lhep/dataforge/names/Name;Lhep/dataforge/data/Data;)V
+	public final fun set (Lhep/dataforge/names/Name;Lhep/dataforge/data/DataItem;)V
+	public final fun set (Lhep/dataforge/names/Name;Lhep/dataforge/data/DataNode;)V
+	public final fun set (Lhep/dataforge/names/Name;Lhep/dataforge/data/DataTreeBuilder;)V
+	public final fun set (Lhep/dataforge/names/NameToken;Lhep/dataforge/data/Data;)V
+	public final fun set (Lhep/dataforge/names/NameToken;Lhep/dataforge/data/DataTreeBuilder;)V
+	public final fun update (Lhep/dataforge/data/DataNode;)V
+}
+
+public final class hep/dataforge/data/DataTreeBuilderKt {
+	public static final fun DataTree (Lkotlin/reflect/KClass;Lkotlin/jvm/functions/Function1;)Lhep/dataforge/data/DataTree;
+	public static final fun builder (Lhep/dataforge/data/DataNode;)Lhep/dataforge/data/DataTreeBuilder;
+	public static final fun datum (Lhep/dataforge/data/DataTreeBuilder;Lhep/dataforge/names/Name;Lhep/dataforge/data/Data;)V
+	public static final fun datum (Lhep/dataforge/data/DataTreeBuilder;Ljava/lang/String;Lhep/dataforge/data/Data;)V
+	public static final fun node (Lhep/dataforge/data/DataTreeBuilder;Lhep/dataforge/names/Name;Lhep/dataforge/data/DataNode;)V
+	public static final fun node (Lhep/dataforge/data/DataTreeBuilder;Ljava/lang/String;Lhep/dataforge/data/DataNode;)V
+	public static final fun static (Lhep/dataforge/data/DataTreeBuilder;Lhep/dataforge/names/Name;Ljava/lang/Object;Lhep/dataforge/meta/Meta;)V
+	public static final fun static (Lhep/dataforge/data/DataTreeBuilder;Lhep/dataforge/names/Name;Ljava/lang/Object;Lkotlin/jvm/functions/Function1;)V
+	public static final fun static (Lhep/dataforge/data/DataTreeBuilder;Ljava/lang/String;Ljava/lang/Object;Lkotlin/jvm/functions/Function1;)V
+	public static synthetic fun static$default (Lhep/dataforge/data/DataTreeBuilder;Lhep/dataforge/names/Name;Ljava/lang/Object;Lhep/dataforge/meta/Meta;ILjava/lang/Object;)V
+	public static synthetic fun static$default (Lhep/dataforge/data/DataTreeBuilder;Lhep/dataforge/names/Name;Ljava/lang/Object;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V
+	public static synthetic fun static$default (Lhep/dataforge/data/DataTreeBuilder;Ljava/lang/String;Ljava/lang/Object;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V
+}
+
+public final class hep/dataforge/data/Dependencies : kotlin/coroutines/CoroutineContext$Element {
+	public static final field Companion Lhep/dataforge/data/Dependencies$Companion;
+	public fun <init> (Ljava/util/Collection;)V
+	public fun fold (Ljava/lang/Object;Lkotlin/jvm/functions/Function2;)Ljava/lang/Object;
+	public fun get (Lkotlin/coroutines/CoroutineContext$Key;)Lkotlin/coroutines/CoroutineContext$Element;
+	public fun getKey ()Lkotlin/coroutines/CoroutineContext$Key;
+	public final fun getValues ()Ljava/util/Collection;
+	public fun minusKey (Lkotlin/coroutines/CoroutineContext$Key;)Lkotlin/coroutines/CoroutineContext;
+	public fun plus (Lkotlin/coroutines/CoroutineContext;)Lkotlin/coroutines/CoroutineContext;
+}
+
+public final class hep/dataforge/data/Dependencies$Companion : kotlin/coroutines/CoroutineContext$Key {
+}
+
+public final class hep/dataforge/data/FragmentRule {
+	public field result Lkotlin/jvm/functions/Function2;
+	public fun <init> (Lhep/dataforge/names/Name;Lhep/dataforge/meta/MetaBuilder;)V
+	public final fun getMeta ()Lhep/dataforge/meta/MetaBuilder;
+	public final fun getName ()Lhep/dataforge/names/Name;
+	public final fun getResult ()Lkotlin/jvm/functions/Function2;
+	public final fun result (Lkotlin/jvm/functions/Function2;)V
+	public final fun setMeta (Lhep/dataforge/meta/MetaBuilder;)V
+	public final fun setResult (Lkotlin/jvm/functions/Function2;)V
+}
+
+public abstract interface class hep/dataforge/data/Goal {
+	public static final field Companion Lhep/dataforge/data/Goal$Companion;
+	public abstract fun getDependencies ()Ljava/util/Collection;
+	public abstract fun getResult ()Lkotlinx/coroutines/Deferred;
+	public abstract fun reset ()V
+	public abstract fun startAsync (Lkotlinx/coroutines/CoroutineScope;)Lkotlinx/coroutines/Deferred;
+}
+
+public final class hep/dataforge/data/Goal$Companion {
+}
+
+public final class hep/dataforge/data/GoalKt {
+	public static final fun await (Lhep/dataforge/data/Goal;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
+	public static final fun isComplete (Lhep/dataforge/data/Goal;)Z
+	public static final fun map (Lhep/dataforge/data/Goal;Lkotlin/coroutines/CoroutineContext;Lkotlin/jvm/functions/Function3;)Lhep/dataforge/data/Goal;
+	public static synthetic fun map$default (Lhep/dataforge/data/Goal;Lkotlin/coroutines/CoroutineContext;Lkotlin/jvm/functions/Function3;ILjava/lang/Object;)Lhep/dataforge/data/Goal;
+	public static final fun reduce (Ljava/util/Collection;Lkotlin/coroutines/CoroutineContext;Lkotlin/jvm/functions/Function3;)Lhep/dataforge/data/Goal;
+	public static final fun reduce (Ljava/util/Map;Lkotlin/coroutines/CoroutineContext;Lkotlin/jvm/functions/Function3;)Lhep/dataforge/data/Goal;
+	public static synthetic fun reduce$default (Ljava/util/Collection;Lkotlin/coroutines/CoroutineContext;Lkotlin/jvm/functions/Function3;ILjava/lang/Object;)Lhep/dataforge/data/Goal;
+	public static synthetic fun reduce$default (Ljava/util/Map;Lkotlin/coroutines/CoroutineContext;Lkotlin/jvm/functions/Function3;ILjava/lang/Object;)Lhep/dataforge/data/Goal;
+}
+
+public abstract interface class hep/dataforge/data/GroupRule {
+	public static final field Companion Lhep/dataforge/data/GroupRule$Companion;
+	public abstract fun invoke (Lhep/dataforge/data/DataNode;)Ljava/util/Map;
+}
+
+public final class hep/dataforge/data/GroupRule$Companion {
+	public final fun byMeta (Lhep/dataforge/meta/Meta;)Lhep/dataforge/data/GroupRule;
+	public final fun byValue (Ljava/lang/String;Ljava/lang/String;)Lhep/dataforge/data/GroupRule;
+}
+
+public final class hep/dataforge/data/JoinGroup {
+	public field result Lkotlin/jvm/functions/Function3;
+	public fun <init> (Ljava/lang/String;Lhep/dataforge/data/DataNode;)V
+	public final fun getMeta ()Lhep/dataforge/meta/MetaBuilder;
+	public final fun getName ()Ljava/lang/String;
+	public final fun getResult ()Lkotlin/jvm/functions/Function3;
+	public final fun result (Lkotlin/jvm/functions/Function3;)V
+	public final fun setMeta (Lhep/dataforge/meta/MetaBuilder;)V
+	public final fun setName (Ljava/lang/String;)V
+	public final fun setResult (Lkotlin/jvm/functions/Function3;)V
+}
+
+public final class hep/dataforge/data/MapAction : hep/dataforge/data/Action {
+	public fun <init> (Lkotlin/reflect/KClass;Lkotlin/jvm/functions/Function1;)V
+	public fun invoke (Lhep/dataforge/data/DataNode;Lhep/dataforge/meta/Meta;)Lhep/dataforge/data/DataNode;
+	public fun isTerminal ()Z
+}
+
+public final class hep/dataforge/data/MapActionBuilder {
+	public field result Lkotlin/jvm/functions/Function3;
+	public fun <init> (Lhep/dataforge/names/Name;Lhep/dataforge/meta/MetaBuilder;Lhep/dataforge/meta/Meta;)V
+	public final fun getActionMeta ()Lhep/dataforge/meta/Meta;
+	public final fun getMeta ()Lhep/dataforge/meta/MetaBuilder;
+	public final fun getName ()Lhep/dataforge/names/Name;
+	public final fun getResult ()Lkotlin/jvm/functions/Function3;
+	public final fun result (Lkotlin/jvm/functions/Function3;)V
+	public final fun setMeta (Lhep/dataforge/meta/MetaBuilder;)V
+	public final fun setName (Lhep/dataforge/names/Name;)V
+	public final fun setResult (Lkotlin/jvm/functions/Function3;)V
+}
+
+public final class hep/dataforge/data/NamedData : hep/dataforge/data/Data {
+	public fun <init> (Ljava/lang/String;Lhep/dataforge/data/Data;)V
+	public fun getDependencies ()Ljava/util/Collection;
+	public fun getMeta ()Lhep/dataforge/meta/Meta;
+	public final fun getName ()Ljava/lang/String;
+	public fun getResult ()Lkotlinx/coroutines/Deferred;
+	public fun getType ()Lkotlin/reflect/KClass;
+	public fun reset ()V
+	public fun startAsync (Lkotlinx/coroutines/CoroutineScope;)Lkotlinx/coroutines/Deferred;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+}
+
+public final class hep/dataforge/data/ReduceAction : hep/dataforge/data/Action {
+	public fun <init> (Lkotlin/reflect/KClass;Lkotlin/jvm/functions/Function1;)V
+	public fun invoke (Lhep/dataforge/data/DataNode;Lhep/dataforge/meta/Meta;)Lhep/dataforge/data/DataNode;
+	public fun isTerminal ()Z
+}
+
+public final class hep/dataforge/data/ReduceActionKt {
+	public static final fun get (Ljava/util/Map;Ljava/lang/String;)Ljava/lang/Object;
+}
+
+public final class hep/dataforge/data/ReduceGroupBuilder {
+	public fun <init> (Lhep/dataforge/meta/Meta;)V
+	public final fun byValue (Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/functions/Function1;)V
+	public static synthetic fun byValue$default (Lhep/dataforge/data/ReduceGroupBuilder;Ljava/lang/String;Ljava/lang/String;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V
+	public final fun getActionMeta ()Lhep/dataforge/meta/Meta;
+	public final fun group (Ljava/lang/String;Lhep/dataforge/data/DataFilter;Lkotlin/jvm/functions/Function1;)V
+	public final fun group (Ljava/lang/String;Lkotlin/jvm/functions/Function2;Lkotlin/jvm/functions/Function1;)V
+	public final fun result (Ljava/lang/String;Lkotlin/jvm/functions/Function3;)V
+}
+
+public final class hep/dataforge/data/SplitAction : hep/dataforge/data/Action {
+	public fun <init> (Lkotlin/reflect/KClass;Lkotlin/jvm/functions/Function1;)V
+	public fun invoke (Lhep/dataforge/data/DataNode;Lhep/dataforge/meta/Meta;)Lhep/dataforge/data/DataNode;
+	public fun isTerminal ()Z
+}
+
+public final class hep/dataforge/data/SplitBuilder {
+	public fun <init> (Lhep/dataforge/names/Name;Lhep/dataforge/meta/Meta;)V
+	public final fun fragment (Ljava/lang/String;Lkotlin/jvm/functions/Function1;)V
+	public final fun getMeta ()Lhep/dataforge/meta/Meta;
+	public final fun getName ()Lhep/dataforge/names/Name;
+}
+
+public final class hep/dataforge/data/StaticData : hep/dataforge/data/StaticGoal, hep/dataforge/data/Data {
+	public fun <init> (Ljava/lang/Object;Lhep/dataforge/meta/Meta;)V
+	public synthetic fun <init> (Ljava/lang/Object;Lhep/dataforge/meta/Meta;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun getMeta ()Lhep/dataforge/meta/Meta;
+	public fun getType ()Lkotlin/reflect/KClass;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+}
+
+public class hep/dataforge/data/StaticGoal : hep/dataforge/data/Goal {
+	public fun <init> (Ljava/lang/Object;)V
+	public fun getDependencies ()Ljava/util/Collection;
+	public fun getResult ()Lkotlinx/coroutines/Deferred;
+	public final fun getValue ()Ljava/lang/Object;
+	public fun reset ()V
+	public fun startAsync (Lkotlinx/coroutines/CoroutineScope;)Lkotlinx/coroutines/Deferred;
+}
+
+public final class hep/dataforge/data/TypeFilteredDataNode : hep/dataforge/data/DataNode {
+	public fun <init> (Lhep/dataforge/data/DataNode;Lkotlin/reflect/KClass;)V
+	public fun getItems ()Ljava/util/Map;
+	public fun getMeta ()Lhep/dataforge/meta/Meta;
+	public final fun getOrigin ()Lhep/dataforge/data/DataNode;
+	public fun getType ()Lkotlin/reflect/KClass;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+}
+

dataforge-data/build.gradle.kts

@@ -1,31 +1,18 @@
 plugins {
-    `npm-multiplatform`
+    id("space.kscience.gradle.mpp")
 }
 
-val coroutinesVersion: String = Versions.coroutinesVersion
-
-kotlin {
+kscience{
     jvm()
     js()
-    sourceSets {
-        val commonMain by getting{
-            dependencies {
-                api(project(":dataforge-meta"))
-                api(kotlin("reflect"))
-                api("org.jetbrains.kotlinx:kotlinx-coroutines-core-common:$coroutinesVersion")
-            }
-        }
-
-        val jvmMain by getting{
-            dependencies {
-                api("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion")
-            }
-        }
-
-        val jsMain by getting{
-            dependencies {
-                api("org.jetbrains.kotlinx:kotlinx-coroutines-core-js:$coroutinesVersion")
-            }
-        }
+    native()
+    useCoroutines()
+    dependencies {
+        api(project(":dataforge-meta"))
+        api(kotlin("reflect"))
     }
-}
+}
+
+readme{
+    maturity = space.kscience.gradle.Maturity.EXPERIMENTAL
+}

dataforge-data/src/commonMain/kotlin/hep/dataforge/data/Action.kt

@@ -1,52 +0,0 @@
-package hep.dataforge.data
-
-import hep.dataforge.meta.Meta
-import hep.dataforge.names.Name
-
-/**
- * A simple data transformation on a data node
- */
-interface Action<in T : Any, out R : Any> {
-    /**
-     * Transform the data in the node, producing a new node. By default it is assumed that all calculations are lazy
-     * so not actual computation is started at this moment
-     */
-    operator fun invoke(node: DataNode<T>, meta: Meta): DataNode<R>
-
-    /**
-     * Terminal action is the one that could not be invoked lazily and requires some kind of blocking computation to invoke
-     */
-    val isTerminal: Boolean get() = false
-}
-
-/**
- * Action composition. The result is terminal if one of its parts is terminal
- */
-infix fun <T : Any, I : Any, R : Any> Action<T, I>.then(action: Action<I, R>): Action<T, R> {
-    // TODO introduce composite action and add optimize by adding action to the list
-    return object : Action<T, R> {
-        override fun invoke(node: DataNode<T>, meta: Meta): DataNode<R> {
-            return action(this@then.invoke(node, meta), meta)
-        }
-
-        override val isTerminal: Boolean
-            get() = this@then.isTerminal || action.isTerminal
-    }
-}
-
-
-///**
-// * An action that performs the same transformation on each of input data nodes. Null results are ignored.
-// * The transformation is non-suspending because it is lazy.
-// */
-//class PipeAction<in T : Any, out R : Any>(val transform: (Name, Data<T>, Meta) -> Data<R>?) : Action<T, R> {
-//    override fun invoke(node: DataNode<T>, meta: Meta): DataNode<R> = DataNode.build {
-//        node.data().forEach { (name, data) ->
-//            val res = transform(name, data, meta)
-//            if (res != null) {
-//                set(name, res)
-//            }
-//        }
-//    }
-//}
-

dataforge-data/src/commonMain/kotlin/hep/dataforge/data/Data.kt

@@ -1,69 +0,0 @@
-package hep.dataforge.data
-
-import hep.dataforge.meta.Meta
-import hep.dataforge.meta.MetaRepr
-import kotlinx.coroutines.CoroutineScope
-import kotlin.reflect.KClass
-
-/**
- * A data element characterized by its meta
- */
-interface Data<out T : Any> : MetaRepr {
-    /**
-     * Type marker for the data. The type is known before the calculation takes place so it could be checked.
-     */
-    val type: KClass<out T>
-    /**
-     * Meta for the data
-     */
-    val meta: Meta
-
-    /**
-     * Lazy data value
-     */
-    val goal: Goal<T>
-
-    override fun toMeta(): Meta = meta
-
-    companion object {
-        const val TYPE = "data"
-
-        fun <T : Any> of(type: KClass<out T>, goal: Goal<T>, meta: Meta): Data<T> = DataImpl(type, goal, meta)
-
-        inline fun <reified T : Any> of(goal: Goal<T>, meta: Meta): Data<T> = of(T::class, goal, meta)
-
-        fun <T : Any> of(name: String, type: KClass<out T>, goal: Goal<T>, meta: Meta): Data<T> =
-            NamedData(name, of(type, goal, meta))
-
-        inline fun <reified T : Any> of(name: String, goal: Goal<T>, meta: Meta): Data<T> =
-            of(name, T::class, goal, meta)
-
-        fun <T : Any> static(scope: CoroutineScope, value: T, meta: Meta): Data<T> =
-            DataImpl(value::class, Goal.static(scope, value), meta)
-    }
-}
-
-/**
- * Upcast a [Data] to a supertype
- */
-inline fun <reified R : Any, reified T : R> Data<T>.cast(): Data<R> {
-    return Data.of(R::class, goal, meta)
-}
-
-fun <R : Any, T : R> Data<T>.cast(type: KClass<R>): Data<R> {
-    return Data.of(type, goal, meta)
-}
-
-suspend fun <T : Any> Data<T>.await(): T = goal.await()
-
-/**
- * Generic Data implementation
- */
-private class DataImpl<out T : Any>(
-    override val type: KClass<out T>,
-    override val goal: Goal<T>,
-    override val meta: Meta
-) : Data<T>
-
-class NamedData<out T : Any>(val name: String, data: Data<T>) : Data<T> by data
-

dataforge-data/src/commonMain/kotlin/hep/dataforge/data/DataFilter.kt

@@ -1,46 +0,0 @@
-package hep.dataforge.data
-
-import hep.dataforge.meta.*
-import hep.dataforge.names.toName
-
-
-class DataFilter(override val config: Config) : Specific {
-    var from by string()
-    var to by string()
-    var pattern by string("*.")
-//    val prefix by string()
-//    val suffix by string()
-
-    companion object : Specification<DataFilter> {
-        override fun wrap(config: Config): DataFilter = DataFilter(config)
-    }
-}
-
-/**
- * Apply meta-based filter to given data node
- */
-fun <T : Any> DataNode<T>.filter(filter: DataFilter): DataNode<T> {
-    val sourceNode = filter.from?.let { getNode(it.toName()) } ?: this@filter
-    val regex = filter.pattern.toRegex()
-    val targetNode = DataTreeBuilder(type).apply {
-        sourceNode.data().forEach { (name, data) ->
-            if (name.toString().matches(regex)) {
-                this[name] = data
-            }
-        }
-    }
-    return filter.to?.let {
-        DataTreeBuilder(type).apply { this[it.toName()] = targetNode }.build()
-    } ?: targetNode.build()
-}
-
-/**
- * Filter data using [DataFilter] specification
- */
-fun <T : Any> DataNode<T>.filter(filter: Meta): DataNode<T> = filter(DataFilter.wrap(filter))
-
-/**
- * Filter data using [DataFilter] builder
- */
-fun <T : Any> DataNode<T>.filter(filterBuilder: DataFilter.() -> Unit): DataNode<T> =
-    filter(DataFilter.build(filterBuilder))

dataforge-data/src/commonMain/kotlin/hep/dataforge/data/DataNode.kt

@@ -1,216 +0,0 @@
-package hep.dataforge.data
-
-import hep.dataforge.names.*
-import kotlin.reflect.KClass
-
-/**
- * A tree-like data structure grouped into the node. All data inside the node must inherit its type
- */
-interface DataNode<out T : Any> {
-
-    /**
-     * The minimal common ancestor to all data in the node
-     */
-    val type: KClass<out T>
-
-    /**
-     * Get the specific data if it exists
-     */
-    operator fun get(name: Name): Data<T>?
-
-    /**
-     * Get a subnode with given name if it exists.
-     */
-    fun getNode(name: Name): DataNode<T>?
-
-    /**
-     * Walk the tree upside down and provide all data nodes with full names
-     */
-    fun data(): Sequence<Pair<Name, Data<T>>>
-
-    /**
-     * A sequence of all nodes in the tree walking upside down, excluding self
-     */
-    fun nodes(): Sequence<Pair<Name, DataNode<T>>>
-
-    operator fun iterator(): Iterator<Pair<Name, Data<T>>> = data().iterator()
-
-    companion object {
-        const val TYPE = "dataNode"
-
-        fun <T : Any> build(type: KClass<out T>, block: DataTreeBuilder<T>.() -> Unit) =
-            DataTreeBuilder<T>(type).apply(block).build()
-
-        fun <T : Any> builder(type: KClass<out T>) = DataTreeBuilder(type)
-    }
-}
-
-internal sealed class DataTreeItem<out T : Any> {
-    class Node<out T : Any>(val tree: DataTree<T>) : DataTreeItem<T>()
-    class Value<out T : Any>(val value: Data<T>) : DataTreeItem<T>()
-}
-
-class DataTree<out T : Any> internal constructor(
-    override val type: KClass<out T>,
-    private val items: Map<NameToken, DataTreeItem<T>>
-) : DataNode<T> {
-    //TODO add node-level meta?
-
-    override fun get(name: Name): Data<T>? = when (name.length) {
-        0 -> error("Empty name")
-        1 -> (items[name.first()] as? DataTreeItem.Value)?.value
-        else -> getNode(name.first()!!.asName())?.get(name.cutFirst())
-    }
-
-    override fun getNode(name: Name): DataTree<T>? = when (name.length) {
-        0 -> this
-        1 -> (items[name.first()] as? DataTreeItem.Node)?.tree
-        else -> getNode(name.first()!!.asName())?.getNode(name.cutFirst())
-    }
-
-    override fun data(): Sequence<Pair<Name, Data<T>>> {
-        return sequence {
-            items.forEach { (head, tree) ->
-                when (tree) {
-                    is DataTreeItem.Value -> yield(head.asName() to tree.value)
-                    is DataTreeItem.Node -> {
-                        val subSequence =
-                            tree.tree.data().map { (name, data) -> (head.asName() + name) to data }
-                        yieldAll(subSequence)
-                    }
-                }
-            }
-        }
-    }
-
-    override fun nodes(): Sequence<Pair<Name, DataNode<T>>> {
-        return sequence {
-            items.forEach { (head, tree) ->
-                if (tree is DataTreeItem.Node) {
-                    yield(head.asName() to tree.tree)
-                    val subSequence =
-                        tree.tree.nodes().map { (name, node) -> (head.asName() + name) to node }
-                    yieldAll(subSequence)
-                }
-            }
-        }
-    }
-}
-
-private sealed class DataTreeBuilderItem<out T : Any> {
-    class Node<T : Any>(val tree: DataTreeBuilder<T>) : DataTreeBuilderItem<T>()
-    class Value<T : Any>(val value: Data<T>) : DataTreeBuilderItem<T>()
-}
-
-/**
- * A builder for a DataTree.
- */
-class DataTreeBuilder<T : Any>(private val type: KClass<out T>) {
-    private val map = HashMap<NameToken, DataTreeBuilderItem<T>>()
-
-    operator fun set(token: NameToken, node: DataTreeBuilder<T>) {
-        if (map.containsKey(token)) error("Tree entry with name $token is not empty")
-        map[token] = DataTreeBuilderItem.Node(node)
-    }
-
-    operator fun set(token: NameToken, data: Data<T>) {
-        if (map.containsKey(token)) error("Tree entry with name $token is not empty")
-        map[token] = DataTreeBuilderItem.Value(data)
-    }
-
-    private fun buildNode(token: NameToken): DataTreeBuilder<T> {
-        return if (!map.containsKey(token)) {
-            DataTreeBuilder<T>(type).also { map[token] = DataTreeBuilderItem.Node(it) }
-        } else {
-            (map[token] as? DataTreeBuilderItem.Node ?: error("The node with name $token is occupied by leaf")).tree
-        }
-    }
-
-    private fun buildNode(name: Name): DataTreeBuilder<T> {
-        return when (name.length) {
-            0 -> this
-            1 -> buildNode(name.first()!!)
-            else -> buildNode(name.first()!!).buildNode(name.cutFirst())
-        }
-    }
-
-    operator fun set(name: Name, data: Data<T>) {
-        when (name.length) {
-            0 -> error("Can't add data with empty name")
-            1 -> set(name.first()!!, data)
-            2 -> buildNode(name.cutLast())[name.last()!!] = data
-        }
-    }
-
-    operator fun set(name: Name, node: DataTreeBuilder<T>) {
-        when (name.length) {
-            0 -> error("Can't add data with empty name")
-            1 -> set(name.first()!!, node)
-            2 -> buildNode(name.cutLast())[name.last()!!] = node
-        }
-    }
-
-    operator fun set(name: Name, node: DataNode<T>) = set(name, node.builder())
-
-    /**
-     * Append data to node
-     */
-    infix fun String.to(data: Data<T>) = set(toName(), data)
-
-    /**
-     * Append node
-     */
-    infix fun String.to(node: DataNode<T>) = set(toName(), node)
-
-    /**
-     * Build and append node
-     */
-    infix fun String.to(block: DataTreeBuilder<T>.() -> Unit) = set(toName(), DataTreeBuilder<T>(type).apply(block))
-
-
-    fun update(node: DataNode<T>){
-        node.data().forEach {
-            //TODO check if the place is occupied
-            this[it.first] = it.second
-        }
-    }
-
-    fun build(): DataTree<T> {
-        val resMap = map.mapValues { (_, value) ->
-            when (value) {
-                is DataTreeBuilderItem.Value -> DataTreeItem.Value(value.value)
-                is DataTreeBuilderItem.Node -> DataTreeItem.Node(value.tree.build())
-            }
-        }
-        return DataTree(type, resMap)
-    }
-}
-
-/**
- * Generate a mutable builder from this node. Node content is not changed
- */
-fun <T : Any> DataNode<T>.builder(): DataTreeBuilder<T> = DataTreeBuilder(type).apply {
-    data().forEach { (name, data) -> this[name] = data }
-}
-
-/**
- * Start computation for all goals in data node
- */
-fun DataNode<*>.startAll() = data().forEach { (_, data) -> data.goal.start() }
-
-fun <T : Any> DataNode<T>.filter(predicate: (Name, Data<T>) -> Boolean): DataNode<T> = DataNode.build(type) {
-    data().forEach { (name, data) ->
-        if (predicate(name, data)) {
-            this[name] = data
-        }
-    }
-}
-
-fun <T: Any> DataNode<T>.first(): Data<T> = data().first().second
-
-/**
- * Check that node is compatible with given type meaning that each element could be cast to the type
- */
-expect fun DataNode<*>.checkType(type: KClass<*>)
-
-//fun <T : Any, R: T> DataNode<T>.filterIsInstance(type: KClass<R>): DataNode<R> = filter{_,data -> type.}

dataforge-data/src/commonMain/kotlin/hep/dataforge/data/Goal.kt

@@ -1,131 +0,0 @@
-package hep.dataforge.data
-
-import kotlinx.coroutines.*
-import kotlin.coroutines.CoroutineContext
-import kotlin.coroutines.EmptyCoroutineContext
-
-/**
- * A special deferred with explicit dependencies and some additional information like progress and unique id
- */
-interface Goal<out T> : Deferred<T>, CoroutineScope {
-    val scope: CoroutineScope
-    override val coroutineContext get() = scope.coroutineContext
-
-    val dependencies: Collection<Goal<*>>
-
-    val totalWork: Double get() = dependencies.sumByDouble { totalWork } + (monitor?.totalWork ?: 0.0)
-    val workDone: Double get() = dependencies.sumByDouble { workDone } + (monitor?.workDone ?: 0.0)
-    val status: String get() = monitor?.status ?: ""
-    val progress: Double get() = workDone / totalWork
-
-    companion object {
-        /**
-         * Create goal wrapping static value. This goal is always completed
-         */
-        fun <T> static(scope: CoroutineScope, value: T): Goal<T> =
-            StaticGoalImpl(scope, CompletableDeferred(value))
-    }
-}
-
-/**
- * A monitor of goal state that could be accessed only form inside the goal
- */
-class GoalMonitor : CoroutineContext.Element {
-    override val key: CoroutineContext.Key<*> get() = GoalMonitor
-
-    var totalWork: Double = 1.0
-    var workDone: Double = 0.0
-    var status: String = ""
-
-    /**
-     * Mark the goal as started
-     */
-    fun start() {
-
-    }
-
-    /**
-     * Mark the goal as completed
-     */
-    fun finish() {
-        workDone = totalWork
-    }
-
-    companion object : CoroutineContext.Key<GoalMonitor>
-}
-
-val CoroutineScope.monitor: GoalMonitor? get() = coroutineContext[GoalMonitor]
-
-private class GoalImpl<T>(
-    override val scope: CoroutineScope,
-    override val dependencies: Collection<Goal<*>>,
-    deferred: Deferred<T>
-) : Goal<T>, Deferred<T> by deferred
-
-private class StaticGoalImpl<T>(override val scope: CoroutineScope, deferred: CompletableDeferred<T>) : Goal<T>,
-    Deferred<T> by deferred {
-    override val dependencies: Collection<Goal<*>> get() = emptyList()
-    override val status: String get() = ""
-    override val totalWork: Double get() = 0.0
-    override val workDone: Double get() = 0.0
-}
-
-
-/**
- * Create a new [Goal] with given [dependencies] and execution [block]. The block takes monitor as parameter.
- * The goal block runs in a supervised scope, meaning that when it fails, it won't affect external scope.
- *
- * **Important:** Unlike regular deferred, the [Goal] is started lazily, so the actual calculation is called only when result is requested.
- */
-fun <R> CoroutineScope.createGoal(
-    dependencies: Collection<Goal<*>>,
-    context: CoroutineContext = EmptyCoroutineContext,
-    block: suspend CoroutineScope.() -> R
-): Goal<R> {
-    val deferred = async(context + GoalMonitor(), start = CoroutineStart.LAZY) {
-        dependencies.forEach { it.start() }
-        monitor?.start()
-        //Running in supervisor scope in order to allow manual error handling
-        return@async supervisorScope {
-            block().also {
-                monitor?.finish()
-            }
-        }
-    }
-
-    return GoalImpl(this, dependencies, deferred)
-}
-
-/**
- * Create a one-to-one goal based on existing goal
- */
-fun <T, R> Goal<T>.pipe(
-    context: CoroutineContext = EmptyCoroutineContext,
-    block: suspend CoroutineScope.(T) -> R
-): Goal<R> = createGoal(listOf(this), context) { block(await()) }
-
-/**
- * Create a joining goal.
- * @param scope the scope for resulting goal. By default use first goal in list
- */
-fun <T, R> Collection<Goal<T>>.join(
-    scope: CoroutineScope = first(),
-    context: CoroutineContext = EmptyCoroutineContext,
-    block: suspend CoroutineScope.(Collection<T>) -> R
-): Goal<R> = scope.createGoal(this, context) {
-    block(map { it.await() })
-}
-
-/**
- * A joining goal for a map
- * @param K type of the map key
- * @param T type of the input goal
- * @param R type of the result goal
- */
-fun <K, T, R> Map<K, Goal<T>>.join(
-    scope: CoroutineScope = values.first(),
-    context: CoroutineContext = EmptyCoroutineContext,
-    block: suspend CoroutineScope.(Map<K, T>) -> R
-): Goal<R> = scope.createGoal(this.values, context) {
-    block(mapValues { it.value.await() })
-}

dataforge-data/src/commonMain/kotlin/hep/dataforge/data/GroupBuilder.kt

@@ -1,75 +0,0 @@
-/* 
- * Copyright 2015 Alexander Nozik.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package hep.dataforge.data
-
-import hep.dataforge.meta.Meta
-import hep.dataforge.meta.get
-import hep.dataforge.meta.string
-
-interface GroupRule {
-    operator fun <T : Any> invoke(node: DataNode<T>): Map<String, DataNode<T>>
-}
-
-/**
- * The class to builder groups of content with annotation defined rules
- *
- * @author Alexander Nozik
- */
-
-object GroupBuilder {
-
-    /**
-     * Create grouping rule that creates groups for different values of value
-     * field with name [key]
-     *
-     * @param key
-     * @param defaultTagValue
-     * @return
-     */
-    fun byValue(key: String, defaultTagValue: String): GroupRule = object :
-        GroupRule {
-        override fun <T : Any> invoke(node: DataNode<T>): Map<String, DataNode<T>> {
-            val map = HashMap<String, DataTreeBuilder<T>>()
-
-            node.data().forEach { (name, data) ->
-                val tagValue = data.meta[key]?.string ?: defaultTagValue
-                map.getOrPut(tagValue) { DataNode.builder(node.type) }[name] = data
-            }
-
-            return map.mapValues { it.value.build() }
-        }
-    }
-
-
-    //    @ValueDef(key = "byValue", required = true, info = "The name of annotation value by which grouping should be made")
-//    @ValueDef(
-//        key = "defaultValue",
-//        def = "default",
-//        info = "Default value which should be used for content in which the grouping value is not presented"
-//    )
-    fun byMeta(config: Meta): GroupRule {
-        //TODO expand grouping options
-        return config["byValue"]?.string?.let {
-            byValue(
-                it,
-                config["defaultValue"]?.string ?: "default"
-            )
-        }
-            ?: object : GroupRule {
-                override fun <T : Any> invoke(node: DataNode<T>): Map<String, DataNode<T>> = mapOf("" to node)
-            }
-    }
-}

dataforge-data/src/commonMain/kotlin/hep/dataforge/data/JoinAction.kt

@@ -1,111 +0,0 @@
-package hep.dataforge.data
-
-import hep.dataforge.meta.Laminate
-import hep.dataforge.meta.Meta
-import hep.dataforge.meta.MetaBuilder
-import hep.dataforge.meta.builder
-import hep.dataforge.names.Name
-import hep.dataforge.names.toName
-import kotlin.coroutines.CoroutineContext
-import kotlin.coroutines.EmptyCoroutineContext
-import kotlin.reflect.KClass
-
-
-class JoinGroup<T : Any, R : Any>(var name: String, internal val node: DataNode<T>) {
-
-    var meta: MetaBuilder = MetaBuilder()
-
-    lateinit var result: suspend ActionEnv.(Map<Name, T>) -> R
-
-    fun result(f: suspend ActionEnv.(Map<Name, T>) -> R) {
-        this.result = f;
-    }
-
-}
-
-class JoinGroupBuilder<T : Any, R : Any>(val actionMeta: Meta) {
-    private val groupRules: MutableList<(DataNode<T>) -> List<JoinGroup<T, R>>> = ArrayList();
-
-    /**
-     * introduce grouping by value name
-     */
-    fun byValue(tag: String, defaultTag: String = "@default", action: JoinGroup<T, R>.() -> Unit) {
-        groupRules += { node ->
-            GroupBuilder.byValue(tag, defaultTag).invoke(node).map {
-                JoinGroup<T, R>(it.key, it.value).apply(action)
-            }
-        }
-    }
-
-    /**
-     * Add a single fixed group to grouping rules
-     */
-    fun group(groupName: String, filter: DataFilter, action: JoinGroup<T, R>.() -> Unit) {
-        groupRules += { node ->
-            listOf(
-                JoinGroup<T, R>(groupName, node.filter(filter)).apply(action)
-            )
-        }
-    }
-
-    fun group(groupName: String, filter: (Name, Data<T>) -> Boolean, action: JoinGroup<T, R>.() -> Unit) {
-        groupRules += { node ->
-            listOf(
-                JoinGroup<T, R>(groupName, node.filter(filter)).apply(action)
-            )
-        }
-    }
-
-    /**
-     * Apply transformation to the whole node
-     */
-    fun result(resultName: String, f: suspend ActionEnv.(Map<Name, T>) -> R) {
-        groupRules += { node ->
-            listOf(JoinGroup<T, R>(resultName, node).apply { result(f) })
-        }
-    }
-
-    internal fun buildGroups(input: DataNode<T>): List<JoinGroup<T, R>> {
-        return groupRules.flatMap { it.invoke(input) }
-    }
-
-}
-
-
-/**
- * The same rules as for KPipe
- */
-class JoinAction<T : Any, R : Any>(
-    val inputType: KClass<T>,
-    val outputType: KClass<R>,
-    val context: CoroutineContext = EmptyCoroutineContext,
-    private val action: JoinGroupBuilder<T, R>.() -> Unit
-) : Action<T, R> {
-
-    override fun invoke(node: DataNode<T>, meta: Meta): DataNode<R> {
-        node.checkType(inputType)
-        return DataNode.build(outputType) {
-            JoinGroupBuilder<T, R>(meta).apply(action).buildGroups(node).forEach { group ->
-
-                val laminate = Laminate(group.meta, meta)
-
-                val goalMap: Map<Name, Goal<T>> = group.node
-                    .data()
-                    .associate { it.first to it.second.goal }
-
-                val groupName: String = group.name;
-
-                val env = ActionEnv(groupName.toName(), laminate.builder())
-
-                val goal = goalMap.join(context = context) { group.result.invoke(env, it) }
-
-                val res = Data.of(outputType, goal, env.meta)
-
-                set(env.name, res)
-            }
-
-        }
-    }
-}
-
-operator fun <T> Map<Name,T>.get(name:String) = get(name.toName())

dataforge-data/src/commonMain/kotlin/hep/dataforge/data/PipeAction.kt

@@ -1,65 +0,0 @@
-package hep.dataforge.data
-
-import hep.dataforge.meta.*
-import hep.dataforge.names.Name
-import kotlin.coroutines.CoroutineContext
-import kotlin.coroutines.EmptyCoroutineContext
-import kotlin.reflect.KClass
-
-class ActionEnv(val name: Name, val meta: Meta)
-
-
-/**
- * Action environment
- */
-class PipeBuilder<T, R>(var name: Name, var meta: MetaBuilder) {
-    lateinit var result: suspend ActionEnv.(T) -> R
-
-    /**
-     * Calculate the result of goal
-     */
-    fun result(f: suspend ActionEnv.(T) -> R) {
-        result = f;
-    }
-}
-
-
-class PipeAction<T : Any, R : Any>(
-    val inputType: KClass<T>,
-    val outputType: KClass<R>,
-    val context: CoroutineContext = EmptyCoroutineContext,
-    private val block: PipeBuilder<T, R>.() -> Unit
-) : Action<T, R> {
-
-    override fun invoke(node: DataNode<T>, meta: Meta): DataNode<R> {
-        node.checkType(inputType)
-
-        return DataNode.build(outputType) {
-            node.data().forEach { (name, data) ->
-                //merging data meta with action meta (data meta is primary)
-                val oldMeta = meta.builder().apply { update(data.meta) }
-                // creating environment from old meta and name
-                val env = ActionEnv(name, oldMeta)
-                //applying transformation from builder
-                val builder = PipeBuilder<T, R>(name, oldMeta).apply(block)
-                //getting new name
-                val newName = builder.name
-                //getting new meta
-                val newMeta = builder.meta.seal()
-                //creating a goal with custom context if provided
-                val goal = data.goal.pipe(context) { builder.result(env, it) }
-                //setting the data node
-                this[newName] = Data.of(outputType, goal, newMeta)
-            }
-        }
-    }
-}
-
-inline fun <reified T : Any, reified R : Any> DataNode<T>.pipe(
-    meta: Meta,
-    context: CoroutineContext = EmptyCoroutineContext,
-    noinline action: PipeBuilder<T, R>.() -> Unit
-): DataNode<R> = PipeAction(T::class, R::class, context, action).invoke(this, meta)
-
-
-

dataforge-data/src/commonMain/kotlin/hep/dataforge/data/SplitAction.kt

@@ -1,69 +0,0 @@
-package hep.dataforge.data
-
-import hep.dataforge.meta.Laminate
-import hep.dataforge.meta.Meta
-import hep.dataforge.meta.MetaBuilder
-import hep.dataforge.meta.builder
-import hep.dataforge.names.Name
-import hep.dataforge.names.toName
-import kotlin.collections.set
-import kotlin.coroutines.CoroutineContext
-import kotlin.coroutines.EmptyCoroutineContext
-import kotlin.reflect.KClass
-
-
-class FragmentRule<T : Any, R : Any>(val name: Name, var meta: MetaBuilder) {
-    lateinit var result: suspend (T) -> R
-
-    fun result(f: suspend (T) -> R) {
-        result = f;
-    }
-}
-
-
-class SplitBuilder<T : Any, R : Any>(val name: Name, val meta: Meta) {
-    internal val fragments: MutableMap<Name, FragmentRule<T, R>.() -> Unit> = HashMap()
-
-    /**
-     * Add new fragment building rule. If the framgent not defined, result won't be available even if it is present in the map
-     * @param name the name of a fragment
-     * @param rule the rule to transform fragment name and meta using
-     */
-    fun fragment(name: String, rule: FragmentRule<T, R>.() -> Unit) {
-        fragments[name.toName()] = rule
-    }
-}
-
-class SplitAction<T : Any, R : Any>(
-    val inputType: KClass<T>,
-    val outputType: KClass<R>,
-    val context: CoroutineContext = EmptyCoroutineContext,
-    private val action: SplitBuilder<T, R>.() -> Unit
-) : Action<T, R> {
-
-    override fun invoke(node: DataNode<T>, meta: Meta): DataNode<R> {
-        node.checkType(inputType)
-
-        return DataNode.build(outputType) {
-            node.data().forEach { (name, data) ->
-
-                val laminate = Laminate(data.meta, meta)
-
-                val split = SplitBuilder<T, R>(name, data.meta).apply(action)
-
-
-                // apply individual fragment rules to result
-                split.fragments.forEach { (fragmentName, rule) ->
-                    val env = FragmentRule<T, R>(fragmentName, laminate.builder())
-
-                    rule(env)
-
-                    val goal = data.goal.pipe(context = context) { env.result(it) }
-
-                    val res = Data.of(outputType, goal, env.meta)
-                    set(env.name, res)
-                }
-            }
-        }
-    }
-}

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/actions/AbstractAction.kt

@@ -0,0 +1,65 @@
+package space.kscience.dataforge.actions
+
+import kotlinx.coroutines.launch
+import space.kscience.dataforge.data.*
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.misc.DFInternal
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.startsWith
+import kotlin.reflect.KType
+
+/**
+ * Remove all values with keys starting with [name]
+ */
+internal fun MutableMap<Name, *>.removeWhatStartsWith(name: Name) {
+    val toRemove = keys.filter { it.startsWith(name) }
+    toRemove.forEach(::remove)
+}
+
+/**
+ * An action that caches results on-demand and recalculates them on source push
+ */
+public abstract class AbstractAction<in T : Any, R : Any>(
+    public val outputType: KType,
+) : Action<T, R> {
+
+    /**
+     * Generate initial content of the output
+     */
+    protected abstract fun DataSetBuilder<R>.generate(
+        data: DataSet<T>,
+        meta: Meta,
+    )
+
+    /**
+     * Update part of the data set when given [updateKey] is triggered by the source
+     */
+    protected open fun DataSourceBuilder<R>.update(
+        dataSet: DataSet<T>,
+        meta: Meta,
+        updateKey: Name,
+    ) {
+        // By default, recalculate the whole dataset
+        generate(dataSet, meta)
+    }
+
+    @OptIn(DFInternal::class)
+    override fun execute(
+        dataSet: DataSet<T>,
+        meta: Meta,
+    ): DataSet<R> = if (dataSet is DataSource) {
+        DataSource(outputType, dataSet){
+            generate(dataSet, meta)
+
+            launch {
+                dataSet.updates.collect { name ->
+                    update(dataSet, meta, name)
+                }
+            }
+        }
+    } else {
+        DataTree<R>(outputType) {
+            generate(dataSet, meta)
+        }
+    }
+}

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/actions/Action.kt

@@ -0,0 +1,40 @@
+package space.kscience.dataforge.actions
+
+import space.kscience.dataforge.data.DataSet
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.misc.DFExperimental
+
+/**
+ * A simple data transformation on a data node. Actions should avoid doing actual dependency evaluation in [execute].
+ */
+public interface Action<in T : Any, out R : Any> {
+
+    /**
+     * Transform the data in the node, producing a new node. By default, it is assumed that all calculations are lazy
+     * so not actual computation is started at this moment.
+     */
+    public fun execute(dataSet: DataSet<T>, meta: Meta = Meta.EMPTY): DataSet<R>
+
+    public companion object
+}
+
+/**
+ * Action composition. The result is terminal if one of its parts is terminal
+ */
+public infix fun <T : Any, I : Any, R : Any> Action<T, I>.then(action: Action<I, R>): Action<T, R> {
+    // TODO introduce composite action and add optimize by adding action to the list
+    return object : Action<T, R> {
+
+        override fun execute(
+            dataSet: DataSet<T>,
+            meta: Meta,
+        ): DataSet<R> = action.execute(this@then.execute(dataSet, meta), meta)
+    }
+}
+
+@DFExperimental
+public operator fun <T : Any, R : Any> Action<T, R>.invoke(
+    dataSet: DataSet<T>,
+    meta: Meta = Meta.EMPTY,
+): DataSet<R> = execute(dataSet, meta)
+

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/actions/MapAction.kt

@@ -0,0 +1,106 @@
+package space.kscience.dataforge.actions
+
+import space.kscience.dataforge.data.*
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MutableMeta
+import space.kscience.dataforge.meta.seal
+import space.kscience.dataforge.meta.toMutableMeta
+import space.kscience.dataforge.misc.DFBuilder
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.misc.DFInternal
+import space.kscience.dataforge.names.Name
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+/**
+ * Action environment includes data name, data meta and action configuration meta
+ */
+public data class ActionEnv(
+    val name: Name,
+    val meta: Meta,
+    val actionMeta: Meta,
+)
+
+/**
+ * Action environment
+ */
+@DFBuilder
+public class MapActionBuilder<T, R>(
+    public var name: Name,
+    public var meta: MutableMeta,
+    public val actionMeta: Meta,
+    @PublishedApi internal var outputType: KType,
+) {
+
+    public lateinit var result: suspend ActionEnv.(T) -> R
+
+    /**
+     * Set unsafe [outputType] for the resulting data. Be sure that it is correct.
+     */
+    public fun <R1 : R> result(outputType: KType, f: suspend ActionEnv.(T) -> R1) {
+        this.outputType = outputType
+        result = f;
+    }
+
+    /**
+     * Calculate the result of goal
+     */
+    public inline fun <reified R1 : R> result(noinline f: suspend ActionEnv.(T) -> R1) {
+        outputType = typeOf<R1>()
+        result = f;
+    }
+}
+
+@PublishedApi
+internal class MapAction<in T : Any, R : Any>(
+    outputType: KType,
+    private val block: MapActionBuilder<T, R>.() -> Unit,
+) : AbstractAction<T, R>(outputType) {
+
+    private fun DataSetBuilder<R>.mapOne(name: Name, data: Data<T>, meta: Meta) {
+        // Creating a new environment for action using **old** name, old meta and task meta
+        val env = ActionEnv(name, data.meta, meta)
+
+        //applying transformation from builder
+        val builder = MapActionBuilder<T, R>(
+            name,
+            data.meta.toMutableMeta(), // using data meta
+            meta,
+            outputType
+        ).apply(block)
+
+        //getting new name
+        val newName = builder.name
+
+        //getting new meta
+        val newMeta = builder.meta.seal()
+
+        @OptIn(DFInternal::class)
+        val newData = Data(builder.outputType, newMeta, dependencies = listOf(data)) {
+            builder.result(env, data.await())
+        }
+        //setting the data node
+        data(newName, newData)
+    }
+
+    override fun DataSetBuilder<R>.generate(data: DataSet<T>, meta: Meta) {
+        data.forEach { mapOne(it.name, it.data, meta) }
+    }
+
+    override fun DataSourceBuilder<R>.update(dataSet: DataSet<T>, meta: Meta, updateKey: Name) {
+        remove(updateKey)
+        dataSet[updateKey]?.let { mapOne(updateKey, it, meta) }
+    }
+}
+
+
+/**
+ * A one-to-one mapping action
+ */
+@DFExperimental
+@Suppress("FunctionName")
+public inline fun <T : Any, reified R : Any> Action.Companion.map(
+    noinline builder: MapActionBuilder<T, R>.() -> Unit,
+): Action<T, R> = MapAction(typeOf<R>(), builder)
+
+

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/actions/ReduceAction.kt

@@ -0,0 +1,117 @@
+package space.kscience.dataforge.actions
+
+import space.kscience.dataforge.data.*
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MutableMeta
+import space.kscience.dataforge.misc.DFBuilder
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.misc.DFInternal
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.parseAsName
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+
+public class JoinGroup<T : Any, R : Any>(
+    public var name: String,
+    internal val set: DataSet<T>,
+    @PublishedApi internal var outputType: KType,
+) {
+
+    public var meta: MutableMeta = MutableMeta()
+
+    public lateinit var result: suspend ActionEnv.(Map<Name, ValueWithMeta<T>>) -> R
+
+    internal fun <R1 : R> result(outputType: KType, f: suspend ActionEnv.(Map<Name,  ValueWithMeta<T>>) -> R1) {
+        this.outputType = outputType
+        this.result = f;
+    }
+
+    public inline fun <reified R1 : R> result(noinline f: suspend ActionEnv.(Map<Name,  ValueWithMeta<T>>) -> R1) {
+        outputType = typeOf<R1>()
+        this.result = f;
+    }
+
+}
+
+@DFBuilder
+public class ReduceGroupBuilder<T : Any, R : Any>(
+    public val actionMeta: Meta,
+    private val outputType: KType,
+) {
+    private val groupRules: MutableList<(DataSet<T>) -> List<JoinGroup<T, R>>> = ArrayList();
+
+    /**
+     * introduce grouping by meta value
+     */
+    public fun byValue(tag: String, defaultTag: String = "@default", action: JoinGroup<T, R>.() -> Unit) {
+        groupRules += { node ->
+            GroupRule.byMetaValue(tag, defaultTag).gather(node).map {
+                JoinGroup<T, R>(it.key, it.value, outputType).apply(action)
+            }
+        }
+    }
+
+    public fun group(
+        groupName: String,
+        predicate: (Name, Meta) -> Boolean,
+        action: JoinGroup<T, R>.() -> Unit,
+    ) {
+        groupRules += { source ->
+            listOf(
+                JoinGroup<T, R>(groupName, source.filter(predicate), outputType).apply(action)
+            )
+        }
+    }
+
+    /**
+     * Apply transformation to the whole node
+     */
+    public fun result(resultName: String, f: suspend ActionEnv.(Map<Name,  ValueWithMeta<T>>) -> R) {
+        groupRules += { node ->
+            listOf(JoinGroup<T, R>(resultName, node, outputType).apply { result(outputType, f) })
+        }
+    }
+
+    internal fun buildGroups(input: DataSet<T>): List<JoinGroup<T, R>> =
+        groupRules.flatMap { it.invoke(input) }
+
+}
+
+@PublishedApi
+internal class ReduceAction<T : Any, R : Any>(
+    outputType: KType,
+    private val action: ReduceGroupBuilder<T, R>.() -> Unit,
+) : AbstractAction<T, R>(outputType) {
+    //TODO optimize reduction. Currently, the whole action recalculates on push
+
+    override fun DataSetBuilder<R>.generate(data: DataSet<T>, meta: Meta) {
+        ReduceGroupBuilder<T, R>(meta, outputType).apply(action).buildGroups(data).forEach { group ->
+            val dataFlow: Map<Name, Data<T>> = group.set.asSequence().fold(HashMap()) { acc, value ->
+                acc.apply {
+                    acc[value.name] = value.data
+                }
+            }
+
+            val groupName: String = group.name
+
+            val groupMeta = group.meta
+
+            val env = ActionEnv(groupName.parseAsName(), groupMeta, meta)
+            @OptIn(DFInternal::class) val res: Data<R> = dataFlow.reduceToData(
+                group.outputType,
+                meta = groupMeta
+            ) { group.result.invoke(env, it) }
+
+            data(env.name, res)
+        }
+    }
+}
+
+/**
+ * A one-to-one mapping action
+ */
+@DFExperimental
+public inline fun <reified T : Any, reified R : Any> Action.Companion.reduce(
+    noinline builder: ReduceGroupBuilder<T, R>.() -> Unit,
+): Action<T, R> = ReduceAction(typeOf<R>(), builder)

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/actions/SplitAction.kt

@@ -0,0 +1,92 @@
+package space.kscience.dataforge.actions
+
+import space.kscience.dataforge.data.*
+import space.kscience.dataforge.meta.Laminate
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MutableMeta
+import space.kscience.dataforge.meta.toMutableMeta
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.parseAsName
+import kotlin.collections.set
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+
+public class SplitBuilder<T : Any, R : Any>(public val name: Name, public val meta: Meta) {
+
+    public class FragmentRule<T : Any, R : Any>(
+        public val name: Name,
+        public var meta: MutableMeta,
+        @PublishedApi internal var outputType: KType,
+    ) {
+        public lateinit var result: suspend (T) -> R
+
+        public inline fun <reified R1 : R> result(noinline f: suspend (T) -> R1) {
+            this.outputType = typeOf<R1>()
+            result = f;
+        }
+    }
+
+    internal val fragments: MutableMap<Name, FragmentRule<T, R>.() -> Unit> = HashMap()
+
+    /**
+     * Add new fragment building rule. If the framgent not defined, result won't be available even if it is present in the map
+     * @param name the name of a fragment
+     * @param rule the rule to transform fragment name and meta using
+     */
+    public fun fragment(name: String, rule: FragmentRule<T, R>.() -> Unit) {
+        fragments[name.parseAsName()] = rule
+    }
+}
+
+/**
+ * Action that splits each incoming element into a number of fragments defined in builder
+ */
+@PublishedApi
+internal class SplitAction<T : Any, R : Any>(
+    outputType: KType,
+    private val action: SplitBuilder<T, R>.() -> Unit,
+) : AbstractAction<T, R>(outputType) {
+
+    private fun DataSetBuilder<R>.splitOne(name: Name, data: Data<T>, meta: Meta) {
+        val laminate = Laminate(data.meta, meta)
+
+        val split = SplitBuilder<T, R>(name, data.meta).apply(action)
+
+
+        // apply individual fragment rules to result
+        split.fragments.forEach { (fragmentName, rule) ->
+            val env = SplitBuilder.FragmentRule<T, R>(
+                fragmentName,
+                laminate.toMutableMeta(),
+                outputType
+            ).apply(rule)
+            //data.map<R>(outputType, meta = env.meta) { env.result(it) }.named(fragmentName)
+
+            data(
+                fragmentName,
+                @Suppress("OPT_IN_USAGE") Data(outputType, meta = env.meta, dependencies = listOf(data)) {
+                    env.result(data.await())
+                }
+            )
+        }
+    }
+
+    override fun DataSetBuilder<R>.generate(data: DataSet<T>, meta: Meta) {
+        data.forEach { splitOne(it.name, it.data, meta) }
+    }
+
+    override fun DataSourceBuilder<R>.update(dataSet: DataSet<T>, meta: Meta, updateKey: Name) {
+        remove(updateKey)
+        dataSet[updateKey]?.let { splitOne(updateKey, it, meta) }
+    }
+}
+
+/**
+ * Action that splits each incoming element into a number of fragments defined in builder
+ */
+@DFExperimental
+public inline fun <T : Any, reified R : Any> Action.Companion.split(
+    noinline builder: SplitBuilder<T, R>.() -> Unit,
+): Action<T, R> = SplitAction(typeOf<R>(), builder)

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/CoroutineMonitor.kt

@@ -0,0 +1,57 @@
+package space.kscience.dataforge.data
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import space.kscience.dataforge.misc.DFExperimental
+import kotlin.coroutines.CoroutineContext
+
+
+/**
+ * A monitor of goal state that could be accessed only form inside the goal
+ */
+@DFExperimental
+public class CoroutineMonitor : CoroutineContext.Element {
+    override val key: CoroutineContext.Key<*> get() = CoroutineMonitor
+
+    public var totalWork: Double = 1.0
+    public var workDone: Double = 0.0
+    public var status: String = ""
+
+    /**
+     * Mark the goal as started
+     */
+    public fun start() {
+
+    }
+
+    /**
+     * Mark the goal as completed
+     */
+    public fun finish() {
+        workDone = totalWork
+    }
+
+    public companion object : CoroutineContext.Key<CoroutineMonitor>
+}
+
+public class Dependencies(public val values: Collection<Job>) : CoroutineContext.Element {
+    override val key: CoroutineContext.Key<*> get() = Dependencies
+
+    public companion object : CoroutineContext.Key<Dependencies>
+}
+
+@DFExperimental
+public val CoroutineContext.monitor: CoroutineMonitor? get() = this[CoroutineMonitor]
+@DFExperimental
+public val CoroutineScope.monitor: CoroutineMonitor? get() = coroutineContext.monitor
+
+public val Job.dependencies: Collection<Job> get() = this[Dependencies]?.values ?: emptyList()
+
+@DFExperimental
+public val Job.totalWork: Double get() = dependencies.sumOf { totalWork } + (monitor?.totalWork ?: 0.0)
+@DFExperimental
+public val Job.workDone: Double get() = dependencies.sumOf { workDone } + (monitor?.workDone ?: 0.0)
+@DFExperimental
+public val Job.status: String get() = monitor?.status ?: ""
+@DFExperimental
+public val Job.progress: Double get() = workDone / totalWork

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/Data.kt

@@ -0,0 +1,107 @@
+package space.kscience.dataforge.data
+
+import kotlinx.coroutines.*
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MetaRepr
+import space.kscience.dataforge.meta.isEmpty
+import space.kscience.dataforge.misc.DFInternal
+import space.kscience.dataforge.misc.DfId
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.EmptyCoroutineContext
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+/**
+ * A data element characterized by its meta
+ */
+@DfId(Data.TYPE)
+public interface Data<out T> : Goal<T>, MetaRepr {
+    /**
+     * Type marker for the data. The type is known before the calculation takes place so it could be checked.
+     */
+    public val type: KType
+
+    /**
+     * Meta for the data
+     */
+    public val meta: Meta
+
+    override fun toMeta(): Meta = Meta {
+        "type" put (type.toString())
+        if (!meta.isEmpty()) {
+            "meta" put meta
+        }
+    }
+
+    public companion object {
+        public const val TYPE: String = "data"
+
+        /**
+         * The type that can't have any subtypes
+         */
+        internal val TYPE_OF_NOTHING: KType = typeOf<Unit>()
+
+        public inline fun <reified T : Any> static(
+            value: T,
+            meta: Meta = Meta.EMPTY,
+        ): Data<T> = StaticData(typeOf<T>(), value, meta)
+
+        /**
+         * An empty data containing only meta
+         */
+        @OptIn(DelicateCoroutinesApi::class)
+        public fun empty(meta: Meta): Data<Nothing> = object : Data<Nothing> {
+            override val type: KType = TYPE_OF_NOTHING
+            override val meta: Meta = meta
+            override val dependencies: Collection<Goal<*>> = emptyList()
+            override val deferred: Deferred<Nothing>
+                get() = GlobalScope.async(start = CoroutineStart.LAZY) {
+                    error("The Data is empty and could not be computed")
+                }
+
+            override fun async(coroutineScope: CoroutineScope): Deferred<Nothing> = deferred
+            override fun reset() {}
+        }
+    }
+}
+
+/**
+ * A lazily computed variant of [Data] based on [LazyGoal]
+ * One must ensure that proper [type] is used so this method should not be used
+ */
+private class LazyData<T : Any>(
+    override val type: KType,
+    override val meta: Meta = Meta.EMPTY,
+    additionalContext: CoroutineContext = EmptyCoroutineContext,
+    dependencies: Collection<Goal<*>> = emptyList(),
+    block: suspend () -> T,
+) : Data<T>, LazyGoal<T>(additionalContext, dependencies, block)
+
+public class StaticData<T : Any>(
+    override val type: KType,
+    value: T,
+    override val meta: Meta = Meta.EMPTY,
+) : Data<T>, StaticGoal<T>(value)
+
+@Suppress("FunctionName")
+public inline fun <reified T : Any> Data(value: T, meta: Meta = Meta.EMPTY): StaticData<T> =
+    StaticData(typeOf<T>(), value, meta)
+
+@Suppress("FunctionName")
+@DFInternal
+public fun <T : Any> Data(
+    type: KType,
+    meta: Meta = Meta.EMPTY,
+    context: CoroutineContext = EmptyCoroutineContext,
+    dependencies: Collection<Goal<*>> = emptyList(),
+    block: suspend () -> T,
+): Data<T> = LazyData(type, meta, context, dependencies, block)
+
+@OptIn(DFInternal::class)
+@Suppress("FunctionName")
+public inline fun <reified T : Any> Data(
+    meta: Meta = Meta.EMPTY,
+    context: CoroutineContext = EmptyCoroutineContext,
+    dependencies: Collection<Goal<*>> = emptyList(),
+    noinline block: suspend () -> T,
+): Data<T> = Data(typeOf<T>(), meta, context, dependencies, block)

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/DataSet.kt

@@ -0,0 +1,124 @@
+package space.kscience.dataforge.data
+
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.flow.mapNotNull
+import space.kscience.dataforge.data.Data.Companion.TYPE_OF_NOTHING
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.asName
+import space.kscience.dataforge.names.endsWith
+import space.kscience.dataforge.names.parseAsName
+import kotlin.reflect.KType
+
+public interface DataSet<out T : Any> {
+
+    /**
+     * The minimal common ancestor to all data in the node
+     */
+    public val dataType: KType
+
+    /**
+     * Meta-data associated with this node. If no meta is provided, returns [Meta.EMPTY].
+     */
+    public val meta: Meta
+
+    /**
+     * Traverse this [DataSet] returning named data instances. The order is not guaranteed.
+     */
+    public operator fun iterator(): Iterator<NamedData<T>>
+
+    /**
+     * Get data with given name.
+     */
+    public operator fun get(name: Name): Data<T>?
+
+    public companion object {
+        public val META_KEY: Name = "@meta".asName()
+
+        /**
+         * An empty [DataSet] that suits all types
+         */
+        public val EMPTY: DataSet<Nothing> = object : DataSet<Nothing> {
+            override val dataType: KType = TYPE_OF_NOTHING
+            override val meta: Meta get() = Meta.EMPTY
+
+            override fun iterator(): Iterator<NamedData<Nothing>> = emptySequence<NamedData<Nothing>>().iterator()
+
+            override fun get(name: Name): Data<Nothing>? = null
+        }
+    }
+}
+
+public fun <T : Any> DataSet<T>.asSequence(): Sequence<NamedData<T>> = object : Sequence<NamedData<T>> {
+    override fun iterator(): Iterator<NamedData<T>> = this@asSequence.iterator()
+}
+
+/**
+ * Return a single [Data] in this [DataSet]. Throw error if it is not single.
+ */
+public fun <T : Any> DataSet<T>.single(): NamedData<T> = asSequence().single()
+
+public fun <T : Any> DataSet<T>.asIterable(): Iterable<NamedData<T>> = object : Iterable<NamedData<T>> {
+    override fun iterator(): Iterator<NamedData<T>> = this@asIterable.iterator()
+}
+
+public operator fun <T : Any> DataSet<T>.get(name: String): Data<T>? = get(name.parseAsName())
+
+/**
+ * A [DataSet] with propagated updates.
+ */
+public interface DataSource<out T : Any> : DataSet<T>, CoroutineScope {
+
+    /**
+     * A flow of updated item names. Updates are propagated in a form of [Flow] of names of updated nodes.
+     * Those can include new data items and replacement of existing ones. The replaced items could update existing data content
+     * and replace it completely, so they should be pulled again.
+     *
+     */
+    public val updates: Flow<Name>
+
+    /**
+     * Stop generating updates from this [DataSource]
+     */
+    public fun close() {
+        coroutineContext[Job]?.cancel()
+    }
+}
+
+public val <T : Any> DataSet<T>.updates: Flow<Name> get() = if (this is DataSource) updates else emptyFlow()
+//
+///**
+// * Flow all data nodes with names starting with [branchName]
+// */
+//public fun <T : Any> DataSet<T>.children(branchName: Name): Sequence<NamedData<T>> =
+//    this@children.asSequence().filter {
+//        it.name.startsWith(branchName)
+//    }
+
+/**
+ * Start computation for all goals in data node and return a job for the whole node
+ */
+public fun <T : Any> DataSet<T>.startAll(coroutineScope: CoroutineScope): Job = coroutineScope.launch {
+    asIterable().map {
+        it.launch(this@launch)
+    }.joinAll()
+}
+
+public suspend fun <T : Any> DataSet<T>.computeAndJoinAll(): Unit = coroutineScope { startAll(this).join() }
+
+public fun DataSet<*>.toMeta(): Meta = Meta {
+    forEach {
+        if (it.name.endsWith(DataSet.META_KEY)) {
+            set(it.name, it.meta)
+        } else {
+            it.name put {
+                "type" put it.type.toString()
+                "meta" put it.meta
+            }
+        }
+    }
+}
+
+public val <T : Any> DataSet<T>.updatesWithData: Flow<NamedData<T>> get() = updates.mapNotNull { get(it)?.named(it) }

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/DataSetBuilder.kt

@@ -0,0 +1,165 @@
+package space.kscience.dataforge.data
+
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MutableMeta
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.isEmpty
+import space.kscience.dataforge.names.plus
+import kotlin.reflect.KType
+
+public interface DataSetBuilder<in T : Any> {
+    public val dataType: KType
+
+    /**
+     * Remove all data items starting with [name]
+     */
+    public fun remove(name: Name)
+
+    public fun data(name: Name, data: Data<T>?)
+
+    /**
+     * Set a current state of given [dataSet] into a branch [name]. Does not propagate updates
+     */
+    public fun node(name: Name, dataSet: DataSet<T>) {
+        //remove previous items
+        if (name != Name.EMPTY) {
+            remove(name)
+        }
+
+        //Set new items
+        dataSet.forEach {
+            data(name + it.name, it.data)
+        }
+    }
+
+    /**
+     * Set meta for the given node
+     */
+    public fun meta(name: Name, meta: Meta)
+
+}
+
+/**
+ * Define meta in this [DataSet]
+ */
+public fun <T : Any> DataSetBuilder<T>.meta(value: Meta): Unit = meta(Name.EMPTY, value)
+
+/**
+ * Define meta in this [DataSet]
+ */
+public fun <T : Any> DataSetBuilder<T>.meta(mutableMeta: MutableMeta.() -> Unit): Unit = meta(Meta(mutableMeta))
+
+@PublishedApi
+internal class SubSetBuilder<in T : Any>(
+    private val parent: DataSetBuilder<T>,
+    private val branch: Name,
+) : DataSetBuilder<T> {
+    override val dataType: KType get() = parent.dataType
+
+    override fun remove(name: Name) {
+        parent.remove(branch + name)
+    }
+
+    override fun data(name: Name, data: Data<T>?) {
+        parent.data(branch + name, data)
+    }
+
+    override fun node(name: Name, dataSet: DataSet<T>) {
+        parent.node(branch + name, dataSet)
+    }
+
+    override fun meta(name: Name, meta: Meta) {
+        parent.meta(branch + name, meta)
+    }
+}
+
+public inline fun <T : Any> DataSetBuilder<T>.node(
+    name: Name,
+    crossinline block: DataSetBuilder<T>.() -> Unit,
+) {
+    if (name.isEmpty()) block() else SubSetBuilder(this, name).block()
+}
+
+
+public fun <T : Any> DataSetBuilder<T>.data(name: String, value: Data<T>) {
+    data(Name.parse(name), value)
+}
+
+public fun <T : Any> DataSetBuilder<T>.node(name: String, set: DataSet<T>) {
+    node(Name.parse(name), set)
+}
+
+public inline fun <T : Any> DataSetBuilder<T>.node(
+    name: String,
+    crossinline block: DataSetBuilder<T>.() -> Unit,
+): Unit = node(Name.parse(name), block)
+
+public fun <T : Any> DataSetBuilder<T>.set(value: NamedData<T>) {
+    data(value.name, value.data)
+}
+
+/**
+ * Produce lazy [Data] and emit it into the [DataSetBuilder]
+ */
+public inline fun <reified T : Any> DataSetBuilder<T>.produce(
+    name: String,
+    meta: Meta = Meta.EMPTY,
+    noinline producer: suspend () -> T,
+) {
+    val data = Data(meta, block = producer)
+    data(name, data)
+}
+
+public inline fun <reified T : Any> DataSetBuilder<T>.produce(
+    name: Name,
+    meta: Meta = Meta.EMPTY,
+    noinline producer: suspend () -> T,
+) {
+    val data = Data(meta, block = producer)
+    data(name, data)
+}
+
+/**
+ * Emit a static data with the fixed value
+ */
+public inline fun <reified T : Any> DataSetBuilder<T>.static(
+    name: String,
+    data: T,
+    meta: Meta = Meta.EMPTY,
+): Unit = data(name, Data.static(data, meta))
+
+public inline fun <reified T : Any> DataSetBuilder<T>.static(
+    name: Name,
+    data: T,
+    meta: Meta = Meta.EMPTY,
+): Unit = data(name, Data.static(data, meta))
+
+public inline fun <reified T : Any> DataSetBuilder<T>.static(
+    name: String,
+    data: T,
+    mutableMeta: MutableMeta.() -> Unit,
+): Unit = data(Name.parse(name), Data.static(data, Meta(mutableMeta)))
+
+/**
+ * Update data with given node data and meta with node meta.
+ */
+@DFExperimental
+public fun <T : Any> DataSetBuilder<T>.populateFrom(tree: DataSet<T>): Unit {
+    tree.forEach {
+        //TODO check if the place is occupied
+        data(it.name, it.data)
+    }
+}
+
+//public fun <T : Any> DataSetBuilder<T>.populateFrom(flow: Flow<NamedData<T>>) {
+//    flow.collect {
+//        data(it.name, it.data)
+//    }
+//}
+
+public fun <T : Any> DataSetBuilder<T>.populateFrom(sequence: Sequence<NamedData<T>>) {
+    sequence.forEach {
+        data(it.name, it.data)
+    }
+}

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/DataTree.kt

@@ -0,0 +1,119 @@
+package space.kscience.dataforge.data
+
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.misc.DFInternal
+import space.kscience.dataforge.misc.DfId
+import space.kscience.dataforge.names.*
+import kotlin.collections.component1
+import kotlin.collections.component2
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public sealed class DataTreeItem<out T : Any> {
+
+    public abstract val meta: Meta
+
+    public class Node<out T : Any>(public val tree: DataTree<T>) : DataTreeItem<T>() {
+        override val meta: Meta get() = tree.meta
+    }
+
+    public class Leaf<out T : Any>(public val data: Data<T>) : DataTreeItem<T>() {
+        override val meta: Meta get() = data.meta
+    }
+}
+
+public val <T : Any> DataTreeItem<T>.type: KType
+    get() = when (this) {
+        is DataTreeItem.Node -> tree.dataType
+        is DataTreeItem.Leaf -> data.type
+    }
+
+/**
+ * A tree-like [DataSet] grouped into the node. All data inside the node must inherit its type
+ */
+@DfId(DataTree.TYPE)
+public interface DataTree<out T : Any> : DataSet<T> {
+
+    /**
+     * Top-level children items of this [DataTree]
+     */
+    public val items: Map<NameToken, DataTreeItem<T>>
+
+    override val meta: Meta get() = items[META_ITEM_NAME_TOKEN]?.meta ?: Meta.EMPTY
+
+    override fun iterator(): Iterator<NamedData<T>> = iterator {
+        items.forEach { (token, childItem: DataTreeItem<T>) ->
+            if (!token.body.startsWith("@")) {
+                when (childItem) {
+                    is DataTreeItem.Leaf -> yield(childItem.data.named(token.asName()))
+                    is DataTreeItem.Node -> yieldAll(childItem.tree.asSequence().map { it.named(token + it.name) })
+                }
+            }
+        }
+    }
+
+    override fun get(name: Name): Data<T>? = when (name.length) {
+        0 -> null
+        1 -> items[name.firstOrNull()!!].data
+        else -> items[name.firstOrNull()!!].tree?.get(name.cutFirst())
+    }
+
+    public companion object {
+        public const val TYPE: String = "dataTree"
+
+        /**
+         * A name token used to designate tree node meta
+         */
+        public val META_ITEM_NAME_TOKEN: NameToken = NameToken("@meta")
+
+        @DFInternal
+        public fun <T : Any> emptyWithType(type: KType, meta: Meta = Meta.EMPTY): DataTree<T> = object : DataTree<T> {
+            override val items: Map<NameToken, DataTreeItem<T>> get() = emptyMap()
+            override val dataType: KType get() = type
+            override val meta: Meta get() = meta
+        }
+
+        @OptIn(DFInternal::class)
+        public inline fun <reified T : Any> empty(meta: Meta = Meta.EMPTY): DataTree<T> =
+            emptyWithType<T>(typeOf<T>(), meta)
+    }
+}
+
+public fun <T : Any> DataTree<T>.listChildren(prefix: Name): List<Name> =
+    getItem(prefix).tree?.items?.keys?.map { prefix + it } ?: emptyList()
+
+/**
+ * Get a [DataTreeItem] with given [name] or null if the item does not exist
+ */
+public tailrec fun <T : Any> DataTree<T>.getItem(name: Name): DataTreeItem<T>? = when (name.length) {
+    0 -> DataTreeItem.Node(this)
+    1 -> items[name.firstOrNull()]
+    else -> items[name.firstOrNull()!!].tree?.getItem(name.cutFirst())
+}
+
+public val <T : Any> DataTreeItem<T>?.tree: DataTree<T>? get() = (this as? DataTreeItem.Node<T>)?.tree
+public val <T : Any> DataTreeItem<T>?.data: Data<T>? get() = (this as? DataTreeItem.Leaf<T>)?.data
+
+/**
+ * A [Sequence] of all children including nodes
+ */
+public fun <T : Any> DataTree<T>.traverseItems(): Sequence<Pair<Name, DataTreeItem<T>>> = sequence {
+    items.forEach { (head, item) ->
+        yield(head.asName() to item)
+        if (item is DataTreeItem.Node) {
+            val subSequence = item.tree.traverseItems()
+                .map { (name, data) -> (head.asName() + name) to data }
+            yieldAll(subSequence)
+        }
+    }
+}
+
+/**
+ * Get a branch of this [DataTree] with a given [branchName].
+ * The difference from similar method for [DataSet] is that internal logic is more simple and the return value is a [DataTree]
+ */
+@OptIn(DFInternal::class)
+public fun <T : Any> DataTree<T>.branch(branchName: Name): DataTree<T> =
+    getItem(branchName)?.tree ?: DataTree.emptyWithType(dataType)
+
+public fun <T : Any> DataTree<T>.branch(branchName: String): DataTree<T> = branch(branchName.parseAsName())

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/DataTreeBuilder.kt

@@ -0,0 +1,127 @@
+package space.kscience.dataforge.data
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.launch
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.misc.DFInternal
+import space.kscience.dataforge.misc.ThreadSafe
+import space.kscience.dataforge.names.*
+import kotlin.collections.set
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.coroutineContext
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public interface DataSourceBuilder<T : Any> : DataSetBuilder<T>, DataSource<T> {
+    override val updates: MutableSharedFlow<Name>
+}
+
+/**
+ * A mutable [DataTree] that propagates updates
+ */
+public class DataTreeBuilder<T : Any>(
+    override val dataType: KType,
+    coroutineContext: CoroutineContext,
+) : DataTree<T>, DataSourceBuilder<T> {
+
+    override val coroutineContext: CoroutineContext =
+        coroutineContext + Job(coroutineContext[Job]) + GoalExecutionRestriction()
+
+    private val treeItems = HashMap<NameToken, DataTreeItem<T>>()
+
+    override val items: Map<NameToken, DataTreeItem<T>>
+        get() = treeItems.filter { !it.key.body.startsWith("@") }
+
+    override val updates: MutableSharedFlow<Name> = MutableSharedFlow<Name>()
+
+    @ThreadSafe
+    private fun remove(token: NameToken) {
+        if (treeItems.remove(token) != null) {
+            launch {
+                updates.emit(token.asName())
+            }
+        }
+    }
+
+    override fun remove(name: Name) {
+        if (name.isEmpty()) error("Can't remove the root node")
+        (getItem(name.cutLast()).tree as? DataTreeBuilder)?.remove(name.lastOrNull()!!)
+    }
+
+    @ThreadSafe
+    private fun set(token: NameToken, data: Data<T>) {
+        treeItems[token] = DataTreeItem.Leaf(data)
+    }
+
+    @ThreadSafe
+    private fun set(token: NameToken, node: DataTree<T>) {
+        treeItems[token] = DataTreeItem.Node(node)
+    }
+
+    private fun getOrCreateNode(token: NameToken): DataTreeBuilder<T> =
+        (treeItems[token] as? DataTreeItem.Node<T>)?.tree as? DataTreeBuilder<T>
+            ?: DataTreeBuilder<T>(dataType, coroutineContext).also { set(token, it) }
+
+    private fun getOrCreateNode(name: Name): DataTreeBuilder<T> = when (name.length) {
+        0 -> this
+        1 -> getOrCreateNode(name.firstOrNull()!!)
+        else -> getOrCreateNode(name.firstOrNull()!!).getOrCreateNode(name.cutFirst())
+    }
+
+    override fun data(name: Name, data: Data<T>?) {
+        if (data == null) {
+            remove(name)
+        } else {
+            when (name.length) {
+                0 -> error("Can't add data with empty name")
+                1 -> set(name.firstOrNull()!!, data)
+                2 -> getOrCreateNode(name.cutLast()).set(name.lastOrNull()!!, data)
+            }
+        }
+        launch {
+            updates.emit(name)
+        }
+    }
+
+    override fun meta(name: Name, meta: Meta) {
+        val item = getItem(name)
+        if (item is DataTreeItem.Leaf) error("TODO: Can't change meta of existing leaf item.")
+        data(name + DataTree.META_ITEM_NAME_TOKEN, Data.empty(meta))
+    }
+}
+
+/**
+ * Create a dynamic [DataSource]. Initial data is placed synchronously.
+ */
+@DFInternal
+@Suppress("FunctionName")
+public fun <T : Any> DataSource(
+    type: KType,
+    parent: CoroutineScope,
+    block: DataSourceBuilder<T>.() -> Unit,
+): DataTreeBuilder<T> = DataTreeBuilder<T>(type, parent.coroutineContext).apply(block)
+
+@Suppress("OPT_IN_USAGE", "FunctionName")
+public inline fun <reified T : Any> DataSource(
+    parent: CoroutineScope,
+    crossinline block: DataSourceBuilder<T>.() -> Unit,
+): DataTreeBuilder<T> = DataSource(typeOf<T>(), parent) { block() }
+
+@Suppress("FunctionName")
+public suspend inline fun <reified T : Any> DataSource(
+    crossinline block: DataSourceBuilder<T>.() -> Unit = {},
+): DataTreeBuilder<T> = DataTreeBuilder<T>(typeOf<T>(), coroutineContext).apply { block() }
+
+public inline fun <reified T : Any> DataSourceBuilder<T>.emit(
+    name: Name,
+    parent: CoroutineScope,
+    noinline block: DataSourceBuilder<T>.() -> Unit,
+): Unit = node(name, DataSource(parent, block))
+
+public inline fun <reified T : Any> DataSourceBuilder<T>.emit(
+    name: String,
+    parent: CoroutineScope,
+    noinline block: DataSourceBuilder<T>.() -> Unit,
+): Unit = node(Name.parse(name), DataSource(parent, block))

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/Goal.kt

@@ -0,0 +1,112 @@
+package space.kscience.dataforge.data
+
+import kotlinx.coroutines.*
+import space.kscience.dataforge.misc.DFExperimental
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.EmptyCoroutineContext
+
+/**
+ * Lazy computation result with its dependencies to allowing to stat computing dependencies ahead of time
+ */
+public interface Goal<out T> {
+    public val dependencies: Collection<Goal<*>>
+
+    /**
+     * Returns current running coroutine if the goal is started. Null if the computation is not started.
+     */
+    public val deferred: Deferred<T>?
+
+    /**
+     * Get ongoing computation or start a new one.
+     * Does not guarantee thread safety. In case of multi-thread access, could create orphan computations.
+     *
+     * If the computation is already running, the scope is not used.
+     */
+    public fun async(coroutineScope: CoroutineScope): Deferred<T>
+
+    /**
+     * Reset the computation
+     */
+    public fun reset()
+
+    public companion object
+}
+
+public fun Goal<*>.launch(coroutineScope: CoroutineScope): Job = async(coroutineScope)
+
+public suspend fun <T> Goal<T>.await(): T = coroutineScope { async(this).await() }
+
+public val Goal<*>.isComplete: Boolean get() = deferred?.isCompleted ?: false
+
+public open class StaticGoal<T>(public val value: T) : Goal<T> {
+    override val dependencies: Collection<Goal<*>> get() = emptyList()
+    override val deferred: Deferred<T> = CompletableDeferred(value)
+
+    override fun async(coroutineScope: CoroutineScope): Deferred<T> = deferred
+
+    override fun reset() {
+        //doNothing
+    }
+}
+
+/**
+ * @param coroutineContext additional context information
+ */
+public open class LazyGoal<T>(
+    private val coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    override val dependencies: Collection<Goal<*>> = emptyList(),
+    public val block: suspend () -> T,
+) : Goal<T> {
+
+    final override var deferred: Deferred<T>? = null
+        private set
+
+    /**
+     * Get ongoing computation or start a new one.
+     * Does not guarantee thread safety. In case of multi-thread access, could create orphan computations.
+     * If [GoalExecutionRestriction] is present in the [coroutineScope] context, the call could produce a error a warning
+     * depending on the settings.
+     */
+    @OptIn(DFExperimental::class)
+    override fun async(coroutineScope: CoroutineScope): Deferred<T> {
+        val log = coroutineScope.coroutineContext[GoalLogger]
+        // Check if context restricts goal computation
+        coroutineScope.coroutineContext[GoalExecutionRestriction]?.let { restriction ->
+            when (restriction.policy) {
+                GoalExecutionRestrictionPolicy.WARNING -> log?.emit(GoalLogger.WARNING_TAG) { "Goal eager execution is prohibited by the coroutine scope policy" }
+                GoalExecutionRestrictionPolicy.ERROR -> error("Goal eager execution is prohibited by the coroutine scope policy")
+                else -> {
+                    /*do nothing*/
+                }
+            }
+        }
+
+        log?.emit { "Starting dependencies computation for ${this@LazyGoal}" }
+        val startedDependencies = this.dependencies.map { goal ->
+            goal.run { async(coroutineScope) }
+        }
+        return deferred ?: coroutineScope.async(
+            coroutineContext
+                    + CoroutineMonitor()
+                    + Dependencies(startedDependencies)
+                    + GoalExecutionRestriction(GoalExecutionRestrictionPolicy.NONE) // Remove restrictions on goal execution
+        ) {
+            //cancel execution if error encountered in one of dependencies
+            startedDependencies.forEach { deferred ->
+                deferred.invokeOnCompletion { error ->
+                    if (error != null) this.cancel(CancellationException("Dependency $deferred failed with error: ${error.message}"))
+                }
+            }
+            coroutineContext[GoalLogger]?.emit { "Starting computation of ${this@LazyGoal}" }
+            block()
+        }.also { deferred = it }
+    }
+
+    /**
+     * Reset the computation
+     */
+    override fun reset() {
+        deferred?.cancel()
+        deferred = null
+    }
+}

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/GoalExecutionRestriction.kt

@@ -0,0 +1,31 @@
+package space.kscience.dataforge.data
+
+import kotlin.coroutines.CoroutineContext
+
+public enum class GoalExecutionRestrictionPolicy {
+    /**
+     * Allow eager execution
+     */
+    NONE,
+
+    /**
+     * Give warning on eager execution
+     */
+    WARNING,
+
+    /**
+     * Throw error on eager execution
+     */
+    ERROR
+}
+
+/**
+ * A special coroutine context key that allows or disallows goal execution during configuration time (eager execution).
+ */
+public class GoalExecutionRestriction(
+    public val policy: GoalExecutionRestrictionPolicy = GoalExecutionRestrictionPolicy.ERROR,
+) : CoroutineContext.Element {
+    override val key: CoroutineContext.Key<*> get() = Companion
+
+    public companion object : CoroutineContext.Key<GoalExecutionRestriction>
+}

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/GoalLogger.kt

@@ -0,0 +1,16 @@
+package space.kscience.dataforge.data
+
+import kotlin.coroutines.CoroutineContext
+
+/**
+ * Coroutine context element that provides logging capabilities
+ */
+public interface GoalLogger : CoroutineContext.Element {
+    override val key: CoroutineContext.Key<*> get() = GoalLogger
+
+    public fun emit(vararg tags: String, message: suspend () -> String)
+
+    public companion object : CoroutineContext.Key<GoalLogger>{
+        public const val WARNING_TAG: String = "WARNING"
+    }
+}

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/GroupRule.kt

@@ -0,0 +1,78 @@
+/* 
+ * Copyright 2015 Alexander Nozik.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package space.kscience.dataforge.data
+
+import kotlinx.coroutines.launch
+import space.kscience.dataforge.meta.get
+import space.kscience.dataforge.meta.string
+import space.kscience.dataforge.misc.DFInternal
+
+public interface GroupRule {
+    public fun <T : Any> gather(set: DataSet<T>): Map<String, DataSet<T>>
+
+    public companion object {
+        /**
+         * Create grouping rule that creates groups for different values of value
+         * field with name [key]
+         *
+         * @param key
+         * @param defaultTagValue
+         * @return
+         */
+        @OptIn(DFInternal::class)
+        public fun byMetaValue(
+            key: String,
+            defaultTagValue: String,
+        ): GroupRule = object : GroupRule {
+
+            override fun <T : Any> gather(
+                set: DataSet<T>,
+            ): Map<String, DataSet<T>> {
+                val map = HashMap<String, DataSet<T>>()
+
+                if (set is DataSource) {
+                    set.forEach { data ->
+                        val tagValue: String = data.meta[key]?.string ?: defaultTagValue
+                        (map.getOrPut(tagValue) { DataTreeBuilder(set.dataType, set.coroutineContext) } as DataTreeBuilder<T>)
+                            .data(data.name, data.data)
+
+                        set.launch {
+                            set.updates.collect { name ->
+                                val dataUpdate = set[name]
+
+                                val updateTagValue = dataUpdate?.meta?.get(key)?.string ?: defaultTagValue
+                                map.getOrPut(updateTagValue) {
+                                    DataSource(set.dataType, this) {
+                                        data(name, dataUpdate)
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    set.forEach { data ->
+                        val tagValue: String = data.meta[key]?.string ?: defaultTagValue
+                        (map.getOrPut(tagValue) { StaticDataTree(set.dataType) } as StaticDataTree<T>)
+                            .data(data.name, data.data)
+                    }
+                }
+
+
+                return map
+            }
+        }
+    }
+}

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/NamedData.kt

@@ -0,0 +1,35 @@
+package space.kscience.dataforge.data
+
+import space.kscience.dataforge.meta.isEmpty
+import space.kscience.dataforge.misc.Named
+import space.kscience.dataforge.names.Name
+
+public interface NamedData<out T : Any> : Named, Data<T> {
+    override val name: Name
+    public val data: Data<T>
+}
+
+public operator fun NamedData<*>.component1(): Name = name
+public operator fun <T: Any> NamedData<T>.component2(): Data<T> = data
+
+private class NamedDataImpl<out T : Any>(
+    override val name: Name,
+    override val data: Data<T>,
+) : Data<T> by data, NamedData<T> {
+    override fun toString(): String = buildString {
+        append("NamedData(name=\"$name\"")
+        if (data is StaticData) {
+            append(", value=${data.value}")
+        }
+        if (!data.meta.isEmpty()) {
+            append(", meta=${data.meta}")
+        }
+        append(")")
+    }
+}
+
+public fun <T : Any> Data<T>.named(name: Name): NamedData<T> = if (this is NamedData) {
+    NamedDataImpl(name, this.data)
+} else {
+    NamedDataImpl(name, this)
+}

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/StaticDataTree.kt

@@ -0,0 +1,82 @@
+package space.kscience.dataforge.data
+
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.names.*
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+@PublishedApi
+internal class StaticDataTree<T : Any>(
+    override val dataType: KType,
+) : DataSetBuilder<T>, DataTree<T> {
+
+    private val _items: MutableMap<NameToken, DataTreeItem<T>> = HashMap()
+
+    override val items: Map<NameToken, DataTreeItem<T>>
+        get() = _items.filter { !it.key.body.startsWith("@") }
+
+    override fun remove(name: Name) {
+        when (name.length) {
+            0 -> error("Can't remove root tree node")
+            1 -> _items.remove(name.firstOrNull()!!)
+            else -> (_items[name.firstOrNull()!!].tree as? StaticDataTree<T>)?.remove(name.cutFirst())
+        }
+    }
+
+    private fun getOrCreateNode(name: Name): StaticDataTree<T> = when (name.length) {
+        0 -> this
+        1 -> {
+            val itemName = name.firstOrNull()!!
+            (_items[itemName].tree as? StaticDataTree<T>) ?: StaticDataTree<T>(dataType).also {
+                _items[itemName] = DataTreeItem.Node(it)
+            }
+        }
+        else -> getOrCreateNode(name.cutLast()).getOrCreateNode(name.lastOrNull()!!.asName())
+    }
+
+    private fun set(name: Name, item: DataTreeItem<T>?) {
+        if (name.isEmpty()) error("Can't set top level tree node")
+        if (item == null) {
+            remove(name)
+        } else {
+            getOrCreateNode(name.cutLast())._items[name.lastOrNull()!!] = item
+        }
+    }
+
+    override fun data(name: Name, data: Data<T>?) {
+        set(name, data?.let { DataTreeItem.Leaf(it) })
+    }
+
+    override fun node(name: Name, dataSet: DataSet<T>) {
+        if (dataSet is StaticDataTree) {
+            set(name, DataTreeItem.Node(dataSet))
+        } else {
+            dataSet.forEach {
+                data(name + it.name, it.data)
+            }
+        }
+    }
+
+    override fun meta(name: Name, meta: Meta) {
+        val item = getItem(name)
+        if (item is DataTreeItem.Leaf) TODO("Can't change meta of existing leaf item.")
+        data(name + DataTree.META_ITEM_NAME_TOKEN, Data.empty(meta))
+    }
+}
+
+@Suppress("FunctionName")
+public inline fun <T : Any> DataTree(
+    dataType: KType,
+    block: DataSetBuilder<T>.() -> Unit,
+): DataTree<T> = StaticDataTree<T>(dataType).apply { block() }
+
+@Suppress("FunctionName")
+public inline fun <reified T : Any> DataTree(
+    noinline block: DataSetBuilder<T>.() -> Unit,
+): DataTree<T> = DataTree(typeOf<T>(), block)
+
+@OptIn(DFExperimental::class)
+public fun <T : Any> DataSet<T>.seal(): DataTree<T> = DataTree(dataType) {
+    populateFrom(this@seal)
+}

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/dataFilter.kt

@@ -0,0 +1,105 @@
+package space.kscience.dataforge.data
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.mapNotNull
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.names.*
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.EmptyCoroutineContext
+import kotlin.reflect.KType
+
+
+/**
+ * A stateless filtered [DataSet]
+ */
+public fun <T : Any> DataSet<T>.filter(
+    predicate: (Name, Meta) -> Boolean,
+): DataSource<T> = object : DataSource<T> {
+
+    override val dataType: KType get() = this@filter.dataType
+
+    override val coroutineContext: CoroutineContext
+        get() = (this@filter as? DataSource)?.coroutineContext ?: EmptyCoroutineContext
+
+
+    override val meta: Meta get() = this@filter.meta
+
+    override fun iterator(): Iterator<NamedData<T>> = iterator {
+        for (d in this@filter) {
+            if (predicate(d.name, d.meta)) {
+                yield(d)
+            }
+        }
+    }
+
+    override fun get(name: Name): Data<T>? = this@filter.get(name)?.takeIf {
+        predicate(name, it.meta)
+    }
+
+    override val updates: Flow<Name> = this@filter.updates.filter flowFilter@{ name ->
+        val theData = this@filter[name] ?: return@flowFilter false
+        predicate(name, theData.meta)
+    }
+}
+
+/**
+ * Generate a wrapper data set with a given name prefix appended to all names
+ */
+public fun <T : Any> DataSet<T>.withNamePrefix(prefix: Name): DataSet<T> = if (prefix.isEmpty()) {
+    this
+} else object : DataSource<T> {
+
+    override val dataType: KType get() = this@withNamePrefix.dataType
+
+    override val coroutineContext: CoroutineContext
+        get() = (this@withNamePrefix as? DataSource)?.coroutineContext ?: EmptyCoroutineContext
+
+    override val meta: Meta get() = this@withNamePrefix.meta
+
+
+    override fun iterator(): Iterator<NamedData<T>> = iterator {
+        for (d in this@withNamePrefix) {
+            yield(d.data.named(prefix + d.name))
+        }
+    }
+
+    override fun get(name: Name): Data<T>? =
+        name.removeFirstOrNull(name)?.let { this@withNamePrefix.get(it) }
+
+    override val updates: Flow<Name> get() = this@withNamePrefix.updates.map { prefix + it }
+}
+
+/**
+ * Get a subset of data starting with a given [branchName]
+ */
+public fun <T : Any> DataSet<T>.branch(branchName: Name): DataSet<T> = if (branchName.isEmpty()) {
+    this
+} else object : DataSource<T> {
+    override val dataType: KType get() = this@branch.dataType
+
+    override val coroutineContext: CoroutineContext
+        get() = (this@branch as? DataSource)?.coroutineContext ?: EmptyCoroutineContext
+
+    override val meta: Meta get() = this@branch.meta
+
+    override fun iterator(): Iterator<NamedData<T>> = iterator {
+        for (d in this@branch) {
+            d.name.removeFirstOrNull(branchName)?.let { name ->
+                yield(d.data.named(name))
+            }
+        }
+    }
+
+    override fun get(name: Name): Data<T>? = this@branch.get(branchName + name)
+
+    override val updates: Flow<Name> get() = this@branch.updates.mapNotNull { it.removeFirstOrNull(branchName) }
+}
+
+public fun <T : Any> DataSet<T>.branch(branchName: String): DataSet<T> = this@branch.branch(branchName.parseAsName())
+
+@DFExperimental
+public suspend fun <T : Any> DataSet<T>.rootData(): Data<T>? = get(Name.EMPTY)
+

dataforge-data/src/commonMain/kotlin/space/kscience/dataforge/data/dataTransform.kt

@@ -0,0 +1,221 @@
+package space.kscience.dataforge.data
+
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.meta.MutableMeta
+import space.kscience.dataforge.meta.seal
+import space.kscience.dataforge.meta.toMutableMeta
+import space.kscience.dataforge.misc.DFInternal
+import space.kscience.dataforge.names.Name
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.EmptyCoroutineContext
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+public data class ValueWithMeta<T>(val meta: Meta, val value: T)
+
+public suspend fun <T : Any> Data<T>.awaitWithMeta(): ValueWithMeta<T> = ValueWithMeta(meta, await())
+
+public data class NamedValueWithMeta<T>(val name: Name, val meta: Meta, val value: T)
+
+public suspend fun <T : Any> NamedData<T>.awaitWithMeta(): NamedValueWithMeta<T> =
+    NamedValueWithMeta(name, meta, await())
+
+
+/**
+ * Lazily transform this data to another data. By convention [block] should not use external data (be pure).
+ * @param coroutineContext additional [CoroutineContext] elements used for data computation.
+ * @param meta for the resulting data. By default equals input data.
+ * @param block the transformation itself
+ */
+public inline fun <T : Any, reified R : Any> Data<T>.map(
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    meta: Meta = this.meta,
+    crossinline block: suspend (T) -> R,
+): Data<R> = Data(meta, coroutineContext, listOf(this)) {
+    block(await())
+}
+
+/**
+ * Combine this data with the other data using [block]. See [Data::map] for other details
+ */
+public inline fun <T1 : Any, T2 : Any, reified R : Any> Data<T1>.combine(
+    other: Data<T2>,
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    meta: Meta = this.meta,
+    crossinline block: suspend (left: T1, right: T2) -> R,
+): Data<R> = Data(meta, coroutineContext, listOf(this, other)) {
+    block(await(), other.await())
+}
+
+
+//data collection operations
+
+/**
+ * Lazily reduce a collection of [Data] to a single data.
+ */
+public inline fun <T : Any, reified R : Any> Collection<Data<T>>.reduceToData(
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    meta: Meta = Meta.EMPTY,
+    crossinline block: suspend (List<ValueWithMeta<T>>) -> R,
+): Data<R> = Data(
+    meta,
+    coroutineContext,
+    this
+) {
+    block(map { it.awaitWithMeta() })
+}
+
+@DFInternal
+public fun <K, T : Any, R : Any> Map<K, Data<T>>.reduceToData(
+    outputType: KType,
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    meta: Meta = Meta.EMPTY,
+    block: suspend (Map<K, ValueWithMeta<T>>) -> R,
+): Data<R> = Data(
+    outputType,
+    meta,
+    coroutineContext,
+    this.values
+) {
+    block(mapValues { it.value.awaitWithMeta() })
+}
+
+/**
+ * Lazily reduce a [Map] of [Data] with any static key.
+ * @param K type of the map key
+ * @param T type of the input goal
+ * @param R type of the result goal
+ */
+public inline fun <K, T : Any, reified R : Any> Map<K, Data<T>>.reduceToData(
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    meta: Meta = Meta.EMPTY,
+    crossinline block: suspend (Map<K, ValueWithMeta<T>>) -> R,
+): Data<R> = Data(
+    meta,
+    coroutineContext,
+    this.values
+) {
+    block(mapValues { it.value.awaitWithMeta() })
+}
+
+//Iterable operations
+
+@DFInternal
+public inline fun <T : Any, R : Any> Iterable<Data<T>>.reduceToData(
+    outputType: KType,
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    meta: Meta = Meta.EMPTY,
+    crossinline transformation: suspend (Collection<ValueWithMeta<T>>) -> R,
+): Data<R> = Data(
+    outputType,
+    meta,
+    coroutineContext,
+    toList()
+) {
+    transformation(map { it.awaitWithMeta() })
+}
+
+@OptIn(DFInternal::class)
+public inline fun <T : Any, reified R : Any> Iterable<Data<T>>.reduceToData(
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    meta: Meta = Meta.EMPTY,
+    crossinline transformation: suspend (Collection<ValueWithMeta<T>>) -> R,
+): Data<R> = reduceToData(typeOf<R>(), coroutineContext, meta) {
+    transformation(it)
+}
+
+public inline fun <T : Any, reified R : Any> Iterable<Data<T>>.foldToData(
+    initial: R,
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    meta: Meta = Meta.EMPTY,
+    crossinline block: suspend (result: R, data: ValueWithMeta<T>) -> R,
+): Data<R> = reduceToData(
+    coroutineContext, meta
+) {
+    it.fold(initial) { acc, t -> block(acc, t) }
+}
+
+/**
+ * Transform an [Iterable] of [NamedData] to a single [Data].
+ */
+@DFInternal
+public inline fun <T : Any, R : Any> Iterable<NamedData<T>>.reduceNamedToData(
+    outputType: KType,
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    meta: Meta = Meta.EMPTY,
+    crossinline transformation: suspend (Collection<NamedValueWithMeta<T>>) -> R,
+): Data<R> = Data(
+    outputType,
+    meta,
+    coroutineContext,
+    toList()
+) {
+    transformation(map { it.awaitWithMeta() })
+}
+
+@OptIn(DFInternal::class)
+public inline fun <T : Any, reified R : Any> Iterable<NamedData<T>>.reduceNamedToData(
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    meta: Meta = Meta.EMPTY,
+    crossinline transformation: suspend (Collection<NamedValueWithMeta<T>>) -> R,
+): Data<R> = reduceNamedToData(typeOf<R>(), coroutineContext, meta) {
+    transformation(it)
+}
+
+/**
+ * Fold a [Iterable] of named data into a single [Data]
+ */
+public inline fun <T : Any, reified R : Any> Iterable<NamedData<T>>.foldNamedToData(
+    initial: R,
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    meta: Meta = Meta.EMPTY,
+    crossinline block: suspend (result: R, data: NamedValueWithMeta<T>) -> R,
+): Data<R> = reduceNamedToData(
+    coroutineContext, meta
+) {
+    it.fold(initial) { acc, t -> block(acc, t) }
+}
+
+//DataSet operations
+
+@DFInternal
+public suspend fun <T : Any, R : Any> DataSet<T>.map(
+    outputType: KType,
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    metaTransform: MutableMeta.() -> Unit = {},
+    block: suspend (NamedValueWithMeta<T>) -> R,
+): DataTree<R> = DataTree<R>(outputType) {
+    forEach {
+        val newMeta = it.meta.toMutableMeta().apply(metaTransform).seal()
+        val d = Data(outputType, newMeta, coroutineContext, listOf(it)) {
+            block(it.awaitWithMeta())
+        }
+        data(it.name, d)
+    }
+}
+
+@OptIn(DFInternal::class)
+public suspend inline fun <T : Any, reified R : Any> DataSet<T>.map(
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    noinline metaTransform: MutableMeta.() -> Unit = {},
+    noinline block: suspend (NamedValueWithMeta<T>) -> R,
+): DataTree<R> = map(typeOf<R>(), coroutineContext, metaTransform, block)
+
+public inline fun <T : Any> DataSet<T>.forEach(block: (NamedData<T>) -> Unit) {
+    for (d in this) {
+        block(d)
+    }
+}
+
+public inline fun <T : Any, reified R : Any> DataSet<T>.reduceToData(
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    meta: Meta = Meta.EMPTY,
+    crossinline transformation: suspend (Iterable<NamedValueWithMeta<T>>) -> R,
+): Data<R> = asIterable().reduceNamedToData(coroutineContext, meta, transformation)
+
+public inline fun <T : Any, reified R : Any> DataSet<T>.foldToData(
+    initial: R,
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    meta: Meta = Meta.EMPTY,
+    crossinline block: suspend (result: R, data: NamedValueWithMeta<T>) -> R,
+): Data<R> = asIterable().foldNamedToData(initial, coroutineContext, meta, block)

dataforge-data/src/jsMain/kotlin/hep/dataforge/data/checkType.kt

@@ -1,10 +0,0 @@
-package hep.dataforge.data
-
-import kotlin.reflect.KClass
-
-/**
- * Check that node is compatible with given type meaning that each element could be cast to the type
- */
-actual fun DataNode<*>.checkType(type: KClass<*>) {
-    //Not supported in js yet
-}

dataforge-data/src/jvmMain/kotlin/hep/dataforge/data/CastDataNode.kt

@@ -1,46 +0,0 @@
-package hep.dataforge.data
-
-import hep.dataforge.names.Name
-import kotlin.reflect.KClass
-import kotlin.reflect.full.isSubclassOf
-
-fun <T : Any, R : Any> Data<T>.safeCast(type: KClass<R>): Data<R>? {
-    return if (type.isSubclassOf(type)) {
-        @Suppress("UNCHECKED_CAST")
-        Data.of(type, goal as Goal<R>, meta)
-    } else {
-        null
-    }
-}
-
-/**
- * Filter a node by data and node type. Resulting node and its subnodes is guaranteed to have border type [type],
- * but could contain empty nodes
- */
-fun <T : Any, R : Any> DataNode<T>.cast(type: KClass<R>): DataNode<R> {
-    return if (this is CastDataNode) {
-        origin.cast(type)
-    } else {
-        CastDataNode(this, type)
-    }
-}
-
-inline fun <T : Any, reified R : Any> DataNode<T>.cast(): DataNode<R> = cast(R::class)
-
-class CastDataNode<out T : Any>(val origin: DataNode<Any>, override val type: KClass<out T>) : DataNode<T> {
-
-    override fun get(name: Name): Data<T>? =
-        origin[name]?.safeCast(type)
-
-    override fun getNode(name: Name): DataNode<T>? {
-        return origin.getNode(name)?.cast(type)
-    }
-
-    override fun data(): Sequence<Pair<Name, Data<T>>> =
-        origin.data().mapNotNull { pair ->
-            pair.second.safeCast(type)?.let { pair.first to it }
-        }
-
-    override fun nodes(): Sequence<Pair<Name, DataNode<T>>> =
-        origin.nodes().map { it.first to it.second.cast(type) }
-}

dataforge-data/src/jvmMain/kotlin/hep/dataforge/data/_Data.kt

@@ -1,8 +0,0 @@
-package hep.dataforge.data
-
-import kotlinx.coroutines.runBlocking
-
-/**
- * Block the thread and get data content
- */
-fun <T : Any> Data<T>.get(): T = runBlocking { await() }

dataforge-data/src/jvmMain/kotlin/hep/dataforge/data/checkType.kt

@@ -1,13 +0,0 @@
-package hep.dataforge.data
-
-import kotlin.reflect.KClass
-import kotlin.reflect.full.isSuperclassOf
-
-/**
- * Check that node is compatible with given type meaning that each element could be cast to the type
- */
-actual fun DataNode<*>.checkType(type: KClass<*>) {
-    if (!type.isSuperclassOf(type)) {
-        error("$type expected, but $type received")
-    }
-}

dataforge-data/src/jvmMain/kotlin/space/kscience/dataforge/data/actionInContext.kt

@@ -0,0 +1,2 @@
+package space.kscience.dataforge.data
+

dataforge-data/src/jvmMain/kotlin/space/kscience/dataforge/data/dataFilterJvm.kt

@@ -0,0 +1,85 @@
+package space.kscience.dataforge.data
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.filter
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.names.Name
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.EmptyCoroutineContext
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.typeOf
+
+
+/**
+ * Cast the node to given type if the cast is possible or return null
+ */
+@Suppress("UNCHECKED_CAST")
+private fun <R : Any> Data<*>.castOrNull(type: KType): Data<R>? =
+    if (!this.type.isSubtypeOf(type)) {
+        null
+    } else {
+        object : Data<R> by (this as Data<R>) {
+            override val type: KType = type
+        }
+    }
+
+/**
+ * Select all data matching given type and filters. Does not modify paths
+ *
+ * @param predicate addition filtering condition based on item name and meta. By default, accepts all
+ */
+@OptIn(DFExperimental::class)
+public fun <R : Any> DataSet<*>.filterByType(
+    type: KType,
+    predicate: (name: Name, meta: Meta) -> Boolean = { _, _ -> true },
+): DataSource<R> = object : DataSource<R> {
+    override val dataType = type
+
+    override val coroutineContext: CoroutineContext
+        get() = (this@filterByType as? DataSource)?.coroutineContext ?: EmptyCoroutineContext
+
+    override val meta: Meta get() = this@filterByType.meta
+
+    private fun checkDatum(name: Name, datum: Data<*>): Boolean = datum.type.isSubtypeOf(type)
+            && predicate(name, datum.meta)
+
+    override fun iterator(): Iterator<NamedData<R>> = iterator {
+        for(d in this@filterByType){
+            if(checkDatum(d.name,d.data)){
+                @Suppress("UNCHECKED_CAST")
+                yield(d as NamedData<R>)
+            }
+        }
+    }
+
+    override fun get(name: Name): Data<R>? = this@filterByType[name]?.let { datum ->
+        if (checkDatum(name, datum)) datum.castOrNull(type) else null
+    }
+
+    override val updates: Flow<Name> = this@filterByType.updates.filter { name ->
+        get(name)?.let { datum ->
+            checkDatum(name, datum)
+        } ?: false
+    }
+}
+
+/**
+ * Select a single datum of the appropriate type
+ */
+public inline fun <reified R : Any> DataSet<*>.filterByType(
+    noinline predicate: (name: Name, meta: Meta) -> Boolean = { _, _ -> true },
+): DataSet<R> = filterByType(typeOf<R>(), predicate)
+
+/**
+ * Select a single datum if it is present and of given [type]
+ */
+public fun <R : Any> DataSet<*>.getByType(type: KType, name: Name): NamedData<R>? =
+    get(name)?.castOrNull<R>(type)?.named(name)
+
+public inline fun <reified R : Any> DataSet<*>.getByType(name: Name): NamedData<R>? =
+    this@getByType.getByType(typeOf<R>(), name)
+
+public inline fun <reified R : Any> DataSet<*>.getByType(name: String): NamedData<R>? =
+    this@getByType.getByType(typeOf<R>(), Name.parse(name))

dataforge-data/src/jvmMain/kotlin/space/kscience/dataforge/data/dataSetBuilderInContext.kt

@@ -0,0 +1,40 @@
+package space.kscience.dataforge.data
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.plus
+
+
+/**
+ * Append data to node
+ */
+context(DataSetBuilder<T>) public infix fun <T : Any> String.put(data: Data<T>): Unit =
+    data(Name.parse(this), data)
+
+/**
+ * Append node
+ */
+context(DataSetBuilder<T>) public infix fun <T : Any> String.put(dataSet: DataSet<T>): Unit =
+    node(Name.parse(this), dataSet)
+
+/**
+ * Build and append node
+ */
+context(DataSetBuilder<T>) public infix fun <T : Any> String.put(
+    block: DataSetBuilder<T>.() -> Unit,
+): Unit = node(Name.parse(this), block)
+
+/**
+ * Copy given data set and mirror its changes to this [DataTreeBuilder] in [this@setAndObserve]. Returns an update [Job]
+ */
+context(DataSetBuilder<T>) public fun <T : Any> CoroutineScope.setAndWatch(
+    name: Name,
+    dataSet: DataSet<T>,
+): Job = launch {
+    node(name, dataSet)
+    dataSet.updates.collect { nameInBranch ->
+        data(name + nameInBranch, dataSet.get(nameInBranch))
+    }
+}

dataforge-data/src/jvmTest/kotlin/space/kscience/dataforge/data/ActionsTest.kt

@@ -0,0 +1,50 @@
+package space.kscience.dataforge.data
+
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Test
+import space.kscience.dataforge.actions.Action
+import space.kscience.dataforge.actions.invoke
+import space.kscience.dataforge.actions.map
+import space.kscience.dataforge.misc.DFExperimental
+import kotlin.test.assertEquals
+
+@OptIn(DFExperimental::class, ExperimentalCoroutinesApi::class)
+internal class ActionsTest {
+    @Test
+    fun testStaticMapAction() = runTest {
+        val data: DataTree<Int> = DataTree {
+            repeat(10) {
+                static(it.toString(), it)
+            }
+        }
+
+        val plusOne = Action.map<Int, Int> {
+            result { it + 1 }
+        }
+        val result = plusOne(data)
+        assertEquals(2, result["1"]?.await())
+    }
+
+    @Test
+    fun testDynamicMapAction() = runTest {
+        val data: DataSourceBuilder<Int> = DataSource()
+
+        val plusOne = Action.map<Int, Int> {
+            result { it + 1 }
+        }
+
+        val result = plusOne(data)
+
+        repeat(10) {
+            data.static(it.toString(), it)
+        }
+
+        delay(20)
+
+        assertEquals(2, result["1"]?.await())
+        data.close()
+    }
+
+}

dataforge-data/src/jvmTest/kotlin/space/kscience/dataforge/data/DataTreeBuilderTest.kt

@@ -0,0 +1,91 @@
+package space.kscience.dataforge.data
+
+import kotlinx.coroutines.*
+import space.kscience.dataforge.misc.DFExperimental
+import space.kscience.dataforge.names.asName
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+
+internal class DataTreeBuilderTest {
+    @Test
+    fun testTreeBuild() = runBlocking {
+        val node = DataTree<Any> {
+            "primary" put {
+                static("a", "a")
+                static("b", "b")
+            }
+            static("c.d", "c.d")
+            static("c.f", "c.f")
+        }
+        runBlocking {
+            assertEquals("a", node["primary.a"]?.await())
+            assertEquals("b", node["primary.b"]?.await())
+            assertEquals("c.d", node["c.d"]?.await())
+            assertEquals("c.f", node["c.f"]?.await())
+        }
+    }
+
+    @OptIn(DFExperimental::class)
+    @Test
+    fun testDataUpdate() = runBlocking {
+        val updateData: DataTree<Any> = DataTree {
+            "update" put {
+                "a" put Data.static("a")
+                "b" put Data.static("b")
+            }
+        }
+
+        val node = DataTree<Any> {
+            "primary" put {
+                static("a", "a")
+                static("b", "b")
+            }
+            static("root", "root")
+            populateFrom(updateData)
+        }
+
+        runBlocking {
+            assertEquals("a", node["update.a"]?.await())
+            assertEquals("a", node["primary.a"]?.await())
+        }
+    }
+
+    @Test
+    fun testDynamicUpdates() = runBlocking {
+        try {
+            lateinit var updateJob: Job
+            supervisorScope {
+                val subNode = DataSource<Int> {
+                    updateJob = launch {
+                        repeat(10) {
+                            delay(10)
+                            static("value", it)
+                        }
+                        delay(10)
+                    }
+                }
+                launch {
+                    subNode.updatesWithData.collect {
+                        println(it)
+                    }
+                }
+                val rootNode = DataSource<Int> {
+                    setAndWatch("sub".asName(), subNode)
+                }
+
+                launch {
+                    rootNode.updatesWithData.collect {
+                        println(it)
+                    }
+                }
+                updateJob.join()
+                assertEquals(9, rootNode["sub.value"]?.await())
+                cancel()
+            }
+        } catch (t: Throwable) {
+            if (t !is CancellationException) throw t
+        }
+
+    }
+}

dataforge-io/README.md

@@ -0,0 +1,23 @@
+# Module dataforge-io
+
+IO module
+
+## Usage
+
+## Artifact:
+
+The Maven coordinates of this project are `space.kscience:dataforge-io:0.7.0`.
+
+**Gradle Kotlin DSL:**
+```kotlin
+repositories {
+    maven("https://repo.kotlin.link")
+    //uncomment to access development builds
+    //maven("https://maven.pkg.jetbrains.space/spc/p/sci/dev")
+    mavenCentral()
+}
+
+dependencies {
+    implementation("space.kscience:dataforge-io:0.7.0")
+}
+```

dataforge-io/api/dataforge-io.api

@@ -0,0 +1,473 @@
+public final class hep/dataforge/io/BinaryMetaFormat : hep/dataforge/io/MetaFormat, hep/dataforge/io/MetaFormatFactory {
+	public static final field INSTANCE Lhep/dataforge/io/BinaryMetaFormat;
+	public fun getKey ()S
+	public fun getName ()Lhep/dataforge/names/Name;
+	public fun getShortName ()Ljava/lang/String;
+	public fun getType ()Lkotlin/reflect/KClass;
+	public fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Lhep/dataforge/io/MetaFormat;
+	public synthetic fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Ljava/lang/Object;
+	public fun readMeta (Lkotlinx/io/Input;Lhep/dataforge/meta/descriptors/NodeDescriptor;)Lhep/dataforge/meta/Meta;
+	public final fun readMetaItem (Lkotlinx/io/Input;)Lhep/dataforge/meta/TypedMetaItem;
+	public fun readObject (Lkotlinx/io/Input;)Lhep/dataforge/meta/Meta;
+	public synthetic fun readObject (Lkotlinx/io/Input;)Ljava/lang/Object;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+	public fun writeMeta (Lkotlinx/io/Output;Lhep/dataforge/meta/Meta;Lhep/dataforge/meta/descriptors/NodeDescriptor;)V
+	public fun writeObject (Lkotlinx/io/Output;Lhep/dataforge/meta/Meta;)V
+	public synthetic fun writeObject (Lkotlinx/io/Output;Ljava/lang/Object;)V
+	public final fun writeValue (Lkotlinx/io/Output;Lhep/dataforge/values/Value;)V
+}
+
+public final class hep/dataforge/io/BinaryView : kotlinx/io/Binary {
+	public fun <init> (Lkotlinx/io/Binary;II)V
+	public fun getSize ()I
+	public fun read (IILkotlin/jvm/functions/Function1;)Ljava/lang/Object;
+}
+
+public abstract interface class hep/dataforge/io/Consumer {
+	public abstract fun consume (Lhep/dataforge/io/Envelope;)V
+}
+
+public final class hep/dataforge/io/DoubleIOFormat : hep/dataforge/io/IOFormat, hep/dataforge/io/IOFormatFactory {
+	public static final field INSTANCE Lhep/dataforge/io/DoubleIOFormat;
+	public fun getName ()Lhep/dataforge/names/Name;
+	public fun getType ()Lkotlin/reflect/KClass;
+	public fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Lhep/dataforge/io/IOFormat;
+	public synthetic fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Ljava/lang/Object;
+	public fun readObject (Lkotlinx/io/Input;)Ljava/lang/Double;
+	public synthetic fun readObject (Lkotlinx/io/Input;)Ljava/lang/Object;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+	public fun writeObject (Lkotlinx/io/Output;D)V
+	public synthetic fun writeObject (Lkotlinx/io/Output;Ljava/lang/Object;)V
+}
+
+public abstract interface class hep/dataforge/io/Envelope {
+	public static final field Companion Lhep/dataforge/io/Envelope$Companion;
+	public abstract fun getData ()Lkotlinx/io/Binary;
+	public abstract fun getMeta ()Lhep/dataforge/meta/Meta;
+}
+
+public final class hep/dataforge/io/Envelope$Companion {
+	public final fun getENVELOPE_DATA_ID_KEY ()Lhep/dataforge/names/Name;
+	public final fun getENVELOPE_DATA_TYPE_KEY ()Lhep/dataforge/names/Name;
+	public final fun getENVELOPE_DESCRIPTION_KEY ()Lhep/dataforge/names/Name;
+	public final fun getENVELOPE_NAME_KEY ()Lhep/dataforge/names/Name;
+	public final fun getENVELOPE_NODE_KEY ()Lhep/dataforge/names/Name;
+	public final fun getENVELOPE_TYPE_KEY ()Lhep/dataforge/names/Name;
+	public final fun invoke (Lkotlin/jvm/functions/Function1;)Lhep/dataforge/io/Envelope;
+}
+
+public final class hep/dataforge/io/EnvelopeBuilder : hep/dataforge/io/Envelope {
+	public fun <init> ()V
+	public final fun data (Lkotlin/jvm/functions/Function1;)V
+	public fun getData ()Lkotlinx/io/Binary;
+	public final fun getDataID ()Ljava/lang/String;
+	public final fun getDataType ()Ljava/lang/String;
+	public final fun getDescription ()Ljava/lang/String;
+	public fun getMeta ()Lhep/dataforge/meta/Meta;
+	public final fun getName ()Ljava/lang/String;
+	public final fun getType ()Ljava/lang/String;
+	public final fun meta (Lkotlin/jvm/functions/Function1;)V
+	public final fun seal ()Lhep/dataforge/io/Envelope;
+	public fun setData (Lkotlinx/io/Binary;)V
+	public final fun setDataID (Ljava/lang/String;)V
+	public final fun setDataType (Ljava/lang/String;)V
+	public final fun setDescription (Ljava/lang/String;)V
+	public fun setMeta (Lhep/dataforge/meta/Meta;)V
+	public final fun setName (Ljava/lang/String;)V
+	public final fun setType (Ljava/lang/String;)V
+}
+
+public final class hep/dataforge/io/EnvelopeBuilderKt {
+	public static final fun Envelope (Lkotlin/jvm/functions/Function1;)Lhep/dataforge/io/Envelope;
+}
+
+public abstract interface class hep/dataforge/io/EnvelopeFormat : hep/dataforge/io/IOFormat {
+	public abstract fun getDefaultMetaFormat ()Lhep/dataforge/io/MetaFormatFactory;
+	public abstract fun readObject (Lkotlinx/io/Input;)Lhep/dataforge/io/Envelope;
+	public abstract fun readPartial (Lkotlinx/io/Input;)Lhep/dataforge/io/PartialEnvelope;
+	public abstract fun writeEnvelope (Lkotlinx/io/Output;Lhep/dataforge/io/Envelope;Lhep/dataforge/io/MetaFormatFactory;Lhep/dataforge/meta/Meta;)V
+	public abstract fun writeObject (Lkotlinx/io/Output;Lhep/dataforge/io/Envelope;)V
+}
+
+public final class hep/dataforge/io/EnvelopeFormat$DefaultImpls {
+	public static fun getDefaultMetaFormat (Lhep/dataforge/io/EnvelopeFormat;)Lhep/dataforge/io/MetaFormatFactory;
+	public static synthetic fun writeEnvelope$default (Lhep/dataforge/io/EnvelopeFormat;Lkotlinx/io/Output;Lhep/dataforge/io/Envelope;Lhep/dataforge/io/MetaFormatFactory;Lhep/dataforge/meta/Meta;ILjava/lang/Object;)V
+	public static fun writeObject (Lhep/dataforge/io/EnvelopeFormat;Lkotlinx/io/Output;Lhep/dataforge/io/Envelope;)V
+}
+
+public abstract interface class hep/dataforge/io/EnvelopeFormatFactory : hep/dataforge/io/EnvelopeFormat, hep/dataforge/io/IOFormatFactory {
+	public static final field Companion Lhep/dataforge/io/EnvelopeFormatFactory$Companion;
+	public static final field ENVELOPE_FORMAT_TYPE Ljava/lang/String;
+	public abstract fun getName ()Lhep/dataforge/names/Name;
+	public abstract fun getType ()Lkotlin/reflect/KClass;
+	public abstract fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Lhep/dataforge/io/EnvelopeFormat;
+	public abstract fun peekFormat (Lhep/dataforge/io/IOPlugin;Lkotlinx/io/Input;)Lhep/dataforge/io/EnvelopeFormat;
+}
+
+public final class hep/dataforge/io/EnvelopeFormatFactory$Companion {
+	public static final field ENVELOPE_FORMAT_TYPE Ljava/lang/String;
+}
+
+public final class hep/dataforge/io/EnvelopeFormatFactory$DefaultImpls {
+	public static fun getDefaultMetaFormat (Lhep/dataforge/io/EnvelopeFormatFactory;)Lhep/dataforge/io/MetaFormatFactory;
+	public static fun getName (Lhep/dataforge/io/EnvelopeFormatFactory;)Lhep/dataforge/names/Name;
+	public static fun getType (Lhep/dataforge/io/EnvelopeFormatFactory;)Lkotlin/reflect/KClass;
+	public static fun toMeta (Lhep/dataforge/io/EnvelopeFormatFactory;)Lhep/dataforge/meta/Meta;
+	public static fun writeObject (Lhep/dataforge/io/EnvelopeFormatFactory;Lkotlinx/io/Output;Lhep/dataforge/io/Envelope;)V
+}
+
+public final class hep/dataforge/io/EnvelopeFormatKt {
+	public static final fun read (Lhep/dataforge/io/EnvelopeFormat;Lkotlinx/io/Input;)Lhep/dataforge/io/Envelope;
+}
+
+public final class hep/dataforge/io/EnvelopeKt {
+	public static final fun contentEquals (Lhep/dataforge/io/Envelope;Lhep/dataforge/io/Envelope;)Z
+	public static final fun dataEquals (Lhep/dataforge/io/Envelope;Lhep/dataforge/io/Envelope;)Z
+	public static final fun getDataID (Lhep/dataforge/io/Envelope;)Ljava/lang/String;
+	public static final fun getDataType (Lhep/dataforge/io/Envelope;)Ljava/lang/String;
+	public static final fun getDescription (Lhep/dataforge/io/Envelope;)Ljava/lang/String;
+	public static final fun getType (Lhep/dataforge/io/Envelope;)Ljava/lang/String;
+	public static final fun metaEquals (Lhep/dataforge/io/Envelope;Lhep/dataforge/io/Envelope;)Z
+	public static final fun withMetaLayers (Lhep/dataforge/io/Envelope;[Lhep/dataforge/meta/Meta;)Lhep/dataforge/io/Envelope;
+}
+
+public final class hep/dataforge/io/EnvelopePart {
+	public fun <init> (Lkotlinx/io/Binary;Lhep/dataforge/meta/Meta;)V
+	public final fun component1 ()Lkotlinx/io/Binary;
+	public final fun component2 ()Lhep/dataforge/meta/Meta;
+	public final fun copy (Lkotlinx/io/Binary;Lhep/dataforge/meta/Meta;)Lhep/dataforge/io/EnvelopePart;
+	public static synthetic fun copy$default (Lhep/dataforge/io/EnvelopePart;Lkotlinx/io/Binary;Lhep/dataforge/meta/Meta;ILjava/lang/Object;)Lhep/dataforge/io/EnvelopePart;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getBinary ()Lkotlinx/io/Binary;
+	public final fun getDescription ()Lhep/dataforge/meta/Meta;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class hep/dataforge/io/EnvelopePartsKt {
+	public static final fun envelope (Lhep/dataforge/io/EnvelopePart;Lhep/dataforge/io/EnvelopeFormat;)Lhep/dataforge/io/Envelope;
+	public static final fun envelope (Lhep/dataforge/io/EnvelopePart;Lhep/dataforge/io/IOPlugin;)Lhep/dataforge/io/Envelope;
+	public static final fun envelopes (Lhep/dataforge/io/EnvelopeBuilder;Ljava/util/List;Lhep/dataforge/io/EnvelopeFormat;Ljava/lang/String;)V
+	public static synthetic fun envelopes$default (Lhep/dataforge/io/EnvelopeBuilder;Ljava/util/List;Lhep/dataforge/io/EnvelopeFormat;Ljava/lang/String;ILjava/lang/Object;)V
+	public static final fun getName (Lhep/dataforge/io/EnvelopePart;)Ljava/lang/String;
+	public static final fun multipart (Lhep/dataforge/io/EnvelopeBuilder;Ljava/util/List;Ljava/lang/String;)V
+	public static synthetic fun multipart$default (Lhep/dataforge/io/EnvelopeBuilder;Ljava/util/List;Ljava/lang/String;ILjava/lang/Object;)V
+	public static final fun parts (Lhep/dataforge/io/Envelope;)Ljava/util/List;
+}
+
+public final class hep/dataforge/io/FileIOKt {
+	public static final fun append (Ljava/nio/file/Path;Lkotlin/jvm/functions/Function1;)V
+	public static final fun getDATA_FILE_NAME (Lhep/dataforge/io/IOPlugin$Companion;)Ljava/lang/String;
+	public static final fun getMETA_FILE_NAME (Lhep/dataforge/io/IOPlugin$Companion;)Ljava/lang/String;
+	public static final fun peekBinaryFormat (Lhep/dataforge/io/IOPlugin;Ljava/nio/file/Path;)Lhep/dataforge/io/EnvelopeFormat;
+	public static final fun read (Ljava/nio/file/Path;Lkotlin/jvm/functions/Function1;)Ljava/lang/Object;
+	public static final fun readEnvelope (Ljava/nio/file/Path;Lhep/dataforge/io/EnvelopeFormat;)Lhep/dataforge/io/Envelope;
+	public static final fun readEnvelopeFile (Lhep/dataforge/io/IOPlugin;Ljava/nio/file/Path;ZLkotlin/jvm/functions/Function2;)Lhep/dataforge/io/Envelope;
+	public static synthetic fun readEnvelopeFile$default (Lhep/dataforge/io/IOPlugin;Ljava/nio/file/Path;ZLkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lhep/dataforge/io/Envelope;
+	public static final fun readMetaFile (Lhep/dataforge/io/IOPlugin;Ljava/nio/file/Path;Lhep/dataforge/io/MetaFormat;Lhep/dataforge/meta/descriptors/NodeDescriptor;)Lhep/dataforge/meta/Meta;
+	public static synthetic fun readMetaFile$default (Lhep/dataforge/io/IOPlugin;Ljava/nio/file/Path;Lhep/dataforge/io/MetaFormat;Lhep/dataforge/meta/descriptors/NodeDescriptor;ILjava/lang/Object;)Lhep/dataforge/meta/Meta;
+	public static final fun rewrite (Ljava/nio/file/Path;Lkotlin/jvm/functions/Function1;)V
+	public static final fun write (Ljava/nio/file/Path;Lkotlin/jvm/functions/Function1;)V
+	public static final fun writeEnvelopeDirectory (Lhep/dataforge/io/IOPlugin;Ljava/nio/file/Path;Lhep/dataforge/io/Envelope;Lhep/dataforge/io/MetaFormatFactory;)V
+	public static synthetic fun writeEnvelopeDirectory$default (Lhep/dataforge/io/IOPlugin;Ljava/nio/file/Path;Lhep/dataforge/io/Envelope;Lhep/dataforge/io/MetaFormatFactory;ILjava/lang/Object;)V
+	public static final fun writeEnvelopeFile (Lhep/dataforge/io/IOPlugin;Ljava/nio/file/Path;Lhep/dataforge/io/Envelope;Lhep/dataforge/io/EnvelopeFormat;Lhep/dataforge/io/MetaFormatFactory;)V
+	public static synthetic fun writeEnvelopeFile$default (Lhep/dataforge/io/IOPlugin;Ljava/nio/file/Path;Lhep/dataforge/io/Envelope;Lhep/dataforge/io/EnvelopeFormat;Lhep/dataforge/io/MetaFormatFactory;ILjava/lang/Object;)V
+	public static final fun writeMetaFile (Lhep/dataforge/io/IOPlugin;Ljava/nio/file/Path;Lhep/dataforge/meta/Meta;Lhep/dataforge/io/MetaFormatFactory;Lhep/dataforge/meta/descriptors/NodeDescriptor;)V
+	public static synthetic fun writeMetaFile$default (Lhep/dataforge/io/IOPlugin;Ljava/nio/file/Path;Lhep/dataforge/meta/Meta;Lhep/dataforge/io/MetaFormatFactory;Lhep/dataforge/meta/descriptors/NodeDescriptor;ILjava/lang/Object;)V
+	public static final fun writeToFile (Lhep/dataforge/io/IOFormat;Ljava/nio/file/Path;Ljava/lang/Object;)V
+}
+
+public abstract interface class hep/dataforge/io/IOFormat : hep/dataforge/meta/MetaRepr {
+	public static final field Companion Lhep/dataforge/io/IOFormat$Companion;
+	public abstract fun readObject (Lkotlinx/io/Input;)Ljava/lang/Object;
+	public abstract fun writeObject (Lkotlinx/io/Output;Ljava/lang/Object;)V
+}
+
+public final class hep/dataforge/io/IOFormat$Companion {
+	public final fun getMETA_KEY ()Lhep/dataforge/names/Name;
+	public final fun getNAME_KEY ()Lhep/dataforge/names/Name;
+}
+
+public abstract interface class hep/dataforge/io/IOFormatFactory : hep/dataforge/context/Factory, hep/dataforge/context/Named, hep/dataforge/meta/MetaRepr {
+	public static final field Companion Lhep/dataforge/io/IOFormatFactory$Companion;
+	public static final field IO_FORMAT_TYPE Ljava/lang/String;
+	public abstract fun getType ()Lkotlin/reflect/KClass;
+	public abstract fun toMeta ()Lhep/dataforge/meta/Meta;
+}
+
+public final class hep/dataforge/io/IOFormatFactory$Companion {
+	public static final field IO_FORMAT_TYPE Ljava/lang/String;
+}
+
+public final class hep/dataforge/io/IOFormatFactory$DefaultImpls {
+	public static fun toMeta (Lhep/dataforge/io/IOFormatFactory;)Lhep/dataforge/meta/Meta;
+}
+
+public final class hep/dataforge/io/IOFormatKt {
+	public static final fun fill (Lkotlinx/io/pool/ObjectPool;Lkotlin/jvm/functions/Function1;)Ljava/nio/ByteBuffer;
+	public static final fun readWith (Lkotlinx/io/Binary;Lhep/dataforge/io/IOFormat;)Ljava/lang/Object;
+	public static final fun readWith (Lkotlinx/io/Input;Lhep/dataforge/io/IOFormat;)Ljava/lang/Object;
+	public static final fun toBinary (Lhep/dataforge/io/IOFormat;Ljava/lang/Object;)Lkotlinx/io/Binary;
+	public static final fun writeWith (Lkotlinx/io/Output;Lhep/dataforge/io/IOFormat;Ljava/lang/Object;)V
+}
+
+public final class hep/dataforge/io/IOPlugin : hep/dataforge/context/AbstractPlugin {
+	public static final field Companion Lhep/dataforge/io/IOPlugin$Companion;
+	public fun <init> (Lhep/dataforge/meta/Meta;)V
+	public fun content (Ljava/lang/String;)Ljava/util/Map;
+	public final fun getEnvelopeFormatFactories ()Ljava/util/Collection;
+	public final fun getIoFormatFactories ()Ljava/util/Collection;
+	public final fun getMetaFormatFactories ()Ljava/util/Collection;
+	public fun getTag ()Lhep/dataforge/context/PluginTag;
+	public final fun resolveEnvelopeFormat (Lhep/dataforge/meta/TypedMetaItem;)Lhep/dataforge/io/EnvelopeFormat;
+	public final fun resolveIOFormat (Lhep/dataforge/meta/TypedMetaItem;Lkotlin/reflect/KClass;)Lhep/dataforge/io/IOFormat;
+	public final fun resolveMetaFormat (Ljava/lang/String;Lhep/dataforge/meta/Meta;)Lhep/dataforge/io/MetaFormat;
+	public final fun resolveMetaFormat (SLhep/dataforge/meta/Meta;)Lhep/dataforge/io/MetaFormat;
+	public static synthetic fun resolveMetaFormat$default (Lhep/dataforge/io/IOPlugin;Ljava/lang/String;Lhep/dataforge/meta/Meta;ILjava/lang/Object;)Lhep/dataforge/io/MetaFormat;
+	public static synthetic fun resolveMetaFormat$default (Lhep/dataforge/io/IOPlugin;SLhep/dataforge/meta/Meta;ILjava/lang/Object;)Lhep/dataforge/io/MetaFormat;
+}
+
+public final class hep/dataforge/io/IOPlugin$Companion : hep/dataforge/context/PluginFactory {
+	public final fun getDefaultEnvelopeFormats ()Ljava/util/List;
+	public final fun getDefaultMetaFormats ()Ljava/util/List;
+	public fun getTag ()Lhep/dataforge/context/PluginTag;
+	public fun getType ()Lkotlin/reflect/KClass;
+	public fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Lhep/dataforge/io/IOPlugin;
+	public synthetic fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Ljava/lang/Object;
+}
+
+public final class hep/dataforge/io/IOPluginKt {
+	public static final fun getIo (Lhep/dataforge/context/Context;)Lhep/dataforge/io/IOPlugin;
+}
+
+public final class hep/dataforge/io/IoMiscKt {
+	public static final fun Binary (ILkotlin/jvm/functions/Function1;)Lkotlinx/io/Binary;
+	public static synthetic fun Binary$default (ILkotlin/jvm/functions/Function1;ILjava/lang/Object;)Lkotlinx/io/Binary;
+	public static final fun buildByteArray (ILkotlin/jvm/functions/Function1;)[B
+	public static synthetic fun buildByteArray$default (ILkotlin/jvm/functions/Function1;ILjava/lang/Object;)[B
+	public static final fun get (Lkotlinx/io/Binary;Lkotlin/ranges/IntRange;)Lhep/dataforge/io/BinaryView;
+	public static final fun readRawString (Lkotlinx/io/Input;I)Ljava/lang/String;
+	public static final fun view (Lkotlinx/io/Binary;II)Lhep/dataforge/io/BinaryView;
+	public static final fun writeRawString (Lkotlinx/io/Output;Ljava/lang/String;)V
+}
+
+public final class hep/dataforge/io/JsonMetaFormat : hep/dataforge/io/MetaFormat {
+	public static final field Companion Lhep/dataforge/io/JsonMetaFormat$Companion;
+	public fun <init> ()V
+	public fun <init> (Lkotlinx/serialization/json/Json;)V
+	public synthetic fun <init> (Lkotlinx/serialization/json/Json;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun readMeta (Lkotlinx/io/Input;Lhep/dataforge/meta/descriptors/NodeDescriptor;)Lhep/dataforge/meta/Meta;
+	public fun readObject (Lkotlinx/io/Input;)Lhep/dataforge/meta/Meta;
+	public synthetic fun readObject (Lkotlinx/io/Input;)Ljava/lang/Object;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+	public fun writeMeta (Lkotlinx/io/Output;Lhep/dataforge/meta/Meta;Lhep/dataforge/meta/descriptors/NodeDescriptor;)V
+	public fun writeObject (Lkotlinx/io/Output;Lhep/dataforge/meta/Meta;)V
+	public synthetic fun writeObject (Lkotlinx/io/Output;Ljava/lang/Object;)V
+}
+
+public final class hep/dataforge/io/JsonMetaFormat$Companion : hep/dataforge/io/MetaFormatFactory {
+	public final fun getDEFAULT_JSON ()Lkotlinx/serialization/json/Json;
+	public fun getKey ()S
+	public fun getName ()Lhep/dataforge/names/Name;
+	public fun getShortName ()Ljava/lang/String;
+	public fun getType ()Lkotlin/reflect/KClass;
+	public fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Lhep/dataforge/io/MetaFormat;
+	public synthetic fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Ljava/lang/Object;
+	public fun readMeta (Lkotlinx/io/Input;Lhep/dataforge/meta/descriptors/NodeDescriptor;)Lhep/dataforge/meta/Meta;
+	public fun readObject (Lkotlinx/io/Input;)Lhep/dataforge/meta/Meta;
+	public synthetic fun readObject (Lkotlinx/io/Input;)Ljava/lang/Object;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+	public fun writeMeta (Lkotlinx/io/Output;Lhep/dataforge/meta/Meta;Lhep/dataforge/meta/descriptors/NodeDescriptor;)V
+	public fun writeObject (Lkotlinx/io/Output;Lhep/dataforge/meta/Meta;)V
+	public synthetic fun writeObject (Lkotlinx/io/Output;Ljava/lang/Object;)V
+}
+
+public final class hep/dataforge/io/ListIOFormat : hep/dataforge/io/IOFormat {
+	public fun <init> (Lhep/dataforge/io/IOFormat;)V
+	public final fun getFormat ()Lhep/dataforge/io/IOFormat;
+	public synthetic fun readObject (Lkotlinx/io/Input;)Ljava/lang/Object;
+	public fun readObject (Lkotlinx/io/Input;)Ljava/util/List;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+	public synthetic fun writeObject (Lkotlinx/io/Output;Ljava/lang/Object;)V
+	public fun writeObject (Lkotlinx/io/Output;Ljava/util/List;)V
+}
+
+public abstract interface class hep/dataforge/io/MetaFormat : hep/dataforge/io/IOFormat {
+	public abstract fun readMeta (Lkotlinx/io/Input;Lhep/dataforge/meta/descriptors/NodeDescriptor;)Lhep/dataforge/meta/Meta;
+	public abstract fun readObject (Lkotlinx/io/Input;)Lhep/dataforge/meta/Meta;
+	public abstract fun writeMeta (Lkotlinx/io/Output;Lhep/dataforge/meta/Meta;Lhep/dataforge/meta/descriptors/NodeDescriptor;)V
+	public abstract fun writeObject (Lkotlinx/io/Output;Lhep/dataforge/meta/Meta;)V
+}
+
+public final class hep/dataforge/io/MetaFormat$DefaultImpls {
+	public static synthetic fun readMeta$default (Lhep/dataforge/io/MetaFormat;Lkotlinx/io/Input;Lhep/dataforge/meta/descriptors/NodeDescriptor;ILjava/lang/Object;)Lhep/dataforge/meta/Meta;
+	public static fun readObject (Lhep/dataforge/io/MetaFormat;Lkotlinx/io/Input;)Lhep/dataforge/meta/Meta;
+	public static synthetic fun writeMeta$default (Lhep/dataforge/io/MetaFormat;Lkotlinx/io/Output;Lhep/dataforge/meta/Meta;Lhep/dataforge/meta/descriptors/NodeDescriptor;ILjava/lang/Object;)V
+	public static fun writeObject (Lhep/dataforge/io/MetaFormat;Lkotlinx/io/Output;Lhep/dataforge/meta/Meta;)V
+}
+
+public abstract interface class hep/dataforge/io/MetaFormatFactory : hep/dataforge/io/IOFormatFactory, hep/dataforge/io/MetaFormat {
+	public static final field Companion Lhep/dataforge/io/MetaFormatFactory$Companion;
+	public static final field META_FORMAT_TYPE Ljava/lang/String;
+	public abstract fun getKey ()S
+	public abstract fun getName ()Lhep/dataforge/names/Name;
+	public abstract fun getShortName ()Ljava/lang/String;
+	public abstract fun getType ()Lkotlin/reflect/KClass;
+	public abstract fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Lhep/dataforge/io/MetaFormat;
+}
+
+public final class hep/dataforge/io/MetaFormatFactory$Companion {
+	public static final field META_FORMAT_TYPE Ljava/lang/String;
+}
+
+public final class hep/dataforge/io/MetaFormatFactory$DefaultImpls {
+	public static fun getKey (Lhep/dataforge/io/MetaFormatFactory;)S
+	public static fun getName (Lhep/dataforge/io/MetaFormatFactory;)Lhep/dataforge/names/Name;
+	public static fun getType (Lhep/dataforge/io/MetaFormatFactory;)Lkotlin/reflect/KClass;
+	public static fun readObject (Lhep/dataforge/io/MetaFormatFactory;Lkotlinx/io/Input;)Lhep/dataforge/meta/Meta;
+	public static fun toMeta (Lhep/dataforge/io/MetaFormatFactory;)Lhep/dataforge/meta/Meta;
+	public static fun writeObject (Lhep/dataforge/io/MetaFormatFactory;Lkotlinx/io/Output;Lhep/dataforge/meta/Meta;)V
+}
+
+public final class hep/dataforge/io/MetaFormatKt {
+	public static final fun parse (Lhep/dataforge/io/MetaFormat;Ljava/lang/String;)Lhep/dataforge/meta/Meta;
+	public static final fun parse (Lhep/dataforge/io/MetaFormatFactory;Ljava/lang/String;Lhep/dataforge/meta/Meta;)Lhep/dataforge/meta/Meta;
+	public static final fun toString (Lhep/dataforge/meta/Meta;Lhep/dataforge/io/MetaFormat;)Ljava/lang/String;
+	public static final fun toString (Lhep/dataforge/meta/Meta;Lhep/dataforge/io/MetaFormatFactory;)Ljava/lang/String;
+}
+
+public final class hep/dataforge/io/PartialEnvelope {
+	public synthetic fun <init> (Lhep/dataforge/meta/Meta;ILkotlin/ULong;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Lhep/dataforge/meta/Meta;
+	public final fun component2-pVg5ArA ()I
+	public final fun component3-6VbMDqA ()Lkotlin/ULong;
+	public final fun copy-BMK4sig (Lhep/dataforge/meta/Meta;ILkotlin/ULong;)Lhep/dataforge/io/PartialEnvelope;
+	public static synthetic fun copy-BMK4sig$default (Lhep/dataforge/io/PartialEnvelope;Lhep/dataforge/meta/Meta;ILkotlin/ULong;ILjava/lang/Object;)Lhep/dataforge/io/PartialEnvelope;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getDataOffset-pVg5ArA ()I
+	public final fun getDataSize-6VbMDqA ()Lkotlin/ULong;
+	public final fun getMeta ()Lhep/dataforge/meta/Meta;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class hep/dataforge/io/ProxyEnvelope : hep/dataforge/io/Envelope {
+	public fun <init> (Lhep/dataforge/io/Envelope;[Lhep/dataforge/meta/Meta;)V
+	public fun getData ()Lkotlinx/io/Binary;
+	public fun getMeta ()Lhep/dataforge/meta/Laminate;
+	public synthetic fun getMeta ()Lhep/dataforge/meta/Meta;
+	public final fun getSource ()Lhep/dataforge/io/Envelope;
+}
+
+public abstract interface class hep/dataforge/io/Responder {
+	public abstract fun respond (Lhep/dataforge/io/Envelope;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
+}
+
+public final class hep/dataforge/io/SimpleEnvelope : hep/dataforge/io/Envelope {
+	public fun <init> (Lhep/dataforge/meta/Meta;Lkotlinx/io/Binary;)V
+	public fun getData ()Lkotlinx/io/Binary;
+	public fun getMeta ()Lhep/dataforge/meta/Meta;
+}
+
+public final class hep/dataforge/io/StreamsIOKt {
+	public static final fun read (Ljava/io/InputStream;ILkotlin/jvm/functions/Function1;)Ljava/lang/Object;
+	public static final fun read (Ljava/io/InputStream;Lkotlin/jvm/functions/Function1;)Ljava/lang/Object;
+	public static final fun readBlocking (Ljava/io/InputStream;Lkotlin/jvm/functions/Function1;)Ljava/lang/Object;
+	public static final fun write (Ljava/io/OutputStream;Lkotlin/jvm/functions/Function1;)V
+}
+
+public final class hep/dataforge/io/TaggedEnvelopeFormat : hep/dataforge/io/EnvelopeFormat {
+	public static final field Companion Lhep/dataforge/io/TaggedEnvelopeFormat$Companion;
+	public fun <init> (Lhep/dataforge/io/IOPlugin;Lhep/dataforge/io/TaggedEnvelopeFormat$VERSION;)V
+	public synthetic fun <init> (Lhep/dataforge/io/IOPlugin;Lhep/dataforge/io/TaggedEnvelopeFormat$VERSION;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun getDefaultMetaFormat ()Lhep/dataforge/io/MetaFormatFactory;
+	public final fun getIo ()Lhep/dataforge/io/IOPlugin;
+	public final fun getVersion ()Lhep/dataforge/io/TaggedEnvelopeFormat$VERSION;
+	public fun readObject (Lkotlinx/io/Input;)Lhep/dataforge/io/Envelope;
+	public synthetic fun readObject (Lkotlinx/io/Input;)Ljava/lang/Object;
+	public fun readPartial (Lkotlinx/io/Input;)Lhep/dataforge/io/PartialEnvelope;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+	public fun writeEnvelope (Lkotlinx/io/Output;Lhep/dataforge/io/Envelope;Lhep/dataforge/io/MetaFormatFactory;Lhep/dataforge/meta/Meta;)V
+	public fun writeObject (Lkotlinx/io/Output;Lhep/dataforge/io/Envelope;)V
+	public synthetic fun writeObject (Lkotlinx/io/Output;Ljava/lang/Object;)V
+}
+
+public final class hep/dataforge/io/TaggedEnvelopeFormat$Companion : hep/dataforge/io/EnvelopeFormatFactory {
+	public fun getDefaultMetaFormat ()Lhep/dataforge/io/MetaFormatFactory;
+	public fun getName ()Lhep/dataforge/names/Name;
+	public fun getType ()Lkotlin/reflect/KClass;
+	public fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Lhep/dataforge/io/EnvelopeFormat;
+	public synthetic fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Ljava/lang/Object;
+	public fun peekFormat (Lhep/dataforge/io/IOPlugin;Lkotlinx/io/Input;)Lhep/dataforge/io/EnvelopeFormat;
+	public fun readObject (Lkotlinx/io/Input;)Lhep/dataforge/io/Envelope;
+	public synthetic fun readObject (Lkotlinx/io/Input;)Ljava/lang/Object;
+	public fun readPartial (Lkotlinx/io/Input;)Lhep/dataforge/io/PartialEnvelope;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+	public fun writeEnvelope (Lkotlinx/io/Output;Lhep/dataforge/io/Envelope;Lhep/dataforge/io/MetaFormatFactory;Lhep/dataforge/meta/Meta;)V
+	public fun writeObject (Lkotlinx/io/Output;Lhep/dataforge/io/Envelope;)V
+	public synthetic fun writeObject (Lkotlinx/io/Output;Ljava/lang/Object;)V
+}
+
+public final class hep/dataforge/io/TaggedEnvelopeFormat$VERSION : java/lang/Enum {
+	public static final field DF02 Lhep/dataforge/io/TaggedEnvelopeFormat$VERSION;
+	public static final field DF03 Lhep/dataforge/io/TaggedEnvelopeFormat$VERSION;
+	public final fun getTagSize-pVg5ArA ()I
+	public static fun valueOf (Ljava/lang/String;)Lhep/dataforge/io/TaggedEnvelopeFormat$VERSION;
+	public static fun values ()[Lhep/dataforge/io/TaggedEnvelopeFormat$VERSION;
+}
+
+public final class hep/dataforge/io/TaglessEnvelopeFormat : hep/dataforge/io/EnvelopeFormat {
+	public static final field Companion Lhep/dataforge/io/TaglessEnvelopeFormat$Companion;
+	public static final field DATA_LENGTH_PROPERTY Ljava/lang/String;
+	public static final field DATA_START_PROPERTY Ljava/lang/String;
+	public static final field DEFAULT_DATA_START Ljava/lang/String;
+	public static final field DEFAULT_META_START Ljava/lang/String;
+	public static final field META_LENGTH_PROPERTY Ljava/lang/String;
+	public static final field META_START_PROPERTY Ljava/lang/String;
+	public static final field META_TYPE_PROPERTY Ljava/lang/String;
+	public static final field TAGLESS_ENVELOPE_HEADER Ljava/lang/String;
+	public static final field TAGLESS_ENVELOPE_TYPE Ljava/lang/String;
+	public static final field code I
+	public fun <init> (Lhep/dataforge/io/IOPlugin;Lhep/dataforge/meta/Meta;)V
+	public synthetic fun <init> (Lhep/dataforge/io/IOPlugin;Lhep/dataforge/meta/Meta;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun getDefaultMetaFormat ()Lhep/dataforge/io/MetaFormatFactory;
+	public final fun getIo ()Lhep/dataforge/io/IOPlugin;
+	public final fun getMeta ()Lhep/dataforge/meta/Meta;
+	public fun readObject (Lkotlinx/io/Input;)Lhep/dataforge/io/Envelope;
+	public synthetic fun readObject (Lkotlinx/io/Input;)Ljava/lang/Object;
+	public fun readPartial (Lkotlinx/io/Input;)Lhep/dataforge/io/PartialEnvelope;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+	public fun writeEnvelope (Lkotlinx/io/Output;Lhep/dataforge/io/Envelope;Lhep/dataforge/io/MetaFormatFactory;Lhep/dataforge/meta/Meta;)V
+	public fun writeObject (Lkotlinx/io/Output;Lhep/dataforge/io/Envelope;)V
+	public synthetic fun writeObject (Lkotlinx/io/Output;Ljava/lang/Object;)V
+}
+
+public final class hep/dataforge/io/TaglessEnvelopeFormat$Companion : hep/dataforge/io/EnvelopeFormatFactory {
+	public fun getDefaultMetaFormat ()Lhep/dataforge/io/MetaFormatFactory;
+	public fun getName ()Lhep/dataforge/names/Name;
+	public fun getType ()Lkotlin/reflect/KClass;
+	public fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Lhep/dataforge/io/EnvelopeFormat;
+	public synthetic fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Ljava/lang/Object;
+	public fun peekFormat (Lhep/dataforge/io/IOPlugin;Lkotlinx/io/Input;)Lhep/dataforge/io/EnvelopeFormat;
+	public fun readObject (Lkotlinx/io/Input;)Lhep/dataforge/io/Envelope;
+	public synthetic fun readObject (Lkotlinx/io/Input;)Ljava/lang/Object;
+	public fun readPartial (Lkotlinx/io/Input;)Lhep/dataforge/io/PartialEnvelope;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+	public fun writeEnvelope (Lkotlinx/io/Output;Lhep/dataforge/io/Envelope;Lhep/dataforge/io/MetaFormatFactory;Lhep/dataforge/meta/Meta;)V
+	public fun writeObject (Lkotlinx/io/Output;Lhep/dataforge/io/Envelope;)V
+	public synthetic fun writeObject (Lkotlinx/io/Output;Ljava/lang/Object;)V
+}
+
+public final class hep/dataforge/io/ValueIOFormat : hep/dataforge/io/IOFormat, hep/dataforge/io/IOFormatFactory {
+	public static final field INSTANCE Lhep/dataforge/io/ValueIOFormat;
+	public fun getName ()Lhep/dataforge/names/Name;
+	public fun getType ()Lkotlin/reflect/KClass;
+	public fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Lhep/dataforge/io/IOFormat;
+	public synthetic fun invoke (Lhep/dataforge/meta/Meta;Lhep/dataforge/context/Context;)Ljava/lang/Object;
+	public fun readObject (Lkotlinx/io/Input;)Lhep/dataforge/values/Value;
+	public synthetic fun readObject (Lkotlinx/io/Input;)Ljava/lang/Object;
+	public fun toMeta ()Lhep/dataforge/meta/Meta;
+	public fun writeObject (Lkotlinx/io/Output;Lhep/dataforge/values/Value;)V
+	public synthetic fun writeObject (Lkotlinx/io/Output;Ljava/lang/Object;)V
+}
+